import { HttpException } from '@nestjs/common';
import { submoduloHabilitado } from '../../auth/guards/submodulo.guard';
import { isContabilidadEnabledForEmpresa, isModuleEnabledForEmpresa } from '../../common/utils/module-access.util';
import { tienePrivilegio } from '../../inmobiliario/common/inm-utils';
import { TesMovimientosService } from './tes-movimientos.service';
import { noEncontrado } from '../../common/utils/error-estructurado';

jest.mock('../../common/utils/module-access.util', () => ({ isContabilidadEnabledForEmpresa: jest.fn(), isModuleEnabledForEmpresa: jest.fn() }));
jest.mock('../../auth/guards/submodulo.guard', () => ({ submoduloHabilitado: jest.fn() }));
jest.mock('../../inmobiliario/common/inm-utils', () => ({ tienePrivilegio: jest.fn() }));
const contabilidad = isContabilidadEnabledForEmpresa as jest.Mock;
const moduloHabilitado = isModuleEnabledForEmpresa as jest.Mock;
const submodulo = submoduloHabilitado as jest.Mock;
const privilegio = tienePrivilegio as jest.Mock;

const UUID = '11111111-1111-4111-8111-111111111111';
const EMP = 'emp';
const USER = 'user-1';

const movBase = (o: Record<string, unknown> = {}) => ({
  id: 'm1',
  empresa_id: EMP,
  cuenta_id: 'cta',
  tipo: 'INGRESO',
  estado: 'BORRADOR',
  fecha: new Date('2026-05-05'),
  monto: 150000,
  descripcion: 'Depósito',
  referencia: null,
  requiere_aprobacion: false,
  aprobado_por: null,
  origen_tipo: null,
  origen_id: null,
  detalles: [{ categoria_id: 'c1', monto: 150000 }],
  // Lo que agrega el include de la fila (findOne con la forma del listado, S3).
  extracto_lineas: [],
  ...o,
});

interface Opciones {
  cuenta?: Record<string, unknown> | null;
  umbral?: number | null;
  /** Moneda base de la empresa (por defecto PYG; null = sin moneda principal cargada). */
  base?: string | null;
  /** Cotización vigente de la moneda de la cuenta, en la base (`tasa`); por defecto sin cotización. */
  tasa?: number | null;
  catalogo?: Array<Record<string, unknown>>;
  embarque?: Record<string, unknown> | null;
  embarqueExistente?: boolean;
  movimiento?: Record<string, unknown> | null;
  updateMany?: number;
  deleteMany?: number;
  conciliado?: boolean;
  integrador?: () => Promise<unknown>;
  constancia?: Record<string, unknown> | null;
}

