import { Logger } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { isContabilidadEnabledForEmpresa } from '../../common/utils/module-access.util';
import { armar, CTA, EMP, errorDe, EXT, extracto, LIN, linea, MOV, MOV2 } from './__helpers__/conciliacion-mock';

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

const contabilidad = isContabilidadEnabledForEmpresa as jest.Mock;
const dec = (n: number) => new Prisma.Decimal(n);

beforeEach(() => contabilidad.mockReset().mockResolvedValue(true));

describe('opciones (D2)', () => {
  const categorias = [
    { id: 'c2', nombre: 'Zeta', tipo: 'EGRESO', activo: false, cuenta_contable_id: 'cc', mapeo_id: 'mp', is_sistema: true },
    { id: 'c1', nombre: 'Alfa', tipo: 'AMBOS', activo: true, cuenta_contable_id: 'cc', mapeo_id: null, is_sistema: false },
  ];
  it('cuentas ordenadas por activas y nombre, categorías proyectadas sin cuenta_contable_id ni mapeo_id (F10), ia_disponible true', async () => {
    const { service, prisma, categorias: catServ } = armar({ categoriasFindAll: categorias, apiKey: 'k' });
    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 },
      orderBy: [{ activo: 'desc' }, { nombre: 'asc' }],
    });
    expect(catServ.findAll).toHaveBeenCalledWith(EMP);
    expect(r.categorias).toEqual([
      { id: 'c1', nombre: 'Alfa', tipo: 'AMBOS', activo: true },
      { id: 'c2', nombre: 'Zeta', tipo: 'EGRESO', activo: false },
    ]);
    expect(r.ia_disponible).toBe(true);
  });
  it('sin credencial: ia_disponible false; la clave nunca sale', async () => {
    const sin = await armar({ apiKey: null }).service.opciones(EMP);
    expect(sin.ia_disponible).toBe(false);
    const con = await armar({ apiKey: 'secreta' }).service.opciones(EMP);
    expect(JSON.stringify(con)).not.toContain('secreta');
  });
  it('una clave que no se puede descifrar no deja la pestaña en error: ia_disponible false, con cuentas y categorías, y queda en el log', async () => {
    const error = jest.spyOn(Logger.prototype, 'error').mockImplementation(() => undefined);
    const { service, aiConfig, prisma } = armar({ categoriasFindAll: categorias });
    aiConfig.getConfigEfectiva.mockRejectedValueOnce(new Error('bad decrypt'));
    prisma.tes_cuentas.findMany.mockResolvedValueOnce([{ id: CTA }]);
    const r = await service.opciones(EMP);
    expect(r).toMatchObject({ ia_disponible: false, cuentas: [{ id: CTA }] });
    expect(r.categorias).toHaveLength(2);
    expect(error).toHaveBeenCalledTimes(1);
    expect(error.mock.calls[0][0]).toContain('bad decrypt');
    error.mockRestore();
  });
});

