import { readFileSync } from 'fs';
import { join } from 'path';

const leer = (carpeta: string) =>
  readFileSync(join(__dirname, '../../prisma/migrations', carpeta, 'migration.sql'), 'utf8').replace(/--.*$/gm, '');
const bloquesDo = (sql: string): string[] => sql.match(/DO \$\$[\s\S]*?END \$\$;/g) ?? [];

describe('migración 20261019100000_gastos_moneda_pyg', () => {
  const sql = leer('20261019100000_gastos_moneda_pyg');
  const bloques = bloquesDo(sql);

  it('va en un DO $$ y, si existe PYG, hace dos UPDATE: gasto_cab y cuentas_pagar de origen gasto, ambos con moneda NULL', () => {
    expect(bloques).toHaveLength(1);
    expect(sql.replace(bloques[0], '').trim()).toBe('');
    const b = bloques[0];
    expect(b).toMatch(/IF pyg IS NOT NULL THEN/);
    const updates = b.match(/UPDATE [\s\S]*?;/g) ?? [];
    expect(updates).toHaveLength(2);
    expect(updates[0]).toMatch(/UPDATE gasto_cab SET moneda_id = pyg WHERE moneda_id IS NULL;/);
    expect(updates[1]).toMatch(
      /UPDATE cuentas_pagar SET moneda_id = pyg WHERE origen_tipo = 'gasto' AND moneda_id IS NULL;/,
    );
  });

  it('solo toca moneda_id (ni cotización ni otra columna)', () => {
    const sets = (sql.match(/SET [^;]*?(?= WHERE)/g) ?? []).map((s) => s.trim());
    expect(sets).toEqual(['SET moneda_id = pyg', 'SET moneda_id = pyg']);
    expect(sql).not.toMatch(/cotizacion/i);
    expect(sql).not.toMatch(/\b(DELETE|INSERT)\b/);
  });

  it('sin PYG no hace nada: los UPDATE están dentro del IF', () => {
    const b = bloques[0];
    const dentro = b.slice(b.indexOf('IF pyg IS NOT NULL THEN'), b.indexOf('END IF;'));
    expect((dentro.match(/UPDATE /g) ?? []).length).toBe(2);
    expect(b.indexOf('UPDATE')).toBeGreaterThan(b.indexOf('IF pyg IS NOT NULL THEN'));
  });
});

describe('migración 20261019100100_gastos_vencimiento_historico', () => {
  const sql = leer('20261019100100_gastos_vencimiento_historico');

  it('agrega fecha_vencimiento y pago_historico con IF NOT EXISTS', () => {
    expect(sql).toContain('ALTER TABLE gasto_cab ADD COLUMN IF NOT EXISTS fecha_vencimiento DATE;');
    expect(sql).toContain(
      'ALTER TABLE gasto_cab ADD COLUMN IF NOT EXISTS pago_historico BOOLEAN NOT NULL DEFAULT false;',
    );
  });

  it('no toca datos', () => {
    expect(sql).not.toMatch(/\b(UPDATE|INSERT|DELETE)\b/);
  });
});

describe('migración 20261019100200_tes_reglas_moneda', () => {
  const sql = leer('20261019100200_tes_reglas_moneda');
  const bloques = bloquesDo(sql);
  const nulo = "'00000000-0000-0000-0000-000000000000'::uuid";

  it('agrega moneda_id con IF NOT EXISTS y la FK a moneda dentro de un DO $$ que tolera duplicate_object', () => {
    expect(sql).toContain('ALTER TABLE tes_reglas ADD COLUMN IF NOT EXISTS moneda_id UUID;');
    const fk = bloques.find((b) => b.includes('FOREIGN KEY (moneda_id) REFERENCES moneda(id)'));
    expect(fk).toBeDefined();
    expect(fk).toMatch(/EXCEPTION WHEN duplicate_object THEN/);
  });

  it('borra los dos índices parciales y crea un único índice con IF NOT EXISTS', () => {
    expect(sql).toContain('DROP INDEX IF EXISTS public.tes_reglas_default_uidx;');
    expect(sql).toContain('DROP INDEX IF EXISTS public.tes_reglas_medio_uidx;');
    const creates = sql.match(/CREATE UNIQUE INDEX [\s\S]*?;/g) ?? [];
    expect(creates).toHaveLength(1);
    expect(creates[0]).toBe(
      `CREATE UNIQUE INDEX IF NOT EXISTS tes_reglas_dimension_uidx ON public.tes_reglas (empresa_id, tipo_operacion, COALESCE(medio_pago_id, ${nulo}), COALESCE(moneda_id, ${nulo}));`,
    );
  });

  it('si hay filas que chocan, avisa con RAISE WARNING y no crea el índice ni borra los viejos', () => {
    const b = bloques.find((x) => x.includes('CREATE UNIQUE INDEX')) as string;
    expect(b).toMatch(/HAVING COUNT\(\*\) > 1/);
    expect(b).toMatch(/RAISE WARNING[^;]*%/);
    expect(b.indexOf('RAISE WARNING')).toBeLessThan(b.indexOf('CREATE UNIQUE INDEX'));
    expect(b.indexOf('ELSE')).toBeLessThan(b.indexOf('CREATE UNIQUE INDEX'));
    expect(b.indexOf('CREATE UNIQUE INDEX')).toBeLessThan(b.indexOf('DROP INDEX'));
    expect(b.indexOf('ELSE')).toBeLessThan(b.indexOf('DROP INDEX'));
  });

  it('no toca datos', () => {
    expect(sql).not.toMatch(/\bUPDATE\b/);
    expect(sql).not.toMatch(/\b(INSERT INTO|DELETE FROM)\b/);
    expect(sql).not.toContain('pg_indexes');
  });
});