function armar(o: Opciones = {}) {
  const prisma: any = {
    $transaction: jest.fn().mockImplementation((cb: any) => cb(tx)),
    tes_cuentas: {
      findFirst: jest.fn().mockResolvedValue(o.cuenta === undefined ? { id: 'cta', empresa_id: EMP, activo: true, moneda: 'PYG', saldo_inicial: 0, saldo_actual: 0 } : o.cuenta),
      findMany: jest.fn().mockResolvedValue([]),
      update: jest.fn().mockResolvedValue({}),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue(o.base === null ? null : { moneda_id: 'mb' }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue(o.base === null ? null : { id: 'mb' }),
      findUnique: jest.fn().mockResolvedValue(o.base === null ? null : { id: 'mb', codigo: o.base ?? 'PYG' }),
    },
    tes_categorias: { findMany: jest.fn().mockResolvedValue(o.catalogo ?? [{ id: 'c1', tipo: 'AMBOS', activo: true, empresa_id: EMP, is_sistema: false }]) },
    imp_embarques: { findFirst: jest.fn().mockResolvedValue(o.embarque === undefined ? { estado: 'EN_TRANSITO', numero: 'IMP-1' } : o.embarque) },
    tes_movimientos: {
      create: jest.fn().mockImplementation(({ data }: any) => Promise.resolve({ id: 'm1', ...data })),
      findFirst: jest
        .fn()
        .mockImplementation(({ where }: any) =>
          Promise.resolve(where?.embarque_id ? (o.embarqueExistente ? { id: 'otro' } : null) : o.movimiento === undefined ? movBase() : o.movimiento),
        ),
      updateMany: jest.fn().mockResolvedValue({ count: o.updateMany ?? 1 }),
      deleteMany: jest.fn().mockResolvedValue({ count: o.deleteMany ?? 1 }),
      update: jest.fn().mockResolvedValue({}),
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockResolvedValue(0),
      groupBy: jest.fn().mockResolvedValue([]),
    },
    tes_movimiento_det: { createMany: jest.fn().mockResolvedValue({ count: 1 }), deleteMany: jest.fn().mockResolvedValue({ count: 1 }) },
    tes_extracto_lineas: { findFirst: jest.fn().mockResolvedValue(o.conciliado ? { id: 'l1' } : null) },
    audit_logs: { findFirst: jest.fn().mockResolvedValue(o.constancia ?? null) },
    usuario: { findMany: jest.fn().mockResolvedValue([]) },
  };
  // La transacción es OTRO objeto (M1): las escrituras de una acción atómica tienen que ir por `tx`. Los mocks de escritura son los de
  // `prisma` (para no tocar las aserciones), pero cada uno anota en `fuera` si lo llamaron sin pasar por `tx`.
  const fuera: string[] = [];
  let porTx = false;
  const vigilar = (nombre: string, fn: jest.Mock, valor: () => unknown) =>
    fn.mockImplementation(() => {
      if (!porTx) fuera.push(nombre);
      return Promise.resolve(valor());
    });
  const porTransaccion =
    (fn: jest.Mock) =>
    (...a: unknown[]) => {
      porTx = true;
      try {
        return fn(...a);
      } finally {
        porTx = false;
      }
    };
  vigilar('tes_cuentas.update', prisma.tes_cuentas.update, () => ({}));
  vigilar('tes_movimientos.updateMany', prisma.tes_movimientos.updateMany, () => ({ count: o.updateMany ?? 1 }));
  vigilar('tes_movimientos.deleteMany', prisma.tes_movimientos.deleteMany, () => ({ count: o.deleteMany ?? 1 }));
  vigilar('det.createMany', prisma.tes_movimiento_det.createMany, () => ({ count: 1 }));
  vigilar('det.deleteMany', prisma.tes_movimiento_det.deleteMany, () => ({ count: 1 }));
  prisma.tes_movimientos.create.mockImplementation(({ data }: any) => {
    if (!porTx) fuera.push('tes_movimientos.create');
    return Promise.resolve({ id: 'm1', ...data });
  });
  const tx: any = {
    $queryRaw: jest.fn().mockResolvedValue([{ id: 'm1' }]),
    tes_movimientos: {
      create: porTransaccion(prisma.tes_movimientos.create),
      updateMany: porTransaccion(prisma.tes_movimientos.updateMany),
      deleteMany: porTransaccion(prisma.tes_movimientos.deleteMany),
    },
    tes_cuentas: { update: porTransaccion(prisma.tes_cuentas.update) },
    tes_movimiento_det: { createMany: porTransaccion(prisma.tes_movimiento_det.createMany), deleteMany: porTransaccion(prisma.tes_movimiento_det.deleteMany) },
    tes_extracto_lineas: { findFirst: (...a: unknown[]) => prisma.tes_extracto_lineas.findFirst(...a) },
  };
  const integracion: any = {
    integrarMovimientoTesoreria: jest.fn().mockImplementation(o.integrador ?? (() => Promise.resolve({ generado: true }))),
    revertirDocumento: jest.fn().mockResolvedValue(undefined),
  };
  const config: any = { get: jest.fn().mockResolvedValue(o.umbral == null ? null : { monto_umbral_aprobacion: o.umbral }) };
  const monedas: any = {
    getCotizacionVigente: jest.fn().mockImplementation((_e: string, codigo: string) =>
      Promise.resolve(
        o.tasa == null
          ? { tasa: 1, fecha_efectiva: null, fuente: 'fallback', moneda_codigo: codigo, warning: 'Sin cotización' }
          : { tasa: o.tasa, fecha_efectiva: '2026-05-05', fuente: 'facturacion', moneda_codigo: codigo },
      ),
    ),
  };
  return { prisma, tx, fuera, integracion, config, monedas, servicio: new TesMovimientosService(prisma, integracion, config, monedas) };
}

const alta = (o: Record<string, unknown> = {}) => ({
  cuenta_id: 'cta',
  tipo: 'INGRESO',
  fecha: '2026-05-05',
  monto: 150000,
  descripcion: 'Depósito',
  categorias: [{ categoria_id: 'c1', monto: 150000 }],
  ...o,
});

const falla = async (p: Promise<unknown>) => {
  try {
    await p;
  } catch (e: any) {
    if (!(e instanceof HttpException)) throw e;
    const r = e.getResponse() as Record<string, unknown>;
    return { status: e.getStatus(), ...(typeof r === 'string' ? { message: r } : r) } as Record<string, any>;
  }
  throw new Error('no lanzó');
};

beforeEach(() => {
  contabilidad.mockReset().mockResolvedValue(true);
  moduloHabilitado.mockReset().mockResolvedValue(true);
  submodulo.mockReset().mockResolvedValue({ habilitado: true });
  privilegio.mockReset().mockResolvedValue(true);
});

describe('alta', () => {
  it('sin accion → BORRADOR: no toca el saldo, no integra y asiento es null', async () => {
    const { prisma, integracion, servicio } = armar();
    const r: any = await servicio.create(alta() as never, EMP, USER);
    expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'BORRADOR', requiere_aprobacion: false });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
    expect(integracion.integrarMovimientoTesoreria).not.toHaveBeenCalled();
    expect(r).toMatchObject({ id: 'm1', estado: 'BORRADOR', asiento: null });
  });

  it('CONFIRMAR sin umbral → una transacción: CONFIRMADO con confirmado_por/en, detalles, saldo una vez; sin updateMany; integra una vez', async () => {
    const { prisma, integracion, servicio } = armar();
    const r: any = await servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER);
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'CONFIRMADO', confirmado_por: USER, confirmado_en: expect.any(Date) });
    expect(prisma.tes_movimiento_det.createMany).toHaveBeenCalledTimes(1);
    expect(prisma.tes_cuentas.update).toHaveBeenCalledTimes(1);
    expect(prisma.tes_cuentas.update.mock.calls[0][0]).toMatchObject({ where: { id: 'cta' }, data: { saldo_actual: { increment: 150000 } } });
    expect(prisma.tes_movimientos.updateMany).not.toHaveBeenCalled();
    expect(integracion.integrarMovimientoTesoreria).toHaveBeenCalledTimes(1);
    expect(r.asiento).toEqual({ generado: true, motivo: null });
  });

  it('un egreso confirmado resta del saldo', async () => {
    const { prisma, servicio } = armar();
    await servicio.create(alta({ accion: 'CONFIRMAR', tipo: 'EGRESO' }) as never, EMP, USER);
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.saldo_actual.increment).toBe(-150000);
  });

  it('CONFIRMAR con umbral 1000 y monto 1500 → BORRADOR con requiere_aprobacion, saldo intacto y asiento null', async () => {
    const { prisma, integracion, servicio } = armar({ umbral: 1000 });
    const r: any = await servicio.create(alta({ accion: 'CONFIRMAR', monto: 1500, categorias: [{ categoria_id: 'c1', monto: 1500 }] }) as never, EMP, USER);
    expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'BORRADOR', requiere_aprobacion: true });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
    expect(integracion.integrarMovimientoTesoreria).not.toHaveBeenCalled();
    expect(r).toMatchObject({ estado: 'BORRADOR', asiento: null });
  });

  describe('umbral de aprobación en moneda base', () => {
    const usd = { id: 'cta', empresa_id: EMP, activo: true, moneda: 'USD', saldo_inicial: 0, saldo_actual: 0 };
    const altaUsd = (monto: number) => alta({ accion: 'CONFIRMAR', monto, categorias: [{ categoria_id: 'c1', monto }] }) as never;

    it('cuenta USD, cotización 7.500, umbral Gs. 5.000.000: USD 700 (Gs. 5.250.000) requiere aprobación', async () => {
      const { prisma, monedas, servicio } = armar({ umbral: 5_000_000, cuenta: usd, tasa: 7500 });
      await servicio.create(altaUsd(700), EMP, USER);
      expect(monedas.getCotizacionVigente).toHaveBeenCalledWith(EMP, 'USD', expect.any(Date));
      expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'BORRADOR', requiere_aprobacion: true });
    });

    it('cuenta USD: USD 600 (Gs. 4.500.000) no alcanza el umbral y se confirma', async () => {
      const { prisma, servicio } = armar({ umbral: 5_000_000, cuenta: usd, tasa: 7500 });
      await servicio.create(altaUsd(600), EMP, USER);
      expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'CONFIRMADO', requiere_aprobacion: false });
    });

    it('cuenta USD sin cotización: falla del lado seguro, requiere aprobación', async () => {
      const { prisma, servicio } = armar({ umbral: 5_000_000, cuenta: usd, tasa: null });
      await servicio.create(altaUsd(1), EMP, USER);
      expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'BORRADOR', requiere_aprobacion: true });
    });

    it('sin moneda base cargada y umbral activo: requiere aprobación', async () => {
      const { prisma, servicio } = armar({ umbral: 5_000_000, base: null });
      await servicio.create(altaUsd(1), EMP, USER);
      expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ requiere_aprobacion: true });
    });

    it('cuenta PYG: se compara el monto tal cual y no pide cotización', async () => {
      const { prisma, monedas, servicio } = armar({ umbral: 5_000_000 });
      await servicio.create(altaUsd(4_999_999), EMP, USER);
      expect(monedas.getCotizacionVigente).not.toHaveBeenCalled();
      expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'CONFIRMADO', requiere_aprobacion: false });
    });

    it('umbral 0: nunca requiere aprobación, aunque no haya cotización', async () => {
      const { prisma, servicio } = armar({ umbral: 0, cuenta: usd, tasa: null });
      await servicio.create(altaUsd(1_000_000), EMP, USER);
      expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ estado: 'CONFIRMADO', requiere_aprobacion: false });
    });
  });

  it('cuenta cerrada o ajena → CUENTA_INVALIDA en cuenta_id', async () => {
    const { servicio } = armar({ cuenta: null });
    expect(await falla(servicio.create(alta() as never, EMP, USER))).toMatchObject({ status: 400, codigo: 'CUENTA_INVALIDA', campo: 'cuenta_id' });
  });

  it('la cuenta se busca activa y de la empresa', async () => {
    const { prisma, servicio } = armar();
    await servicio.create(alta() as never, EMP, USER);
    expect(prisma.tes_cuentas.findFirst.mock.calls[0][0].where).toEqual({ id: 'cta', empresa_id: EMP, activo: true });
  });

  it('suma distinta → CATEGORIAS_NO_SUMAN sin escribir', async () => {
    const { prisma, servicio } = armar();
    expect(await falla(servicio.create(alta({ categorias: [{ categoria_id: 'c1', monto: 10 }] }) as never, EMP, USER))).toMatchObject({ codigo: 'CATEGORIAS_NO_SUMAN' });
    expect(prisma.$transaction).not.toHaveBeenCalled();
    expect(prisma.tes_movimientos.create).not.toHaveBeenCalled();
  });

  it('el catálogo se lee con findMany por los ids pedidos', async () => {
    const { prisma, servicio } = armar();
    await servicio.create(alta() as never, EMP, USER);
    expect(prisma.tes_categorias.findMany.mock.calls[0][0].where).toEqual({ id: { in: ['c1'] } });
  });

  describe('embarque', () => {
    const conEmbarque = { embarque_id: UUID, tipo_pago_importacion: 'PROVEEDOR', tipo: 'EGRESO' };
    it('sin IMPORTACIONES → IMPORTACIONES_NO_CONTRATADA en embarque_id', async () => {
      moduloHabilitado.mockResolvedValue(false);
      expect(await falla(armar().servicio.create(alta(conEmbarque) as never, EMP, USER))).toMatchObject({ codigo: 'IMPORTACIONES_NO_CONTRATADA', campo: 'embarque_id' });
    });
    it('con el módulo y IMP_EMBARQUES deshabilitado → igual', async () => {
      submodulo.mockResolvedValue({ habilitado: false });
      expect(await falla(armar().servicio.create(alta(conEmbarque) as never, EMP, USER))).toMatchObject({ codigo: 'IMPORTACIONES_NO_CONTRATADA' });
    });
    it('con los dos y sin IMP_EMB_EMBARQUE_VER → igual', async () => {
      privilegio.mockResolvedValue(false);
      const { servicio } = armar();
      expect(await falla(servicio.create(alta(conEmbarque) as never, EMP, USER))).toMatchObject({ codigo: 'IMPORTACIONES_NO_CONTRATADA' });
      expect(privilegio.mock.calls[0].slice(1)).toEqual([USER, 'IMP_EMB_EMBARQUE_VER']);
      expect(submodulo.mock.calls[0].slice(1, 3)).toEqual([EMP, 'IMP_EMBARQUES']);
    });
    it('embarque CERRADO / inexistente / ya pagado ese tipo', async () => {
      expect(await falla(armar({ embarque: { estado: 'CERRADO', numero: 'IMP-1' } }).servicio.create(alta(conEmbarque) as never, EMP, USER))).toMatchObject({
        codigo: 'EMBARQUE_CERRADO',
      });
      expect(await falla(armar({ embarque: null }).servicio.create(alta(conEmbarque) as never, EMP, USER))).toMatchObject({ codigo: 'EMBARQUE_INVALIDO' });
      expect(await falla(armar({ embarqueExistente: true }).servicio.create(alta(conEmbarque) as never, EMP, USER))).toMatchObject({ codigo: 'EMBARQUE_PAGO_DUPLICADO' });
    });
    it('I1: la búsqueda del duplicado ignora los anulados (anulado el pago, se puede cargar otro del mismo tipo)', async () => {
      const { prisma, servicio } = armar();
      await servicio.create(alta(conEmbarque) as never, EMP, USER);
      const donde = prisma.tes_movimientos.findFirst.mock.calls.map((c: any) => c[0].where).find((w: any) => w?.embarque_id);
      expect(donde).toMatchObject({ embarque_id: UUID, tipo_pago_importacion: 'PROVEEDOR', estado: { not: 'ANULADO' } });
      expect(prisma.tes_movimientos.create).toHaveBeenCalled();
    });
    it('I1: P2002 del índice de pago por importación (carrera) → 400 EMBARQUE_PAGO_DUPLICADO, nunca 500', async () => {
      const { prisma, servicio } = armar();
      prisma.tes_movimientos.create.mockRejectedValueOnce(Object.assign(new Error('Unique'), { code: 'P2002', meta: { target: ['embarque_id', 'tipo_pago_importacion'] } }));
      expect(await falla(servicio.create(alta(conEmbarque) as never, EMP, USER))).toMatchObject({ status: 400, codigo: 'EMBARQUE_PAGO_DUPLICADO', campo: 'embarque_id' });
    });
    it('I1: otro error del alta no se traduce', async () => {
      const { prisma, servicio } = armar();
      prisma.tes_movimientos.create.mockRejectedValueOnce(new Error('boom'));
      await expect(servicio.create(alta(conEmbarque) as never, EMP, USER)).rejects.toThrow('boom');
    });
    it('embarque sin tipo de pago → EMBARQUE_INVALIDO', async () => {
      expect(await falla(armar().servicio.create(alta({ embarque_id: UUID, tipo: 'EGRESO' }) as never, EMP, USER))).toMatchObject({ codigo: 'EMBARQUE_INVALIDO' });
    });
    it('con todo y abierto crea con embarque_id y tipo_pago_importacion', async () => {
      const { prisma, servicio } = armar();
      await servicio.create(alta(conEmbarque) as never, EMP, USER);
      expect(prisma.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({ embarque_id: UUID, tipo_pago_importacion: 'PROVEEDOR' });
    });
    it('sin embarque no se consulta ningún módulo', async () => {
      await armar().servicio.create(alta() as never, EMP, USER);
      expect(moduloHabilitado).not.toHaveBeenCalled();
    });
  });

  describe('asiento (A6)', () => {
    const confirmando = (integrador: () => Promise<unknown>, constancia?: Record<string, unknown>) => {
      const h = armar({ integrador, constancia });
      return h.servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER) as Promise<any>;
    };
    it.each([
      [{ generado: true }, { generado: true, motivo: null }],
      [
        { generado: false, motivo: 'SIN_MODULO' },
        { generado: false, motivo: 'SIN_MODULO' },
      ],
      [
        { generado: false, motivo: 'CUENTA_SIN_CUENTA_CONTABLE' },
        { generado: false, motivo: 'CUENTA_SIN_CUENTA_CONTABLE' },
      ],
      [
        { generado: false, motivo: 'CATEGORIA_SIN_CUENTA', categoria: 'Otro Egreso' },
        { generado: false, motivo: 'CATEGORIA_SIN_CUENTA', categoria: 'Otro Egreso' },
      ],
      [
        { generado: false, motivo: 'SIN_PERIODO_ABIERTO' },
        { generado: false, motivo: 'SIN_PERIODO_ABIERTO' },
      ],
    ])('el integrador devuelve %j → asiento %j', async (resultado, esperado) => {
      expect((await confirmando(() => Promise.resolve(resultado))).asiento).toEqual(esperado);
    });
    it('undefined con una constancia CONT_FALTA_MAPEO → FALTA_MAPEO con sus conceptos', async () => {
      const r = await confirmando(() => Promise.resolve(undefined), { new_value: { conceptos: ['ANTICIPO_DESPACHO'] } });
      expect(r.asiento).toEqual({ generado: false, motivo: 'FALTA_MAPEO', conceptos: ['ANTICIPO_DESPACHO'] });
    });
    it('la constancia se busca del movimiento, la más reciente', async () => {
      const h = armar({ integrador: () => Promise.resolve(undefined), constancia: { new_value: { conceptos: ['X'] } } });
      await h.servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER);
      expect(h.prisma.audit_logs.findFirst.mock.calls[0][0]).toMatchObject({
        where: { empresa_id: EMP, action: 'CONT_FALTA_MAPEO', entity_type: 'tes_movimientos', entity_id: 'm1' },
        orderBy: { created_at: 'desc' },
      });
    });
    it('el integrador lanza Error("boom") → 201 con ERROR_INESPERADO sin mensaje crudo; el movimiento queda CONFIRMADO y la transacción commiteada', async () => {
      const h = armar({ integrador: () => Promise.reject(new Error('boom')) });
      const log = jest.spyOn((h.servicio as any).logger, 'error').mockImplementation(() => undefined);
      const r: any = await h.servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER);
      expect(r.asiento).toEqual({ generado: false, motivo: 'ERROR', codigo: 'ERROR_INESPERADO' });
      expect(r.estado).toBe('CONFIRMADO');
      expect(h.prisma.tes_cuentas.update).toHaveBeenCalledTimes(1);
      expect(log.mock.calls[0][0]).toMatch(/movimiento m1 \(empresa /);
    });
    it('un error de Prisma no expone tablas ni columnas: solo ERROR_INESPERADO', async () => {
      const h = armar({ integrador: () => Promise.reject(new Error('Invalid `tx.cont_asientos.create()` invocation: column "numero"')) });
      jest.spyOn((h.servicio as any).logger, 'error').mockImplementation(() => undefined);
      const r: any = await h.servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER);
      expect(r.asiento).toEqual({ generado: false, motivo: 'ERROR', codigo: 'ERROR_INESPERADO' });
      expect(JSON.stringify(r.asiento)).not.toContain('cont_asientos');
    });
    it('un error con codigo (TIPO_CAMBIO_NO_REGISTRADO) va con su codigo y su mensaje', async () => {
      const mensaje = 'No hay tipo de cambio registrado para USD en la fecha 2026-05-05';
      const h = armar({ integrador: () => Promise.reject(noEncontrado({ message: mensaje, codigo: 'TIPO_CAMBIO_NO_REGISTRADO' })) });
      const r: any = await h.servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER);
      expect(r.asiento).toEqual({ generado: false, motivo: 'ERROR', codigo: 'TIPO_CAMBIO_NO_REGISTRADO', mensaje });
    });
    it('el integrador corre después de la transacción', async () => {
      const orden: string[] = [];
      const h = armar({
        integrador: () => {
          orden.push('integrar');
          return Promise.resolve({ generado: true });
        },
      });
      h.prisma.$transaction.mockImplementation(async (cb: any) => {
        const r = await cb(h.tx);
        orden.push('commit');
        return r;
      });
      await h.servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER);
      expect(orden).toEqual(['commit', 'integrar']);
    });
  });
});