describe('getExtractos', () => {
  const lineasDe = (o: Array<Record<string, unknown>>) => o.map((l) => ({ extracto_id: EXT, conciliado: false, sin_correspondencia: false, movimiento: null, ...l }));
  const cinco = lineasDe([
    { conciliado: true, movimiento: { estado: 'CONFIRMADO', origen_tipo: 'CONCILIACION_AJUSTE' } },
    { conciliado: true, movimiento: { estado: 'CONFIRMADO', origen_tipo: 'CHEQUE_DEPOSITADO' } },
    { sin_correspondencia: true },
    {},
    {},
  ]);
  it('stats y movimientos_conciliacion, con una sola consulta de líneas para toda la lista', async () => {
    const otro = { ...extracto({ id: 'otro' }) };
    const { service, prisma } = armar({ extractos: [extracto(), otro], lineas: cinco });
    const r = await service.getExtractos(EMP);
    expect(prisma.tes_extracto_lineas.findMany).toHaveBeenCalledTimes(1);
    expect(prisma.tes_extracto_lineas.findMany.mock.calls[0][0].where).toEqual({ extracto_id: { in: [EXT, 'otro'] } });
    expect(r[0].stats).toEqual({ total: 5, conciliadas: 2, sin_correspondencia: 1, pendientes: 2 });
    expect(r[0].movimientos_conciliacion).toBe(1);
    expect(r[1].stats).toEqual({ total: 0, conciliadas: 0, sin_correspondencia: 0, pendientes: 0 });
  });
  it('un CONCILIACION_AJUSTE ANULADO no cuenta; un CONCILIACION_AUTO sí', async () => {
    const r = await armar({
      extractos: [extracto()],
      lineas: lineasDe([
        { conciliado: true, movimiento: { estado: 'ANULADO', origen_tipo: 'CONCILIACION_AJUSTE' } },
        { conciliado: true, movimiento: { estado: 'CONFIRMADO', origen_tipo: 'CONCILIACION_AUTO' } },
      ]),
    }).service.getExtractos(EMP);
    expect(r[0].movimientos_conciliacion).toBe(1);
  });
  it('saldos nulos salen null, no 0; un 0 sale 0 (D5)', async () => {
    const r = await armar({ extractos: [extracto({ saldo_inicial: null, saldo_final: dec(0) })] }).service.getExtractos(EMP);
    expect(r[0].saldo_inicial).toBeNull();
    expect(r[0].saldo_final).toBe(0);
  });
  it('cuenta trae id, nombre, moneda y activo; sin saldo de la cuenta', async () => {
    const { service, prisma } = armar({ extractos: [extracto()] });
    await service.getExtractos(EMP);
    expect(prisma.tes_extracto_bancario.findMany.mock.calls[0][0].include.cuenta).toEqual({ select: { id: true, nombre: true, moneda: true, activo: true } });
  });
  it('filtra por cuenta_id y no pide líneas si no hay extractos', async () => {
    const { service, prisma } = armar({ extractos: [] });
    expect(await service.getExtractos(EMP, CTA)).toEqual([]);
    expect(prisma.tes_extracto_bancario.findMany.mock.calls[0][0].where).toEqual({ empresa_id: EMP, cuenta_id: CTA });
    expect(prisma.tes_extracto_lineas.findMany).not.toHaveBeenCalled();
  });
});

