import { isContabilidadEnabledForEmpresa } from '../src/common/utils/module-access.util';
import { submoduloHabilitado } from '../src/auth/guards/submodulo.guard';
import { armarInforme, calcularDescuadres, comentar, SECCIONES, SQL_MOVIMIENTOS_POR_DIA } from './revisar-tesoreria-s1';

jest.mock('../src/common/utils/module-access.util', () => ({ isContabilidadEnabledForEmpresa: jest.fn() }));
jest.mock('../src/auth/guards/submodulo.guard', () => ({ submoduloHabilitado: jest.fn() }));
const contabilidad = isContabilidadEnabledForEmpresa as jest.Mock;
const submodulo = submoduloHabilitado as jest.Mock;
const seccion = (clave: string) => SECCIONES.find((s) => s.clave === clave)!;

describe('revisar-tesoreria-s1', () => {
  it('las 5 secciones del spec salen en orden', () => {
    expect(SECCIONES.map((s) => s.clave)).toEqual(['moneda_no_activa', 'cuenta_contable', 'descuadre', 'config_fuera_de_dto', 'reglas']);
    expect(SECCIONES.map((s) => s.titulo.charAt(0))).toEqual(['1', '2', '3', '4', '5']);
    const informe = armarInforme('base', '2026-11-02', SECCIONES.map((seccion) => ({ seccion, filas: [] })));
    const posiciones = SECCIONES.map((s) => informe.indexOf(s.titulo));
    expect(posiciones.every((p) => p >= 0)).toBe(true);
    expect([...posiciones].sort((a, b) => a - b)).toEqual(posiciones);
  });

  it('ninguna consulta escribe (sin INSERT/UPDATE/DELETE fuera de comentarios)', () => {
    for (const s of SECCIONES) {
      const sinComentarios = s.sql.replace(/--.*$/gm, '');
      expect(sinComentarios).not.toMatch(/\b(INSERT|UPDATE|DELETE|TRUNCATE|ALTER|DROP|CREATE)\b/i);
      expect(sinComentarios.trim().toUpperCase().startsWith('SELECT')).toBe(true);
    }
  });

  it('el SQL de corrección sale con cada línea comentada (-- )', () => {
    const fila: any = { empresa: 'E', id: 'c1', empresa_id: 'e1', moneda: 'USD', moneda_en_empresa: false, calculado: 10, monto_umbral_aprobacion: -1, dias_alerta_cheques: 0, moneda_base_reportes: 'PYG' };
    const filaPorSeccion = SECCIONES.map((s) => ({ seccion: s, filas: [fila] }));
    const informe = armarInforme('base', '2026-11-02', filaPorSeccion);
    const sql = informe.split('\n').filter((l) => /\b(UPDATE|INSERT|DELETE)\b/.test(l) && /\b(SET|INTO|FROM)\b/.test(l));
    expect(sql.length).toBeGreaterThanOrEqual(4);
    for (const linea of sql) expect(linea.trimStart().startsWith('-- ')).toBe(true);
    expect(comentar('a\nb')).toBe('-- a\n-- b');
    // La aclaración de varias líneas también sale comentada.
    for (const s of SECCIONES) {
      const c = s.correccion?.(fila);
      if (c) for (const linea of comentar(c).split('\n')) expect(linea.startsWith('-- ')).toBe(true);
    }
  });

  describe('sección 3 (descuadre)', () => {
    const cuenta = { empresa: 'E', id: 'c1', nombre: 'Banco', saldo_inicial: 1000, saldo_actual: 1000 };
    const mov = (dia: string, tipo: string, origen_tipo: string | null, monto: number) => ({ cuenta_id: 'c1', dia, tipo, origen_tipo, monto, cantidad: 1 });

    it('calcula el saldo con sentidoMovimiento sobre los CONFIRMADO: la transferencia destino suma, la origen resta', () => {
      const filas = calcularDescuadres(
        [{ ...cuenta, saldo_actual: 0 }],
        [mov('2026-01-01', 'INGRESO', null, 500), mov('2026-01-02', 'EGRESO', null, 200), mov('2026-01-03', 'TRANSFERENCIA', 'TRANSFERENCIA_DESTINO', 100), mov('2026-01-04', 'TRANSFERENCIA', 'TRANSFERENCIA_ORIGEN', 50)],
      );
      expect(filas).toHaveLength(1);
      expect(filas[0]).toMatchObject({ calculado: 1350, guardado: 0, diferencia: -1350 });
      expect(filas[0].detalle_dias).toHaveLength(4);
      expect((filas[0].detalle_dias as string[])[0]).toContain('2026-01-01');
    });

    it('una cuenta cuadrada no aparece', () => {
      expect(calcularDescuadres([{ ...cuenta, saldo_actual: 1300 }], [mov('2026-01-01', 'INGRESO', null, 500), mov('2026-01-02', 'EGRESO', null, 200)])).toEqual([]);
    });

    it('procesar consulta los movimientos CONFIRMADO por día y devuelve solo las cuentas descuadradas', async () => {
      expect(SQL_MOVIMIENTOS_POR_DIA).toContain("m.estado = 'CONFIRMADO'");
      const tx: any = {
        $queryRawUnsafe: jest.fn().mockResolvedValue([
          mov('2026-01-01', 'INGRESO', null, 500),
          { cuenta_id: 'c2', dia: '2026-01-01', tipo: 'EGRESO', origen_tipo: null, monto: 100, cantidad: 1 },
        ]),
      };
      const cuadrada = { ...cuenta, id: 'c2', saldo_inicial: 100, saldo_actual: 0 };
      const filas = await seccion('descuadre').procesar!([{ ...cuenta, saldo_actual: 0 }, cuadrada] as never, tx);
      expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(SQL_MOVIMIENTOS_POR_DIA);
      expect(filas).toHaveLength(1);
      expect(filas[0]).toMatchObject({ id: 'c1', calculado: 1500, guardado: 0 });
    });

    it('la nota es coherente con el UPDATE comentado que imprime', () => {
      const s3 = seccion('descuadre');
      expect(s3.nota).toContain('UPDATE comentado');
      expect(s3.nota).not.toContain('no propone');
      expect(s3.correccion!({ id: 'c1', calculado: 5 } as never)).toContain('SET saldo_actual = 5');
    });

    it('el informe abre el detalle por día', () => {
      const [fila] = calcularDescuadres([{ ...cuenta, saldo_actual: 0 }], [mov('2026-01-01', 'INGRESO', null, 500)]);
      const s3 = SECCIONES.find((s) => s.clave === 'descuadre')!;
      expect(armarInforme('b', 'f', [{ seccion: s3, filas: [fila] }])).toContain('2026-01-01  movimientos 1');
    });
  });

  describe('sección 2 (cuenta contable)', () => {
    const plan = { empresa: 'E', id: 'c1', empresa_id: 'e1', cuenta_contable_id: 'p1', plan_codigo: '1.1', plan_empresa_id: 'e1', plan_activa: true, plan_acepta_movimientos: true };
    const correr = async (fila: object, conModulo = true) => {
      contabilidad.mockResolvedValue(conModulo);
      return seccion('cuenta_contable').procesar!([{ ...plan, ...fila }] as never, {} as never);
    };
    beforeEach(() => contabilidad.mockReset());

    it('una cuenta válida con CONTABILIDAD no se lista', async () => {
      expect(await correr({})).toEqual([]);
      expect(await correr({ plan_empresa_id: null })).toEqual([]);
    });
    it.each([
      ['la empresa no tiene CONTABILIDAD', {}, false],
      ['la cuenta contable no existe', { plan_codigo: null }, true],
      ['es de otra empresa', { plan_empresa_id: 'otra' }, true],
      ['está inactiva', { plan_activa: false }, true],
      ['no acepta movimientos', { plan_acepta_movimientos: false }, true],
      ['es una cuenta OLD-', { plan_codigo: 'OLD-1.1' }, true],
    ])('motivo «%s»', async (motivo, fila, conModulo) => {
      expect(await correr(fila, conModulo)).toMatchObject([{ id: 'c1', motivo }]);
    });
    it('pregunta el módulo una vez por empresa', async () => {
      contabilidad.mockResolvedValue(true);
      await seccion('cuenta_contable').procesar!([plan, { ...plan, id: 'c2' }] as never, {} as never);
      expect(contabilidad).toHaveBeenCalledTimes(1);
    });
  });

  describe('sección 5 (reglas)', () => {
    const regla = { empresa: 'E', id: 'r1', empresa_id: 'e1', tipo_operacion: 'COBRO_CLIENTE', cuenta_id: 'c1', cuenta_activa: true, cuenta_empresa_id: 'e1' };
    const correr = (fila: object) => seccion('reglas').procesar!([{ ...regla, ...fila }] as never, {} as never);
    beforeEach(() => {
      submodulo.mockReset();
      submodulo.mockResolvedValue({ habilitado: true, fechaFinPrueba: null });
    });

    it('una regla sana no se lista y consulta el submódulo de su tipo', async () => {
      expect(await correr({})).toEqual([]);
      expect(submodulo).toHaveBeenCalledWith(expect.anything(), 'e1', 'COB_RECIBOS');
    });
    it('cuenta cerrada, cuenta ajena y tipo sin efecto', async () => {
      expect(await correr({ cuenta_activa: false })).toMatchObject([{ motivo: 'la cuenta está cerrada' }]);
      expect(await correr({ cuenta_empresa_id: 'otra' })).toMatchObject([{ motivo: 'la cuenta es de otra empresa' }]);
      expect(await correr({ tipo_operacion: 'COBRO_EFECTIVO' })).toMatchObject([{ motivo: 'tipo sin efecto' }]);
    });
    it('submódulo sin acceso → dice cuál y por qué', async () => {
      submodulo.mockResolvedValue({ habilitado: false, causa: 'sin_suscripcion', mensaje: 'La empresa no tiene una suscripción activa' });
      expect(await correr({ tipo_operacion: 'PAGO_PROVEEDOR' })).toMatchObject([
        { motivo: 'COMP_ORDEN_PAGO sin acceso: La empresa no tiene una suscripción activa' },
      ]);
    });
    it('una regla sin cuenta no marca cuenta cerrada', async () => {
      expect(await correr({ cuenta_id: null, cuenta_activa: null, cuenta_empresa_id: null })).toEqual([]);
    });
    it('junta los motivos', async () => {
      submodulo.mockResolvedValue({ habilitado: false, causa: 'excluido', mensaje: 'x' });
      const [f] = await correr({ cuenta_activa: false });
      expect(f.motivo).toBe('la cuenta está cerrada; COB_RECIBOS sin acceso: x');
    });
  });
});