describe('confirmar', () => {
  it('confirma un borrador: updateMany con guarda por estado, saldo una vez y asiento', async () => {
    const { prisma, integracion, servicio } = armar();
    const r: any = await servicio.confirmar('m1', EMP, USER);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0]).toMatchObject({
      where: { id: 'm1', empresa_id: EMP, estado: 'BORRADOR' },
      data: { estado: 'CONFIRMADO', confirmado_por: USER },
    });
    expect(prisma.tes_cuentas.update).toHaveBeenCalledTimes(1);
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.saldo_actual.increment).toBe(150000);
    expect(integracion.integrarMovimientoTesoreria).toHaveBeenCalledTimes(1);
    expect(r).toMatchObject({ estado: 'CONFIRMADO', asiento: { generado: true, motivo: null } });
  });
  it('doble clic: updateMany cuenta 0 → 409 ESTADO_CAMBIADO, el saldo no se toca y no se integra', async () => {
    const { prisma, integracion, servicio } = armar({ updateMany: 0 });
    expect(await falla(servicio.confirmar('m1', EMP, USER))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
    expect(integracion.integrarMovimientoTesoreria).not.toHaveBeenCalled();
  });
  it('confirmar dos veces seguidas: el segundo updateMany cuenta 0 → 409 y el saldo se movió una vez', async () => {
    const { prisma, servicio } = armar();
    prisma.tes_movimientos.updateMany.mockResolvedValueOnce({ count: 1 }).mockResolvedValueOnce({ count: 0 });
    await servicio.confirmar('m1', EMP, USER);
    expect(await falla(servicio.confirmar('m1', EMP, USER))).toMatchObject({ status: 409 });
    expect(prisma.tes_cuentas.update).toHaveBeenCalledTimes(1);
  });
  it('un movimiento que ya no es borrador → 409 ESTADO_CAMBIADO', async () => {
    const { prisma, servicio } = armar({ movimiento: movBase({ estado: 'CONFIRMADO' }) });
    expect(await falla(servicio.confirmar('m1', EMP, USER))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
    expect(prisma.tes_movimientos.updateMany).not.toHaveBeenCalled();
  });
  it('requiere aprobación sin aprobar → 403 REQUIERE_APROBACION', async () => {
    const { servicio } = armar({ movimiento: movBase({ requiere_aprobacion: true }) });
    expect(await falla(servicio.confirmar('m1', EMP, USER))).toMatchObject({ status: 403, codigo: 'REQUIERE_APROBACION' });
  });
  it('aprobado sí confirma', async () => {
    const { servicio } = armar({ movimiento: movBase({ requiere_aprobacion: true, aprobado_por: 'otro' }) });
    await expect(servicio.confirmar('m1', EMP, USER)).resolves.toMatchObject({ estado: 'CONFIRMADO' });
  });
  it('un borrador con la suma de categorías distinta → CATEGORIAS_NO_SUMAN', async () => {
    const { prisma, servicio } = armar({ movimiento: movBase({ detalles: [{ categoria_id: 'c1', monto: 10 }] }) });
    expect(await falla(servicio.confirmar('m1', EMP, USER))).toMatchObject({ codigo: 'CATEGORIAS_NO_SUMAN' });
    expect(prisma.tes_movimientos.updateMany).not.toHaveBeenCalled();
  });
  it('inexistente → 404', async () => {
    expect(await falla(armar({ movimiento: null }).servicio.confirmar('m1', EMP, USER))).toMatchObject({ status: 404 });
  });
  it('si el integrador falla, el movimiento igual queda confirmado y vuelve ERROR_INESPERADO (sin mensaje crudo)', async () => {
    const h = armar({ integrador: () => Promise.reject(new Error('boom')) });
    jest.spyOn((h.servicio as any).logger, 'error').mockImplementation(() => undefined);
    const r: any = await h.servicio.confirmar('m1', EMP, USER);
    expect(r).toMatchObject({ estado: 'CONFIRMADO', asiento: { generado: false, motivo: 'ERROR', codigo: 'ERROR_INESPERADO' } });
    expect(r.asiento).not.toHaveProperty('mensaje');
  });
});