describe('getExtractoDetalle', () => {
  const conLineas = (lineas: Array<Record<string, unknown>>, o: Record<string, unknown> = {}) => extracto({ lineas, ...o });
  const ajuste = (o: Record<string, unknown> = {}) =>
    linea({
      conciliado: true,
      movimiento_id: MOV,
      movimiento: { id: MOV, fecha: new Date('2026-10-20'), descripcion: 'x', monto: dec(1000), tipo: 'EGRESO', origen_tipo: 'CONCILIACION_AJUSTE', estado: 'CONFIRMADO' },
      ...o,
    });
  const deCheque = () =>
    ajuste({
      id: 'l2',
      movimiento_id: MOV2,
      movimiento: { id: MOV2, fecha: new Date('2026-10-20'), descripcion: 'x', monto: dec(1000), tipo: 'INGRESO', origen_tipo: 'CHEQUE_DEPOSITADO', estado: 'CONFIRMADO' },
    });

  it('debito, credito y monto como número; movimiento.origen_tipo presente', async () => {
    const r = await armar({ extracto: conLineas([ajuste()]) }).service.getExtractoDetalle(EMP, EXT);
    expect(r.lineas[0]).toMatchObject({ debito: 1000, credito: 0, movimiento: { monto: 1000, origen_tipo: 'CONCILIACION_AJUSTE' } });
    expect(r.saldo_inicial).toBe(100);
    expect(r.cuenta).toEqual({ id: CTA, nombre: 'DOBA S.A.', moneda: 'PYG', activo: true });
  });
  it('con CONTABILIDAD: documento CONFIRMADO → true; línea de un cheque → null', async () => {
    const { service, prisma } = armar({ extracto: conLineas([ajuste(), deCheque()]), documentos: [{ origen_id: MOV }] });
    const r = await service.getExtractoDetalle(EMP, EXT);
    expect(r.lineas.map((l) => l.contabilizada)).toEqual([true, null]);
    expect(prisma.cont_documentos.findMany.mock.calls[0][0].where).toMatchObject({
      empresa_id: EMP,
      origen_tipo: 'tes_movimientos',
      origen_id: { in: [MOV] },
      estado: 'CONFIRMADO',
    });
  });
  it('sin documento CONFIRMADO → false (un REVERTIDO no cuenta, F16)', async () => {
    const r = await armar({ extracto: conLineas([ajuste()]), documentos: [] }).service.getExtractoDetalle(EMP, EXT);
    expect(r.lineas[0].contabilizada).toBe(false);
  });
  it('sin CONTABILIDAD → null y cont_documentos no se consulta', async () => {
    contabilidad.mockResolvedValue(false);
    const { service, prisma } = armar({ extracto: conLineas([ajuste()]) });
    const r = await service.getExtractoDetalle(EMP, EXT);
    expect(r.lineas[0].contabilizada).toBeNull();
    expect(prisma.cont_documentos.findMany).not.toHaveBeenCalled();
  });
  it('sin movimientos CONCILIACION_* no consulta documentos', async () => {
    const { service, prisma } = armar({ extracto: conLineas([deCheque()]) });
    await service.getExtractoDetalle(EMP, EXT);
    expect(prisma.cont_documentos.findMany).not.toHaveBeenCalled();
  });
  it('stats y movimientos_conciliacion en el detalle', async () => {
    const r = await armar({ extracto: conLineas([ajuste(), deCheque(), linea({ id: 'l3', sin_correspondencia: true }), linea({ id: 'l4' })]) }).service.getExtractoDetalle(
      EMP,
      EXT,
    );
    expect(r.stats).toEqual({ total: 4, conciliadas: 2, sin_correspondencia: 1, pendientes: 1 });
    expect(r.movimientos_conciliacion).toBe(1);
  });
  it('control_saldo.saldo_sistema: 100 + 50 − 20 + 10 − 5 = 135, con CONFIRMADO hasta el fin del período (D6)', async () => {
    const hasta = new Date('2026-10-31T00:00:00.000Z');
    const { service, prisma } = armar({
      extracto: conLineas([], { cuenta: { id: CTA, nombre: 'x', moneda: 'PYG', activo: true, saldo_inicial: dec(100) }, periodo_hasta: hasta }),
      grupos: [
        { tipo: 'INGRESO', origen_tipo: null, _sum: { monto: dec(50) } },
        { tipo: 'EGRESO', origen_tipo: null, _sum: { monto: dec(20) } },
        { tipo: 'TRANSFERENCIA', origen_tipo: 'TRANSFERENCIA_DESTINO', _sum: { monto: dec(10) } },
        { tipo: 'TRANSFERENCIA', origen_tipo: 'TRANSFERENCIA_ORIGEN', _sum: { monto: dec(5) } },
      ],
    });
    const r = await service.getExtractoDetalle(EMP, EXT);
    expect(r.control_saldo.saldo_sistema).toBe(135);
    expect(prisma.tes_movimientos.groupBy.mock.calls[0][0]).toMatchObject({
      by: ['tipo', 'origen_tipo'],
      where: { empresa_id: EMP, cuenta_id: CTA, estado: 'CONFIRMADO', fecha: { lte: hasta } },
    });
  });
  it('control_saldo con las líneas y los saldos nulos', async () => {
    const r = await armar({
      extracto: conLineas([linea({ debito: dec(30), credito: dec(0) }), linea({ id: 'l2', debito: dec(0), credito: dec(50) })], { saldo_inicial: null, saldo_final: null }),
    }).service.getExtractoDetalle(EMP, EXT);
    expect(r.control_saldo).toEqual({ debitos: 30, creditos: 50, saldo_calculado: null, diferencia_extracto: null, saldo_sistema: 0, diferencia_sistema: null });
    expect(r.saldo_inicial).toBeNull();
    expect(r.saldo_final).toBeNull();
  });
  it('un id que no es UUID → 404 sin consultar Prisma', async () => {
    const { service, prisma } = armar();
    expect(await errorDe(service.getExtractoDetalle(EMP, 'abc'))).toMatchObject({ status: 404, codigo: 'EXTRACTO_NO_ENCONTRADO' });
    expect(prisma.tes_extracto_bancario.findFirst).not.toHaveBeenCalled();
  });
  it('uno ajeno → el mismo 404', async () => {
    expect(await errorDe(armar({ extracto: null }).service.getExtractoDetalle(EMP, EXT))).toMatchObject({ status: 404, codigo: 'EXTRACTO_NO_ENCONTRADO' });
  });
});