/**
 * I11 y M12 de la revisión de buenas prácticas: la 20261019100200 ya está aplicada en
 * local (no se edita); esta la completa. Si quedaron reglas repetidas y el índice nuevo
 * no existe, la migración FALLA con el detalle (no queda "aplicada" con el esquema viejo),
 * y la FK de la moneda pasa a RESTRICT (borrar la moneda no convierte una regla "USD" en
 * "cualquier moneda").
 */
describe('migración 20261019100300_tes_reglas_moneda_estricta', () => {
  const sql = leer('20261019100300_tes_reglas_moneda_estricta');

  it('sin el índice nuevo y con repetidos: RAISE EXCEPTION con los grupos, nunca un WARNING', () => {
    expect(sql).toMatch(/to_regclass\('public\.tes_reglas_dimension_uidx'\) IS NULL/);
    expect(sql).toMatch(/RAISE EXCEPTION/);
    expect(sql).toMatch(/string_agg/);
    expect(sql).not.toMatch(/RAISE WARNING/);
  });

  it('sin repetidos crea el índice y borra los dos viejos', () => {
    expect(sql).toMatch(/CREATE UNIQUE INDEX IF NOT EXISTS tes_reglas_dimension_uidx/);
    expect(sql).toMatch(/DROP INDEX IF EXISTS public\.tes_reglas_default_uidx;/);
    expect(sql).toMatch(/DROP INDEX IF EXISTS public\.tes_reglas_medio_uidx;/);
  });

  it('la FK de moneda queda ON DELETE RESTRICT y es re-aplicable', () => {
    expect(sql).toMatch(/DROP CONSTRAINT IF EXISTS tes_reglas_moneda_id_fkey/);
    expect(sql).toMatch(/FOREIGN KEY \(moneda_id\) REFERENCES moneda\(id\) ON DELETE RESTRICT/);
    expect(sql).not.toMatch(/SET NULL/);
    expect(sql).not.toMatch(/\b(DELETE FROM|UPDATE|INSERT)\b/);
  });
});

describe('migración 20261019100400_gastos_permisos_compras', () => {
  const sql = leer('20261019100400_gastos_permisos_compras');
  const inserts = sql.match(/INSERT INTO [\s\S]*?;/g) ?? [];
  const privilegiosGastos =
    "('TES_GAS_GASTO_VER', 'TES_GAS_GASTO_CREAR', 'TES_GAS_GASTO_ANULAR', 'TES_GAS_GASTO_IMPORTAR')";

  it('solo inserta en perfiles_privilegios: no borra ni cambia nada', () => {
    expect(inserts).toHaveLength(2);
    for (const i of inserts)
      expect(i).toMatch(/^INSERT INTO perfiles_privilegios \(perfil_id, privilegio_id, modulo_id, active\)/);
    expect(sql).not.toMatch(/\b(UPDATE|DELETE|TRUNCATE|ALTER)\b/);
  });

  it('1: copia a COMPRAS solo los privilegios de Gastos que el perfil ya tiene activos en TESORERIA', () => {
    const realinear = inserts[0];
    expect(realinear).toContain(`pr.codigo IN ${privilegiosGastos}`);
    expect(realinear).toMatch(/SELECT DISTINCT pp\.perfil_id, pp\.privilegio_id, compras\.id, true/);
    expect(realinear).toMatch(/tesoreria\.id = pp\.modulo_id AND tesoreria\.codigo = 'TESORERIA'/);
    expect(realinear).toMatch(/compras\.codigo = 'COMPRAS'/);
    expect(realinear).toMatch(/WHERE pp\.active = true/);
  });

  it('las dos partes son re-aplicables: NOT EXISTS de la misma fila activa en COMPRAS', () => {
    for (const i of inserts) {
      expect(i).toMatch(/NOT EXISTS \(\s*SELECT 1 FROM perfiles_privilegios x/);
      expect(i).toMatch(/x\.modulo_id = compras\.id/);
      expect(i).toMatch(/x\.active = true/);
    }
  });

  it('2: IMPORTAR para "Copia de Administrador" de Comercial Kety, por criterio y solo si hay exactamente uno', () => {
    const [bloque] = bloquesDo(sql);
    expect(bloque).toBeDefined();
    expect(bloque).toMatch(/pf\.perfil = 'Copia de Administrador' AND e\.razon_social = 'Comercial Kety'/);
    expect(bloque).toMatch(/IF perfiles_encontrados <> 1 THEN\s*RAISE NOTICE[\s\S]*?RETURN;\s*END IF;/);
    expect(bloque.indexOf('RETURN;')).toBeLessThan(bloque.indexOf('INSERT INTO'));
    expect(inserts[1]).toMatch(/pr\.codigo = 'TES_GAS_GASTO_IMPORTAR'/);
    expect(sql).not.toMatch(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i);
  });
});