describe('aprobar y eliminar', () => {
  const requiere = movBase({ requiere_aprobacion: true });
  it('aprobar con updateMany 0 → 409 ESTADO_CAMBIADO', async () => {
    expect(await falla(armar({ movimiento: requiere, updateMany: 0 }).servicio.aprobar('m1', EMP, USER))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
  });
  it('aprobar guarda por estado BORRADOR', async () => {
    const { prisma, servicio } = armar({ movimiento: requiere });
    await servicio.aprobar('m1', EMP, USER);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0]).toMatchObject({ where: { id: 'm1', empresa_id: EMP, estado: 'BORRADOR' }, data: { aprobado_por: USER } });
  });
  it('aprobar uno que no requiere aprobación → 400', async () => {
    expect(await falla(armar().servicio.aprobar('m1', EMP, USER))).toMatchObject({ status: 400 });
  });
  it('eliminar con deleteMany 0 → 409 lanzado dentro de la transacción, después de borrar los detalles (se deshace)', async () => {
    const { prisma, servicio } = armar({ deleteMany: 0 });
    expect(await falla(servicio.eliminar('m1', EMP, USER))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
    expect(prisma.tes_movimiento_det.deleteMany).toHaveBeenCalledTimes(1);
    expect(prisma.tes_movimientos.deleteMany.mock.calls[0][0].where).toEqual({ id: 'm1', empresa_id: EMP, estado: 'BORRADOR' });
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
  });
  it('eliminar un borrador lo borra', async () => {
    const { prisma, servicio } = armar();
    await expect(servicio.eliminar('m1', EMP, USER)).resolves.toMatchObject({ id: 'm1' });
    expect(prisma.tes_movimientos.deleteMany).toHaveBeenCalledTimes(1);
  });
  it('eliminar uno que no es borrador → 409 ESTADO_CAMBIADO sin abrir la transacción', async () => {
    const { prisma, servicio } = armar({ movimiento: movBase({ estado: 'CONFIRMADO' }) });
    expect(await falla(servicio.eliminar('m1', EMP, USER))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
});

describe('anular', () => {
  const confirmado = (o: Record<string, unknown> = {}) => movBase({ estado: 'CONFIRMADO', ...o });
  const DTO = { motivo_anulacion: 'Error de registro' };
  const PERIODO_CERRADO = 'No se puede revertir: el período 05/2026 del asiento está CERRADO. Reabra ese período para revertirlo o registre un ajuste en el período actual.';
  const errorPeriodo = () => new HttpException({ message: PERIODO_CERRADO, codigo: 'PERIODO_NO_ABIERTO' }, 400);

  it('con origen de un documento → 400 MOVIMIENTO_CON_ORIGEN con el mensaje de describirOrigen y sin abrir la transacción', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado({ origen_tipo: 'CHEQUE_DEPOSITADO', origen_id: 'ch-1' }) });
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({
      status: 400,
      codigo: 'MOVIMIENTO_CON_ORIGEN',
      origen_tipo: 'CHEQUE_DEPOSITADO',
      message: 'Este movimiento lo generó Cheque depositado. Se anula desde Tesorería → Cheques.',
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
  it('CHEQUE_ANULADO con origen_id → 400 MOVIMIENTO_CON_ORIGEN (un documento anulado no habilita, F3)', async () => {
    expect(await falla(armar({ movimiento: confirmado({ origen_tipo: 'CHEQUE_ANULADO', origen_id: 'ch-1' }) }).servicio.anular('m1', DTO, EMP, USER))).toMatchObject({
      codigo: 'MOVIMIENTO_CON_ORIGEN',
    });
  });
  it.each(['IMPORT_EXTRACTO', 'CONCILIACION_AJUSTE', 'CONCILIACION_AUTO', 'AJUSTE_SALDO'])('%s sin origen_id y sin conciliar se anula como un manual (F4)', async (tipo) => {
    const { prisma, integracion, servicio } = armar({ movimiento: confirmado({ origen_tipo: tipo }) });
    await servicio.anular('m1', DTO, EMP, USER);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0].data).toMatchObject({ estado: 'ANULADO' });
    expect(prisma.tes_cuentas.update).toHaveBeenCalledTimes(1);
    expect(integracion.revertirDocumento).toHaveBeenCalledTimes(1);
  });
  it.each(['IMPORT_EXTRACTO', 'CONCILIACION_AJUSTE', 'CONCILIACION_AUTO', 'AJUSTE_SALDO'])('%s conciliado → 400 MOVIMIENTO_CONCILIADO y no escribe nada', async (tipo) => {
    const { prisma, integracion, servicio } = armar({ movimiento: confirmado({ origen_tipo: tipo }), conciliado: true });
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({
      status: 400,
      codigo: 'MOVIMIENTO_CONCILIADO',
      message: 'Este movimiento ya está conciliado con el extracto bancario. Deshacé la conciliación antes de anularlo.',
    });
    expect(prisma.tes_movimientos.updateMany).not.toHaveBeenCalled();
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
    expect(integracion.revertirDocumento).not.toHaveBeenCalled();
  });
  it('manual confirmado con CONTABILIDAD: en una transacción, updateMany guardado, saldo -150000 y revertirDocumento(…, tx) una vez', async () => {
    const { prisma, tx, fuera, integracion, servicio } = armar({ movimiento: confirmado() });
    const r: any = await servicio.anular('m1', DTO, EMP, USER);
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0]).toMatchObject({
      where: { id: 'm1', empresa_id: EMP, estado: 'CONFIRMADO' },
      data: { estado: 'ANULADO', motivo_anulacion: 'Error de registro', anulado_por: USER },
    });
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.saldo_actual.increment).toBe(-150000);
    expect(integracion.revertirDocumento).toHaveBeenCalledTimes(1);
    expect(integracion.revertirDocumento).toHaveBeenCalledWith('tes_movimientos', 'm1', USER, tx);
    expect(fuera).toEqual([]);
    expect(r).toMatchObject({ id: 'm1', estado: 'ANULADO' });
  });
  it('F3: bloquea el movimiento con FOR UPDATE en el tx antes del updateMany con extracto_lineas', async () => {
    const { prisma, tx, servicio } = armar({ movimiento: confirmado() });
    await servicio.anular('m1', DTO, EMP, USER);
    expect(tx.$queryRaw.mock.calls[0][0].join('?')).toMatch(/SELECT id FROM tes_movimientos WHERE id = \?::uuid FOR UPDATE/);
    expect(tx.$queryRaw.mock.calls[0][1]).toBe('m1');
    expect(tx.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(prisma.tes_movimientos.updateMany.mock.invocationCallOrder[0]);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0].where.extracto_lineas).toEqual({ none: { conciliado: true } });
  });
  it('F3: conciliar tomó la fila entre medio → el updateMany ve la línea conciliada: 400 MOVIMIENTO_CONCILIADO sin tocar el saldo', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado(), updateMany: 0 });
    prisma.tes_extracto_lineas.findFirst.mockResolvedValueOnce(null).mockResolvedValueOnce({ id: 'l1' });
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 400, codigo: 'MOVIMIENTO_CONCILIADO' });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
  });
  it('un egreso anulado devuelve el monto al saldo', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado({ tipo: 'EGRESO' }) });
    await servicio.anular('m1', DTO, EMP, USER);
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.saldo_actual.increment).toBe(150000);
  });
  it('con CONTABILIDAD y asiento en período cerrado → 400 ASIENTO_NO_REVERTIDO con el mensaje del período; la transacción no commitea', async () => {
    const { prisma, tx, integracion, servicio } = armar({ movimiento: confirmado() });
    integracion.revertirDocumento.mockRejectedValue(errorPeriodo());
    let commit = false;
    prisma.$transaction.mockImplementation(async (cb: any) => {
      const r = await cb(tx);
      commit = true;
      return r;
    });
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 400, codigo: 'ASIENTO_NO_REVERTIDO', message: PERIODO_CERRADO });
    expect(commit).toBe(false);
  });
  it('con CONTABILIDAD, otro error de la reversión sale tal cual (no ASIENTO_NO_REVERTIDO)', async () => {
    const { integracion, servicio } = armar({ movimiento: confirmado() });
    integracion.revertirDocumento.mockRejectedValue(new Error('se cayó la base'));
    await expect(servicio.anular('m1', DTO, EMP, USER)).rejects.toThrow('se cayó la base');
  });
  it('un error HTTP con otro código también sale tal cual', async () => {
    const { integracion, servicio } = armar({ movimiento: confirmado() });
    integracion.revertirDocumento.mockRejectedValue(new HttpException({ message: 'otra cosa', codigo: 'OTRO' }, 400));
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ codigo: 'OTRO' });
  });
  it('SIN CONTABILIDAD aunque la reversión fallaría por período cerrado → anula y no llama a revertirDocumento', async () => {
    contabilidad.mockResolvedValue(false);
    const { prisma, integracion, servicio } = armar({ movimiento: confirmado() });
    integracion.revertirDocumento.mockRejectedValue(errorPeriodo());
    await servicio.anular('m1', DTO, EMP, USER);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0].data.estado).toBe('ANULADO');
    expect(prisma.tes_cuentas.update.mock.calls[0][0].data.saldo_actual.increment).toBe(-150000);
    expect(integracion.revertirDocumento).not.toHaveBeenCalled();
  });
  it('con CONTABILIDAD y sin asiento (revertirDocumento no hace nada) → anula', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado() });
    await servicio.anular('m1', DTO, EMP, USER);
    expect(prisma.tes_movimientos.updateMany).toHaveBeenCalledTimes(1);
  });
  it('doble clic: updateMany 0 → 409 ESTADO_CAMBIADO sin tocar el saldo ni revertir', async () => {
    const { prisma, integracion, servicio } = armar({ movimiento: confirmado(), updateMany: 0 });
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
    expect(integracion.revertirDocumento).not.toHaveBeenCalled();
  });
  it('anular dos veces seguidas mueve el saldo una sola vez', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado() });
    prisma.tes_movimientos.updateMany.mockResolvedValueOnce({ count: 1 }).mockResolvedValueOnce({ count: 0 });
    await servicio.anular('m1', DTO, EMP, USER);
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 409 });
    expect(prisma.tes_cuentas.update).toHaveBeenCalledTimes(1);
  });
  it('un movimiento que no está confirmado → 409 ESTADO_CAMBIADO', async () => {
    expect(await falla(armar({ movimiento: movBase() }).servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
  });
  it('inexistente → 404', async () => {
    expect(await falla(armar({ movimiento: null }).servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 404 });
  });
});

