import { isContabilidadEnabledForEmpresa } from '../src/common/utils/module-access.util';
import { ORIGENES_MOVIMIENTO } from '../src/tesoreria/services/origen-movimiento';
import { armarInforme, SECCIONES } from './revisar-tesoreria-s2';

jest.mock('../src/common/utils/module-access.util', () => ({ isContabilidadEnabledForEmpresa: jest.fn() }));
// El informe y los tipos vienen del script de S1, que importa el guard de submódulos.
jest.mock('../src/auth/guards/submodulo.guard', () => ({ submoduloHabilitado: jest.fn() }));
const contabilidad = isContabilidadEnabledForEmpresa as jest.Mock;
const seccion = (clave: string) => SECCIONES.find((s) => s.clave === clave)!;

describe('revisar-tesoreria-s2', () => {
  beforeEach(() => contabilidad.mockReset());

  it('las 5 secciones del spec salen en orden', () => {
    expect(SECCIONES.map((s) => s.clave)).toEqual(['suma_distinta', 'manual_sin_asiento', 'origen_desconocido', 'categoria_contable', 'borradores_no_confirmables']);
    expect(SECCIONES.map((s) => s.titulo.charAt(0))).toEqual(['1', '2', '3', '4', '5']);
    const informe = armarInforme(
      'base',
      '2026-11-03',
      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);
    expect(informe).toContain('Revisión de Tesorería S2');
  });

  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', origen: 'categoría propia', tabla: 'categoria' };
    const conSql = SECCIONES.filter((s) => s.correccion?.(fila));
    expect(conSql.length).toBeGreaterThanOrEqual(1);
    const informe = armarInforme(
      'base',
      '2026-11-03',
      conSql.map((seccion) => ({ seccion, filas: [fila] })),
    );
    const sql = informe.split('\n').filter((l) => /\b(UPDATE|DELETE)\b/.test(l) && /\b(SET|FROM)\b/.test(l));
    expect(sql.length).toBeGreaterThanOrEqual(1);
    for (const linea of sql) expect(linea.trimStart().startsWith('-- ')).toBe(true);
  });

  describe('sección 1 (suma distinta)', () => {
    it('compara la suma en centavos, de los movimientos que ya no son borrador', () => {
      const sql = seccion('suma_distinta').sql;
      expect(sql).toMatch(/ROUND\(\s*SUM\(d\.monto\)\s*\*\s*100\)\s*<>\s*ROUND\(\s*m\.monto\s*\*\s*100\)/i);
      expect(sql).toContain("m.estado <> 'BORRADOR'");
    });
    it('no corrige: cuál es el correcto lo dice el contador', () => {
      expect(seccion('suma_distinta').correccion).toBeUndefined();
    });
  });

  describe('sección 2 (manuales sin asiento)', () => {
    const fila = (o: Record<string, unknown> = {}) => ({
      empresa: 'E',
      empresa_id: 'e1',
      id: 'm1',
      cuenta_contable_id: 'cc-1',
      categoria_sin_cuenta: null,
      periodo_abierto: true,
      ...o,
    });
    it('usa motivoSinAsiento (no una copia de la secuencia): una cuenta sin cuenta contable sale como CUENTA_SIN_CUENTA_CONTABLE', async () => {
      contabilidad.mockResolvedValue(true);
      const filas = await seccion('manual_sin_asiento').procesar!([fila({ cuenta_contable_id: null })] as never, {} as never);
      expect(filas).toHaveLength(1);
      expect(filas[0]).toMatchObject({ motivo: 'CUENTA_SIN_CUENTA_CONTABLE' });
    });
    it('categoría sin cuenta y período cerrado, con su motivo', async () => {
      contabilidad.mockResolvedValue(true);
      const filas = await seccion('manual_sin_asiento').procesar!(
        [fila({ categoria_sin_cuenta: 'Otro Egreso' }), fila({ id: 'm2', periodo_abierto: false })] as never,
        {} as never,
      );
      expect(filas.map((f) => f.motivo)).toEqual(['CATEGORIA_SIN_CUENTA (Otro Egreso)', 'SIN_PERIODO_ABIERTO']);
    });
    it('sin otra causa dice «revisar el mapeo» (no evalúa conceptos sin mapear)', async () => {
      contabilidad.mockResolvedValue(true);
      const filas = await seccion('manual_sin_asiento').procesar!([fila()] as never, {} as never);
      expect(filas[0].motivo).toBe('revisar el mapeo');
    });
    it('una empresa sin CONTABILIDAD no se lista', async () => {
      contabilidad.mockResolvedValue(false);
      expect(await seccion('manual_sin_asiento').procesar!([fila()] as never, {} as never)).toEqual([]);
    });
    it('la consulta mira solo manuales confirmados sin documento contable', () => {
      const sql = seccion('manual_sin_asiento').sql;
      expect(sql).toContain("m.estado = 'CONFIRMADO'");
      expect(sql).toContain('m.origen_tipo IS NULL');
      expect(sql).toContain('cont_documentos');
    });
  });

  describe('sección 3 (orígenes fuera de la tabla)', () => {
    it('la consulta excluye las 22 claves de ORIGENES_MOVIMIENTO: no marca rrhh_anticipo_salario ni CXP_EMPLEADO_PAGO y sí XYZ', () => {
      const sql = seccion('origen_desconocido').sql;
      const claves = Object.keys(ORIGENES_MOVIMIENTO);
      expect(claves).toHaveLength(22);
      for (const c of claves) expect(sql).toContain(`'${c}'`);
      expect(sql).toContain('NOT IN');
      expect(sql).not.toContain("'XYZ'");
      expect(sql).toContain('m.origen_tipo IS NOT NULL');
    });
  });

  describe('sección 4 (categorías con cuenta contable)', () => {
    const fila = (o: Record<string, unknown> = {}) => ({
      empresa: 'E',
      empresa_id: 'e1',
      id: 'k1',
      nombre: 'Ventas',
      origen: 'categoría propia',
      plan_codigo: '4.1',
      plan_empresa_id: 'e1',
      plan_activa: true,
      plan_acepta_movimientos: true,
      ...o,
    });
    it('sin CONTABILIDAD, cuenta inexistente, ajena, inactiva, que no acepta movimientos u OLD- se listan con su motivo', async () => {
      contabilidad.mockResolvedValue(false);
      expect((await seccion('categoria_contable').procesar!([fila()] as never, {} as never))[0].motivo).toBe('la empresa no tiene CONTABILIDAD');
      contabilidad.mockResolvedValue(true);
      const casos: Array<[Record<string, unknown>, string]> = [
        [{ plan_codigo: null }, 'la cuenta contable no existe'],
        [{ plan_empresa_id: 'otra' }, 'es de otra empresa'],
        [{ plan_activa: false }, 'está inactiva'],
        [{ plan_acepta_movimientos: false }, 'no acepta movimientos'],
        [{ plan_codigo: 'OLD-4.1' }, 'es una cuenta OLD-'],
      ];
      for (const [cambios, motivo] of casos) {
        expect((await seccion('categoria_contable').procesar!([fila(cambios)] as never, {} as never))[0].motivo).toBe(motivo);
      }
    });
    it('una categoría sana no se lista', async () => {
      contabilidad.mockResolvedValue(true);
      expect(await seccion('categoria_contable').procesar!([fila()] as never, {} as never)).toEqual([]);
    });
    it('la corrección quita la cuenta (propia) o el mapeo (del sistema), siempre comentada en el informe', () => {
      const s = seccion('categoria_contable');
      expect(s.correccion!({ empresa: 'E', id: 'k1', tabla: 'categoria' } as never)).toMatch(/UPDATE tes_categorias SET cuenta_contable_id = NULL/);
      expect(s.correccion!({ empresa: 'E', id: 'k1', tabla: 'mapeo' } as never)).toMatch(/DELETE FROM tes_categoria_cuenta_contable/);
    });
  });

  describe('sección 5 (borradores)', () => {
    it('los borradores con la suma distinta (también sin detalles) se comparan en centavos', () => {
      const sql = seccion('borradores_no_confirmables').sql;
      expect(sql).toContain("m.estado = 'BORRADOR'");
      expect(sql).toMatch(/LEFT JOIN tes_movimiento_det/i);
      expect(sql).toMatch(/ROUND\(\s*COALESCE\(SUM\(d\.monto\),\s*0\)\s*\*\s*100\)/i);
    });
  });
});