describe('getDiferencias', () => {
  const movs = [
    { id: 'a', tipo: 'TRANSFERENCIA', origen_tipo: 'TRANSFERENCIA_DESTINO', monto: dec(10), detalles: [] },
    { id: 'b', tipo: 'EGRESO', origen_tipo: null, monto: dec(5), detalles: [] },
  ];
  it('en_sistema sin el día de más y con sentido; una TRANSFERENCIA_DESTINO → INGRESO', async () => {
    const e = extracto();
    const { service, prisma } = armar({ extracto: e, movimientos: movs });
    const r = await service.getDiferencias(EMP, EXT);
    expect(prisma.tes_movimientos.findMany.mock.calls[0][0].where.fecha).toEqual({ gte: e.periodo_desde, lte: e.periodo_hasta });
    expect(r.en_sistema.map((m) => [m.id, m.sentido, m.monto])).toEqual([
      ['a', 'INGRESO', 10],
      ['b', 'EGRESO', 5],
    ]);
  });
  it('en_banco trae clasificacion y números; un saldo 0 sale 0', async () => {
    const { service } = armar({ lineas: [linea({ descripcion: 'COMISION', saldo: dec(0) })] });
    const r = await service.getDiferencias(EMP, EXT);
    expect(r.en_banco[0]).toMatchObject({ debito: 1000, credito: 0, saldo: 0, clasificacion: 'COMISION_BANCARIA' });
  });
  it('no UUID o ajeno → 404 EXTRACTO_NO_ENCONTRADO', async () => {
    expect(await errorDe(armar().service.getDiferencias(EMP, 'abc'))).toMatchObject({ status: 404, codigo: 'EXTRACTO_NO_ENCONTRADO' });
    expect(await errorDe(armar({ extracto: null }).service.getDiferencias(EMP, EXT))).toMatchObject({ status: 404, codigo: 'EXTRACTO_NO_ENCONTRADO' });
  });
});

describe('getMovimientosSinConciliar', () => {
  it('una TRANSFERENCIA_ORIGEN sale con tipo TRANSFERENCIA, sentido EGRESO y origen_tipo (D7)', async () => {
    const { service } = armar({
      movimientos: [
        { id: MOV, fecha: new Date('2026-10-08'), tipo: 'TRANSFERENCIA', origen_tipo: 'TRANSFERENCIA_ORIGEN', monto: dec(3700000), descripcion: 'x', referencia: null },
      ],
    });
    const [m] = await service.getMovimientosSinConciliar(EMP, CTA, '2026-10-01', '2026-10-31');
    expect(m).toEqual({
      id: MOV,
      fecha: new Date('2026-10-08'),
      tipo: 'TRANSFERENCIA',
      sentido: 'EGRESO',
      origen_tipo: 'TRANSFERENCIA_ORIGEN',
      monto: 3700000,
      descripcion: 'x',
      referencia: null,
    });
  });
});

describe('getLineaDeMovimientos (D9)', () => {
  const fila = { id: LIN, extracto_id: EXT, movimiento_id: MOV };
  it('busca las conciliadas de esos movimientos, de la empresa, y devuelve la primera', async () => {
    const { service, prisma } = armar({ linea: fila });
    expect(await service.getLineaDeMovimientos(EMP, `${MOV},${MOV2}`)).toEqual({ linea_id: LIN, extracto_id: EXT, movimiento_id: MOV });
    expect(prisma.tes_extracto_lineas.findFirst.mock.calls[0][0].where).toEqual({ movimiento_id: { in: [MOV, MOV2] }, conciliado: true, extracto: { empresa_id: EMP } });
  });
  it('sin línea → 404 LINEA_NO_ENCONTRADA', async () => {
    expect(await errorDe(armar({ linea: null }).service.getLineaDeMovimientos(EMP, MOV))).toMatchObject({ status: 404, codigo: 'LINEA_NO_ENCONTRADA' });
  });
  it('"abc" → el mismo 404 sin consultar', async () => {
    const { service, prisma } = armar();
    expect(await errorDe(service.getLineaDeMovimientos(EMP, 'abc'))).toMatchObject({ status: 404, codigo: 'LINEA_NO_ENCONTRADA' });
    expect(await errorDe(service.getLineaDeMovimientos(EMP, ''))).toMatchObject({ status: 404, codigo: 'LINEA_NO_ENCONTRADA' });
    expect(prisma.tes_extracto_lineas.findFirst).not.toHaveBeenCalled();
  });
  it('tres ids → el mismo 404 sin consultar', async () => {
    const { service, prisma } = armar();
    expect(await errorDe(service.getLineaDeMovimientos(EMP, `${MOV},${MOV2},${MOV}`))).toMatchObject({ status: 404, codigo: 'LINEA_NO_ENCONTRADA' });
    expect(prisma.tes_extracto_lineas.findFirst).not.toHaveBeenCalled();
  });
});