describe('editar', () => {
  it('anulado → MOVIMIENTO_ANULADO', async () => {
    expect(await falla(armar({ movimiento: movBase({ estado: 'ANULADO' }) }).servicio.actualizar('m1', { descripcion: 'x' }, EMP, USER))).toMatchObject({
      codigo: 'MOVIMIENTO_ANULADO',
    });
  });
  it('conciliado → MOVIMIENTO_CONCILIADO', async () => {
    expect(await falla(armar({ conciliado: true }).servicio.actualizar('m1', { descripcion: 'x' }, EMP, USER))).toMatchObject({ codigo: 'MOVIMIENTO_CONCILIADO' });
  });
  it('fecha futura → FECHA_FUTURA en fecha', async () => {
    expect(await falla(armar().servicio.actualizar('m1', { fecha: '2999-01-01' }, EMP, USER))).toMatchObject({ codigo: 'FECHA_FUTURA', campo: 'fecha' });
  });
  it('referencia null borra la referencia', async () => {
    const { prisma, servicio } = armar();
    await servicio.actualizar('m1', { referencia: null }, EMP, USER);
    expect(prisma.tes_movimientos.update.mock.calls[0][0].data).toMatchObject({ referencia: null });
  });
});

describe('listado', () => {
  const fila = (id: string, lineas: unknown[] = [], extra: Record<string, unknown> = {}) => ({
    id,
    tipo: 'INGRESO',
    origen_tipo: null,
    origen_id: null,
    cuenta: { id: 'cta', nombre: 'B', moneda: 'PYG', activo: true },
    detalles: [],
    extracto_lineas: lineas,
    embarque: null,
    ...extra,
  });

  it('findMany recibe el where de whereMovimientos, skip 20 y take 20 para page 2; y la meta', async () => {
    const { prisma, servicio } = armar();
    prisma.tes_movimientos.count.mockResolvedValue(45);
    const r: any = await servicio.findAll(EMP, { cuentaId: UUID, page: 2, limit: 20 });
    const args = prisma.tes_movimientos.findMany.mock.calls[0][0];
    expect(args.where).toEqual({ empresa_id: EMP, cuenta_id: UUID });
    expect(args).toMatchObject({ skip: 20, take: 20 });
    expect(r.meta).toEqual({ total: 45, page: 2, limit: 20, totalPages: 3 });
  });
  it('page y limit por defecto: 1 y 20', async () => {
    const { prisma, servicio } = armar();
    await servicio.findAll(EMP, {});
    expect(prisma.tes_movimientos.findMany.mock.calls[0][0]).toMatchObject({ skip: 0, take: 20 });
  });
  it('cada fila trae conciliado y embarque { id, numero }', async () => {
    const { prisma, servicio } = armar();
    prisma.tes_movimientos.findMany.mockResolvedValue([fila('a', [{ id: 'l' }]), fila('b', [], { embarque: { id: 'e1', numero: 'IMP-7' } })]);
    const r: any = await servicio.findAll(EMP, {});
    expect(r.data[0]).toMatchObject({ id: 'a', conciliado: true, embarque: null, origen: null });
    expect(r.data[1]).toMatchObject({ id: 'b', conciliado: false, embarque: { id: 'e1', numero: 'IMP-7' } });
    expect(r.data[0]).not.toHaveProperty('extracto_lineas');
    const include = prisma.tes_movimientos.findMany.mock.calls[0][0].include;
    expect(include.extracto_lineas).toMatchObject({ where: { conciliado: true } });
    expect(include.embarque).toEqual({ select: { id: true, numero: true } });
  });
  it('el resumen por moneda suma ingresos y egresos de los CONFIRMADO, con el sentido de las transferencias', async () => {
    const { prisma, servicio } = armar();
    prisma.tes_movimientos.groupBy.mockResolvedValue([
      { cuenta_id: 'c-pyg', tipo: 'INGRESO', origen_tipo: null, _sum: { monto: 100 }, _count: { _all: 1 } },
      { cuenta_id: 'c-pyg', tipo: 'EGRESO', origen_tipo: null, _sum: { monto: 40 }, _count: { _all: 1 } },
      { cuenta_id: 'c-usd', tipo: 'TRANSFERENCIA', origen_tipo: 'TRANSFERENCIA_DESTINO', _sum: { monto: 10 }, _count: { _all: 1 } },
    ]);
    prisma.tes_cuentas.findMany.mockResolvedValue([
      { id: 'c-pyg', moneda: 'PYG' },
      { id: 'c-usd', moneda: 'USD' },
    ]);
    const r: any = await servicio.findAll(EMP, {});
    expect(prisma.tes_movimientos.groupBy.mock.calls[0][0].where).toMatchObject({ empresa_id: EMP, estado: 'CONFIRMADO' });
    expect(r.resumen.por_moneda).toEqual([
      { moneda: 'PYG', ingresos: 100, egresos: 40, cantidad: 2 },
      { moneda: 'USD', ingresos: 10, egresos: 0, cantidad: 1 },
    ]);
  });
  it('borradores y por_aprobar se cuentan sobre el mismo where', async () => {
    const { prisma, servicio } = armar();
    prisma.tes_movimientos.count.mockImplementation(({ where }: any) => Promise.resolve(where.estado === 'BORRADOR' ? (where.requiere_aprobacion ? 2 : 5) : 45));
    const r: any = await servicio.findAll(EMP, { cuentaId: UUID });
    expect(r.resumen).toMatchObject({ borradores: 5, por_aprobar: 2 });
    const wheres = prisma.tes_movimientos.count.mock.calls.map((c: any) => c[0].where);
    expect(wheres.every((w: any) => w.cuenta_id === UUID)).toBe(true);
    expect(wheres.find((w: any) => w.requiere_aprobacion)).toMatchObject({ estado: 'BORRADOR', requiere_aprobacion: true, aprobado_por: null });
  });
  it('filtrando por un estado que no es CONFIRMADO, el neto es vacío; que no es BORRADOR, no hay borradores', async () => {
    const { prisma, servicio } = armar();
    const r: any = await servicio.findAll(EMP, { estado: 'ANULADO' });
    expect(r.resumen).toEqual({ por_moneda: [], borradores: 0, por_aprobar: 0 });
    expect(prisma.tes_movimientos.groupBy).not.toHaveBeenCalled();
  });
});

