import { Prisma } from '@prisma/client';
import { isContabilidadEnabledForEmpresa } from '../../common/utils/module-access.util';
import { armar, cheque, CTA_PYG, CTA_USD, EMP, errorDe, ID, MOV } from './__helpers__/cheques-mock';

jest.mock('../../common/utils/module-access.util', () => ({ ...jest.requireActual('../../common/utils/module-access.util'), isContabilidadEnabledForEmpresa: jest.fn() }));
jest.mock('../../auth/guards/submodulo.guard', () => ({ ...jest.requireActual('../../auth/guards/submodulo.guard'), submoduloHabilitado: jest.fn() }));
jest.mock('../../utils/utilidades', () => ({ ...jest.requireActual('../../utils/utilidades'), ymdInAsuncion: jest.fn(() => '2026-11-03') }));
const conContabilidad = isContabilidadEnabledForEmpresa as jest.Mock;

const ID2 = 'e9a10000-0000-4000-8000-0000000000c2';
const ID3 = 'e9a10000-0000-4000-8000-0000000000c3';

describe('TesChequeService: la fila (spec 6.2)', () => {
  beforeEach(() => conContabilidad.mockReset().mockResolvedValue(true));

  describe('findAll', () => {
    it('filtra por empresa, tipo y cuenta, con el orden de hoy', async () => {
      const { service, prisma } = armar();
      await service.findAll(EMP, { tipo: 'RECIBIDO', cuenta_id: CTA_PYG } as never);
      expect(prisma.tes_cheques.findMany).toHaveBeenCalledWith(
        expect.objectContaining({ where: { empresa_id: EMP, tipo: 'RECIBIDO', cuenta_id: CTA_PYG }, orderBy: [{ fecha_vencimiento: 'asc' }, { created_at: 'desc' }] }),
      );
    });

    it('sin cheques devuelve [] sin más consultas', async () => {
      const { service, prisma } = armar();
      expect(await service.findAll(EMP, {} as never)).toEqual([]);
      expect(prisma.tes_movimientos.findMany).not.toHaveBeenCalled();
    });

    it('monto como número y cuenta con { id, nombre, moneda, activo }', async () => {
      const cuenta = { id: CTA_PYG, nombre: 'DOBA S.A.', moneda: 'PYG', activo: true };
      const { service, prisma } = armar({ chequesLista: [cheque({ monto: new Prisma.Decimal('2500000'), cuenta, cuenta_id: CTA_PYG })] });
      const [fila] = await service.findAll(EMP, {} as never);
      expect(fila.monto).toBe(2500000);
      expect(fila.cuenta).toEqual(cuenta);
      expect(prisma.tes_cheques.findMany.mock.calls[0][0].include.cuenta).toEqual({ select: { id: true, nombre: true, moneda: true, activo: true } });
      // La relación `movimiento` no viaja en la fila.
      expect(fila).not.toHaveProperty('movimiento');
    });

    it('origen de un recibo con una sola consulta a recibos_cobro para todos los cheques de ese origen', async () => {
      const fecha = new Date('2026-09-01T00:00:00.000Z');
      const { service, prisma } = armar({
        chequesLista: [cheque({ origen_tipo: 'recibos_multi', origen_id: 'rec-1' }), cheque({ id: ID2, origen_tipo: 'recibos_multi', origen_id: 'rec-2' })],
        recibos: [
          { id: 'rec-1', numero_recibo: '001-001-0000123', fecha_emision: fecha, estado: 'emitido' },
          { id: 'rec-2', numero_recibo: '001-001-0000124', fecha_emision: fecha, estado: 'anulado' },
        ],
      });
      const filas = await service.findAll(EMP, {} as never);
      expect(prisma.recibos_cobro.findMany).toHaveBeenCalledTimes(1);
      expect(filas[0].origen).toMatchObject({ tipo: 'recibos_multi', etiqueta: 'Recibo de cobro', ruta: '/cobranzas/recibos', numero: '001-001-0000123', anulado: false });
      expect(filas[1].origen).toMatchObject({ numero: '001-001-0000124', anulado: true });
    });

    it('movimientos: el de movimiento_id más los CHEQUE_* del cheque, con conciliado; una consulta de movimientos y una de líneas para toda la lista', async () => {
      const f = (d: string) => new Date(`${d}T00:00:00.000Z`);
      const { service, prisma } = armar({
        chequesLista: [cheque({ estado: 'RECHAZADO', movimiento_id: null }), cheque({ id: ID2, estado: 'DEPOSITADO', movimiento_id: 'm-dep2' })],
        movimientos: [
          { id: 'm-dep', tipo: 'INGRESO', origen_tipo: 'CHEQUE_DEPOSITADO', origen_id: ID, estado: 'CONFIRMADO', fecha: f('2026-10-02'), monto: new Prisma.Decimal(2500000) },
          { id: 'm-rev', tipo: 'EGRESO', origen_tipo: 'CHEQUE_RECHAZADO', origen_id: ID, estado: 'CONFIRMADO', fecha: f('2026-10-05'), monto: new Prisma.Decimal(2500000) },
          { id: 'm-dep2', tipo: 'INGRESO', origen_tipo: 'CHEQUE_DEPOSITADO', origen_id: ID2, estado: 'CONFIRMADO', fecha: f('2026-10-03'), monto: new Prisma.Decimal(100) },
        ],
        lineas: [{ movimiento_id: 'm-dep2' }],
      });
      const [rechazado, depositado] = await service.findAll(EMP, {} as never);
      expect(prisma.tes_movimientos.findMany).toHaveBeenCalledTimes(1);
      expect(prisma.tes_extracto_lineas.findMany).toHaveBeenCalledTimes(1);
      expect(rechazado.movimientos.map((m) => m.id)).toEqual(['m-dep', 'm-rev']);
      expect(rechazado.movimientos[0]).toEqual({
        id: 'm-dep',
        tipo: 'INGRESO',
        origen_tipo: 'CHEQUE_DEPOSITADO',
        estado: 'CONFIRMADO',
        fecha: f('2026-10-02'),
        monto: 2500000,
        conciliado: false,
      });
      expect(rechazado.conciliado).toBe(false);
      expect(depositado.movimientos).toEqual([expect.objectContaining({ id: 'm-dep2', conciliado: true })]);
      // DEPOSITADO con una línea de extracto conciliada en su movimiento.
      expect(depositado.conciliado).toBe(true);
    });

    it('B8 y M6: EMITIDO EN_CARTERA de RENDICION_ADELANTO → saldo_movido_por_origen, con movimiento_id CONFIRMADO y también con ANULADO; un recibo con ANULADO → false', async () => {
      const base = { tipo: 'EMITIDO', origen_tipo: 'RENDICION_ADELANTO', origen_id: 'ad-1' };
      const { service } = armar({
        chequesLista: [cheque({ ...base, movimiento_id: 'm-ad' }), cheque({ ...base, id: ID2, movimiento_id: 'm-ad-anulado' })],
        movimientos: [
          { id: 'm-ad', tipo: 'EGRESO', origen_tipo: 'RENDICION_ADELANTO', origen_id: 'ad-1', estado: 'CONFIRMADO', fecha: new Date(), monto: 1 },
          { id: 'm-ad-anulado', tipo: 'EGRESO', origen_tipo: 'RENDICION_ADELANTO', origen_id: 'ad-1', estado: 'ANULADO', fecha: new Date(), monto: 1 },
        ],
      });
      const [vigente, anulado] = await service.findAll(EMP, {} as never);
      expect(vigente.saldo_movido_por_origen).toBe(true);
      expect(anulado.saldo_movido_por_origen).toBe(true);
      const recibo = armar({
        chequesLista: [cheque({ origen_tipo: 'recibos_multi', origen_id: 'r-1', movimiento_id: 'm-r' })],
        movimientos: [{ id: 'm-r', tipo: 'INGRESO', origen_tipo: 'recibos_multi', origen_id: 'r-1', estado: 'ANULADO', fecha: new Date(), monto: 1 }],
      });
      expect((await recibo.service.findAll(EMP, {} as never))[0].saldo_movido_por_origen).toBe(false);
      // Su movimiento no es CHEQUE_*: no cuenta para `contabilizada`.
      expect(vigente.contabilizada).toBeNull();
    });

    it('con CONTABILIDAD: DEPOSITADO con documento → true; sin documento → false; EN_CARTERA sin movimientos → null', async () => {
      const mov = (id: string, origenId: string) => ({
        id,
        tipo: 'INGRESO',
        origen_tipo: 'CHEQUE_DEPOSITADO',
        origen_id: origenId,
        estado: 'CONFIRMADO',
        fecha: new Date(),
        monto: 1,
      });
      const { service, prisma } = armar({
        chequesLista: [cheque({ estado: 'DEPOSITADO', movimiento_id: 'm1' }), cheque({ id: ID2, estado: 'DEPOSITADO', movimiento_id: 'm2' }), cheque({ id: ID3 })],
        movimientos: [mov('m1', ID), mov('m2', ID2)],
        documentos: [{ origen_id: 'm1' }],
      });
      const [con, sin, cartera] = await service.findAll(EMP, {} as never);
      expect(con.contabilizada).toBe(true);
      expect(sin.contabilizada).toBe(false);
      expect(cartera.contabilizada).toBeNull();
      expect(prisma.cont_documentos.findMany).toHaveBeenCalledWith(
        expect.objectContaining({ where: { empresa_id: EMP, origen_tipo: 'tes_movimientos', origen_id: { in: ['m1', 'm2'] }, estado: 'CONFIRMADO' } }),
      );
    });

    it('sin CONTABILIDAD: contabilizada null y cont_documentos no se consulta', async () => {
      conContabilidad.mockResolvedValue(false);
      const { service, prisma } = armar({
        chequesLista: [cheque({ estado: 'DEPOSITADO', movimiento_id: 'm1' })],
        movimientos: [{ id: 'm1', tipo: 'INGRESO', origen_tipo: 'CHEQUE_DEPOSITADO', origen_id: ID, estado: 'CONFIRMADO', fecha: new Date(), monto: 1 }],
      });
      const [fila] = await service.findAll(EMP, {} as never);
      expect(fila.contabilizada).toBeNull();
      expect(prisma.cont_documentos.findMany).not.toHaveBeenCalled();
    });

    it('proximos_vencer con dias_alerta_cheques 15 → EN_CARTERA que vencen hasta hoy + 15 (en Asunción)', async () => {
      const { service, prisma } = armar({ config: { dias_alerta_cheques: 15 } });
      await service.findAll(EMP, { proximos_vencer: 'true' } as never);
      const where = prisma.tes_cheques.findMany.mock.calls[0][0].where;
      expect(where.estado).toBe('EN_CARTERA');
      expect(where.fecha_vencimiento).toEqual({ lte: new Date('2026-11-18T00:00:00.000Z') });
    });
  });

  describe('findOne', () => {
    it('un id que no es UUID → 404 CHEQUE_NO_ENCONTRADO sin consultar', async () => {
      const { service, prisma } = armar();
      expect(await errorDe(service.findOne('abc', EMP))).toMatchObject({ status: 404, codigo: 'CHEQUE_NO_ENCONTRADO' });
      expect(prisma.tes_cheques.findFirst).not.toHaveBeenCalled();
    });
    it('ajeno o inexistente → el mismo 404', async () => {
      const { service, prisma } = armar({ cheque: null });
      expect(await errorDe(service.findOne(ID, EMP))).toMatchObject({ status: 404, codigo: 'CHEQUE_NO_ENCONTRADO' });
      expect(prisma.tes_cheques.findFirst).toHaveBeenCalledWith(expect.objectContaining({ where: { id: ID, empresa_id: EMP } }));
    });
    it('la fila con la misma forma del listado', async () => {
      const { service } = armar({ cheque: cheque({ estado: 'DEPOSITADO', movimiento_id: MOV, movimiento: { id: MOV } }) });
      const fila = await service.findOne(ID, EMP);
      expect(fila).toMatchObject({ id: ID, monto: 2500000, origen: null, movimientos: [], conciliado: false, saldo_movido_por_origen: false });
      expect(fila).not.toHaveProperty('movimiento');
    });
  });

  describe('opciones (D2)', () => {
    it('cuentas activas primero y por nombre, con el banco del catálogo y el número; días de tes_config y PYG sin cuenta', async () => {
      const { service, prisma } = armar({ config: { dias_alerta_cheques: 12 } });
      // La forma del `select`.
      prisma.tes_cuentas.findMany.mockResolvedValue([
        { id: CTA_PYG, nombre: 'DOBA S.A.', moneda: 'PYG', tipo: 'BANCO_CC', activo: true, banco_id: 'b-1', numero_cuenta: '123' },
        { id: CTA_USD, nombre: 'DOBA S.A. DOLARES', moneda: 'USD', tipo: 'BANCO_CA', activo: true, banco_id: null, numero_cuenta: null },
      ]);
      const r = await service.opciones(EMP);
      expect(prisma.tes_cuentas.findMany).toHaveBeenCalledWith({
        where: { empresa_id: EMP },
        select: { id: true, nombre: true, moneda: true, tipo: true, activo: true, banco_id: true, numero_cuenta: true },
        orderBy: [{ activo: 'desc' }, { nombre: 'asc' }],
      });
      expect(prisma.bancos.findMany).toHaveBeenCalledWith({ where: { id: { in: ['b-1'] } }, select: { id: true, descripcion: true } });
      expect(r.cuentas).toEqual([
        { id: CTA_PYG, nombre: 'DOBA S.A.', moneda: 'PYG', tipo: 'BANCO_CC', activo: true, banco: 'Banco Continental', numero_cuenta: '123' },
        { id: CTA_USD, nombre: 'DOBA S.A. DOLARES', moneda: 'USD', tipo: 'BANCO_CA', activo: true, banco: null, numero_cuenta: null },
      ]);
      expect(r.dias_alerta_cheques).toBe(12);
      expect(r.moneda_sin_cuenta).toBe('PYG');
    });
    it('sin fila de tes_config → 7 días', async () => {
      const { service } = armar({ config: null });
      expect((await service.opciones(EMP)).dias_alerta_cheques).toBe(7);
    });
  });
});