describe('opciones', () => {
  it('devuelve las cuentas (activas primero, por nombre) y el umbral de tes_config', async () => {
    const { prisma, servicio } = armar({ umbral: 5000 });
    prisma.tes_cuentas.findMany.mockResolvedValue([{ id: 'a', nombre: 'A', moneda: 'PYG', tipo: 'BANCO_CC', activo: true }]);
    const r = await servicio.opciones(EMP);
    expect(prisma.tes_cuentas.findMany.mock.calls[0][0]).toMatchObject({
      where: { empresa_id: EMP },
      select: { id: true, nombre: true, moneda: true, tipo: true, activo: true },
      orderBy: [{ activo: 'desc' }, { nombre: 'asc' }],
    });
    expect(r).toEqual({ cuentas: [{ id: 'a', nombre: 'A', moneda: 'PYG', tipo: 'BANCO_CC', activo: true }], umbral_aprobacion: 5000, moneda_umbral: 'PYG' });
  });
  it('sin moneda principal el umbral no tiene moneda', async () => {
    expect((await armar({ umbral: 5000, base: null }).servicio.opciones(EMP)).moneda_umbral).toBeNull();
  });
  it('sin fila de config el umbral es 0', async () => {
    expect((await armar().servicio.opciones(EMP)).umbral_aprobacion).toBe(0);
  });
});

describe('excel', () => {
  it('findMany con el mismo where y sin skip ni take; nombres de created_by desde usuario', async () => {
    const { prisma, servicio } = armar();
    prisma.tes_movimientos.findMany.mockResolvedValue([
      {
        id: 'a',
        fecha: new Date('2026-05-05'),
        tipo: 'INGRESO',
        origen_tipo: null,
        origen_id: null,
        estado: 'CONFIRMADO',
        descripcion: '=SUMA(A1)',
        referencia: null,
        monto: 10,
        created_by: 'u1',
        cuenta: { nombre: 'B', moneda: 'PYG' },
        detalles: [],
      },
    ]);
    prisma.usuario.findMany.mockResolvedValue([{ id: 'u1', nombres: 'Ana', apellidos: 'Pérez' }]);
    const r = await servicio.exportarExcel(EMP, { cuentaId: UUID, fechaDesde: '2026-05-01', fechaHasta: '2026-05-31' });
    const args = prisma.tes_movimientos.findMany.mock.calls[0][0];
    expect(args.where).toEqual({ empresa_id: EMP, cuenta_id: UUID, fecha: { gte: new Date('2026-05-01'), lte: new Date('2026-05-31') } });
    expect(args).not.toHaveProperty('skip');
    expect(args).not.toHaveProperty('take');
    expect(prisma.usuario.findMany.mock.calls[0][0].where).toEqual({ id: { in: ['u1'] } });
    expect(r.nombre).toBe('movimientos-tesoreria-2026-05-01-2026-05-31.xlsx');
    expect(Buffer.isBuffer(r.buffer)).toBe(true);
  });
});

describe('extracto', () => {
  it('la cuenta suma saldo_actual (D13)', async () => {
    const { prisma, servicio } = armar({ cuenta: { id: 'cta', nombre: 'B', tipo: 'BANCO_CC', moneda: 'PYG', saldo_inicial: 0, saldo_actual: 1234 } });
    prisma.tes_movimientos.findMany.mockResolvedValue([]);
    expect((await servicio.getExtracto(EMP, 'cta')).cuenta).toEqual({ id: 'cta', nombre: 'B', tipo: 'BANCO_CC', moneda: 'PYG', saldo_actual: 1234 });
  });
});

describe('extracto: saldos a centavos', () => {
  it('el saldo de apertura, el acumulado y el cierre no arrastran restos de coma flotante', async () => {
    const { prisma, servicio } = armar({ cuenta: { id: 'cta', nombre: 'B', tipo: 'BANCO_CC', moneda: 'PYG', saldo_inicial: 0.1, saldo_actual: 0.3 } });
    prisma.tes_movimientos.findMany.mockResolvedValueOnce([{ tipo: 'INGRESO', origen_tipo: null, monto: 0.2 }]);
    prisma.tes_movimientos.findMany.mockResolvedValueOnce([{ id: 'm1', tipo: 'INGRESO', origen_tipo: null, monto: 0.2, detalles: [] }]);
    const r = await servicio.getExtracto(EMP, 'cta', '2026-05-01');
    expect(0.1 + 0.2).not.toBe(0.3);
    expect(r.saldo_apertura).toBe(0.3);
    expect(r.movimientos[0].saldo_acumulado).toBe(0.5);
    expect(r.saldo_cierre).toBe(0.5);
  });
});

describe('ronda 1 de la revisión', () => {
  const DTO = { motivo_anulacion: 'Error' };
  const confirmado = (o: Record<string, unknown> = {}) => movBase({ estado: 'CONFIRMADO', ...o });

  it('M1: guardar y confirmar, confirmar, anular y eliminar escriben solo por la transacción', async () => {
    const a = armar();
    await a.servicio.create(alta({ accion: 'CONFIRMAR' }) as never, EMP, USER);
    expect(a.fuera).toEqual([]);
    const b = armar();
    await b.servicio.confirmar('m1', EMP, USER);
    expect(b.fuera).toEqual([]);
    const c = armar({ movimiento: confirmado() });
    await c.servicio.anular('m1', DTO, EMP, USER);
    expect(c.fuera).toEqual([]);
    const d = armar();
    await d.servicio.eliminar('m1', EMP, USER);
    expect(d.fuera).toEqual([]);
  });

  it('M2: anular un origen sin documento pone «no conciliado» en la misma escritura', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado({ origen_tipo: 'IMPORT_EXTRACTO' }) });
    await servicio.anular('m1', DTO, EMP, USER);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0].where).toMatchObject({ extracto_lineas: { none: { conciliado: true } } });
  });

  it('M2: si entre la lectura y la escritura se conciliaba, el updateMany da 0 y responde MOVIMIENTO_CONCILIADO (no ESTADO_CAMBIADO)', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado({ origen_tipo: 'IMPORT_EXTRACTO' }), updateMany: 0 });
    prisma.tes_extracto_lineas.findFirst.mockResolvedValueOnce(null).mockResolvedValueOnce({ id: 'l1' });
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 400, codigo: 'MOVIMIENTO_CONCILIADO' });
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0].where).toMatchObject({ estado: 'CONFIRMADO', extracto_lineas: { none: { conciliado: true } } });
  });

  it('M2 final: un manual conciliado → 400 MOVIMIENTO_CONCILIADO y no escribe nada', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado(), conciliado: true });
    expect(await falla(servicio.anular('m1', DTO, EMP, USER))).toMatchObject({ status: 400, codigo: 'MOVIMIENTO_CONCILIADO' });
    expect(prisma.tes_movimientos.updateMany).not.toHaveBeenCalled();
    expect(prisma.tes_cuentas.update).not.toHaveBeenCalled();
  });

  it('M2 final: un manual también pide la condición de conciliado en la misma escritura', async () => {
    const { prisma, servicio } = armar({ movimiento: confirmado() });
    await servicio.anular('m1', DTO, EMP, USER);
    expect(prisma.tes_movimientos.updateMany.mock.calls[0][0].where).toMatchObject({ extracto_lineas: { none: { conciliado: true } } });
  });

  it('M4: el extracto sin cuenta → 400 CUENTA_INVALIDA (no la primera cuenta); con una cuenta ajena también', async () => {
    const { prisma, servicio } = armar();
    expect(await falla(servicio.getExtracto(EMP, undefined as never))).toMatchObject({ status: 400, codigo: 'CUENTA_INVALIDA', campo: 'cuentaId' });
    expect(prisma.tes_cuentas.findFirst).not.toHaveBeenCalled();
    const ajena = armar({ cuenta: null });
    expect(await falla(ajena.servicio.getExtracto(EMP, UUID))).toMatchObject({ status: 400, codigo: 'CUENTA_INVALIDA' });
  });
});

describe('detalle (S3: GET /tes/movimientos/:id con la forma de la fila)', () => {
  it('un TRANSFERENCIA_DESTINO conciliado → conciliado, origen con la ruta a su transferencia, embarque null y la cuenta del listado', async () => {
    const mov = movBase({
      id: UUID,
      tipo: 'TRANSFERENCIA',
      estado: 'CONFIRMADO',
      origen_tipo: 'TRANSFERENCIA_DESTINO',
      transferencia_id: 'trf-1',
      cuenta: { id: 'cta', nombre: 'DOBA S.A. DOLARES', moneda: 'USD', activo: true },
      detalles: [],
      extracto_lineas: [{ id: 'l1' }],
      embarque: null,
    });
    const { prisma, servicio } = armar({ movimiento: mov });
    const r: any = await servicio.findOne(UUID, EMP);
    expect(r).toMatchObject({ id: UUID, conciliado: true, embarque: null, cuenta: { id: 'cta', nombre: 'DOBA S.A. DOLARES', moneda: 'USD', activo: true } });
    expect(r.origen.ruta).toBe('/tesoreria-bancos?tab=tes_transferencias&transferencia=trf-1');
    expect(r).not.toHaveProperty('extracto_lineas');
    const args = prisma.tes_movimientos.findFirst.mock.calls[0][0];
    expect(args.where).toEqual({ id: UUID, empresa_id: EMP });
    expect(args.include.cuenta).toEqual({ select: { id: true, nombre: true, moneda: true, activo: true } });
    expect(args.include.extracto_lineas).toMatchObject({ where: { conciliado: true } });
  });
  it('inexistente → 404 MOVIMIENTO_NO_ENCONTRADO', async () => {
    const { servicio } = armar({ movimiento: null });
    expect(await falla(servicio.findOne(UUID, EMP))).toMatchObject({ status: 404, codigo: 'MOVIMIENTO_NO_ENCONTRADO' });
  });
  it('id que no es UUID → 404 MOVIMIENTO_NO_ENCONTRADO sin consultar Prisma (F7)', async () => {
    const { prisma, servicio } = armar();
    expect(await falla(servicio.findOne('abc', EMP))).toMatchObject({ status: 404, codigo: 'MOVIMIENTO_NO_ENCONTRADO' });
    expect(prisma.tes_movimientos.findFirst).not.toHaveBeenCalled();
  });
});
