/**
 * Revisión de Tesorería S1 antes de desplegar (spec «Script de revisión previo al deploy»). SOLO LECTURA: todo corre en una
 * transacción `SET TRANSACTION READ ONLY` con PrismaClient directo (nunca AppModule). No corrige nada: lista, por base y por
 * empresa, lo que el usuario tiene que decidir, e imprime el SQL de corrección COMENTADO (cada línea con `-- `) cuando lo hay.
 *
 * Secciones (en este orden):
 *   1. Cuentas con moneda fuera de las activas de su empresa (A10e).
 *   2. Cuentas con `cuenta_contable_id` en empresas sin CONTABILIDAD, o que no es del plan, está inactiva, no acepta movimientos o es OLD-.
 *   3. Descuadre de `saldo_actual` contra el cálculo (saldo_inicial + movimientos CONFIRMADO con `sentidoMovimiento`), con el detalle por día (A11).
 *   4. `tes_config` con valores fuera del DTO nuevo.
 *   5. Reglas con la cuenta cerrada o ajena, o de un tipo fuera del plan.
 *
 * Salida: stdout y ~/.local/share/novasis-video-trabajo/tesoreria-s1/revisar-tesoreria-s1.txt.
 * Uso: npx ts-node --transpile-only -r tsconfig-paths/register --project tsconfig.scripts.json scripts/revisar-tesoreria-s1.ts
 */
import 'dotenv/config';
import { mkdirSync, writeFileSync } from 'fs';
import { homedir } from 'os';
import { join } from 'path';
import { Prisma, PrismaClient } from '@prisma/client';
import { submoduloHabilitado } from '../src/auth/guards/submodulo.guard';
import { isContabilidadEnabledForEmpresa } from '../src/common/utils/module-access.util';
import { SUBMODULO_DE_REGLA } from '../src/tesoreria/reglas-regla';
import { sentidoMovimiento } from '../src/tesoreria/services/sentido-movimiento';
import { TIPOS_REGLA_TESORERIA } from '../src/tesoreria/services/tes-reglas.service';

export type Fila = Record<string, unknown> & { empresa: string };
type Tx = Prisma.TransactionClient;

export interface Seccion {
  clave: string;
  titulo: string;
  /** Qué hacer con lo que aparece (para decidir con el cliente). */
  nota: string;
  sql: string;
  /** Columnas a mostrar (además de la empresa), en orden. */
  columnas: string[];
  /** Filtra o completa lo que trae la SQL con las reglas del código (módulos, submódulos, sentido de los movimientos). */
  procesar?: (filas: Fila[], tx: Tx) => Promise<Fila[]>;
  /** SQL de corrección de una fila, sin comentar: el informe antepone `-- ` a cada línea. `null` si no hay corrección unívoca. */
  correccion?: (fila: Fila) => string | null;
  /** Detalle de las filas (el punto 3 abre el movimiento por día). */
  detalle?: (fila: Fila) => string[];
}

const comillas = (v: unknown) => `'${String(v).replace(/'/g, "''")}'`;
const fmt = (n: unknown) => Number(n).toLocaleString('es-PY', { maximumFractionDigits: 2 });

/** Movimientos CONFIRMADO agrupados por cuenta, día, tipo y origen: el sentido sale de `sentidoMovimiento` en el código. */
export const SQL_MOVIMIENTOS_POR_DIA = `
      SELECT m.cuenta_id, to_char(m.fecha, 'YYYY-MM-DD') AS dia, m.tipo, m.origen_tipo, SUM(m.monto) AS monto, COUNT(*)::int AS cantidad
        FROM tes_movimientos m
       WHERE m.estado = 'CONFIRMADO'
       GROUP BY m.cuenta_id, m.fecha, m.tipo, m.origen_tipo
       ORDER BY m.cuenta_id, m.fecha`;

/** Saldo calculado y detalle por día de cada cuenta, a partir de las filas de `SQL_MOVIMIENTOS_POR_DIA`. */
export function calcularDescuadres(
  cuentas: Array<Fila & { id: string; saldo_inicial: unknown; saldo_actual: unknown }>,
  movimientos: Array<{ cuenta_id: string; dia: string; tipo: string; origen_tipo: string | null; monto: unknown; cantidad: number }>,
): Fila[] {
  const porCuenta = new Map<string, typeof movimientos>();
  for (const m of movimientos) porCuenta.set(m.cuenta_id, [...(porCuenta.get(m.cuenta_id) ?? []), m]);
  const salida: Fila[] = [];
  for (const c of cuentas) {
    const movs = porCuenta.get(c.id) ?? [];
    let acumulado = Number(c.saldo_inicial);
    const dias = new Map<string, { delta: number; cantidad: number }>();
    for (const m of movs) {
      const delta = (sentidoMovimiento(m) === 'INGRESO' ? 1 : -1) * Number(m.monto);
      acumulado += delta;
      const d = dias.get(m.dia) ?? { delta: 0, cantidad: 0 };
      dias.set(m.dia, { delta: d.delta + delta, cantidad: d.cantidad + m.cantidad });
    }
    const guardado = Number(c.saldo_actual);
    // Decimal(18,2): una diferencia de centavos de redondeo no es un descuadre.
    if (Math.abs(acumulado - guardado) < 0.005) continue;
    let corrido = Number(c.saldo_inicial);
    const detalle = [...dias.entries()].map(([dia, d]) => {
      corrido += d.delta;
      return `${dia}  movimientos ${d.cantidad}  neto ${fmt(d.delta)}  saldo calculado al cierre del día ${fmt(corrido)}`;
    });
    salida.push({ ...c, calculado: acumulado, guardado, diferencia: guardado - acumulado, detalle_dias: detalle });
  }
  return salida;
}

export const SECCIONES: Seccion[] = [
  {
    clave: 'moneda_no_activa',
    titulo: '1. Cuentas con moneda fuera de las activas de su empresa',
    nota: 'Desde S1 no se puede crear ni cambiar una cuenta a una moneda que la empresa no tiene activa. Las existentes siguen operando; decidir con el cliente si se activa la moneda.',
    sql: `
      SELECT e.razon_social AS empresa, c.id, c.nombre, c.moneda, c.activo,
             (SELECT em.active FROM empresa_monedas em JOIN moneda m ON m.id = em.moneda_id
               WHERE em.empresa_id = c.empresa_id AND m.codigo = c.moneda LIMIT 1) AS moneda_en_empresa, c.empresa_id
        FROM tes_cuentas c
        JOIN empresas e ON e.id = c.empresa_id
       WHERE NOT EXISTS (
               SELECT 1 FROM empresa_monedas em JOIN moneda m ON m.id = em.moneda_id
                WHERE em.empresa_id = c.empresa_id AND em.active IS TRUE AND m.codigo = c.moneda)
       ORDER BY e.razon_social, c.nombre`,
    columnas: ['id', 'nombre', 'moneda', 'activo', 'moneda_en_empresa'],
    correccion: (f) =>
      f.moneda_en_empresa === false
        ? `UPDATE empresa_monedas SET active = true WHERE empresa_id = ${comillas(f.empresa_id)} AND moneda_id = (SELECT id FROM moneda WHERE codigo = ${comillas(f.moneda)});`
        : null,
  },
  {
    clave: 'cuenta_contable',
    titulo: '2. Cuentas con cuenta contable que S1 no aceptaría',
    nota: 'Sin CONTABILIDAD la cuenta contable no se guarda; con el módulo tiene que ser del plan de la empresa o del sistema, activa, que acepte movimientos y sin OLD-. Lo que ya está guardado se conserva hasta que el contador decida.',
    sql: `
      SELECT e.razon_social AS empresa, c.id, c.nombre, c.empresa_id, c.cuenta_contable_id,
             p.codigo AS plan_codigo, p.empresa_id AS plan_empresa_id, p.active AS plan_activa, p.acepta_movimientos AS plan_acepta_movimientos
        FROM tes_cuentas c
        JOIN empresas e ON e.id = c.empresa_id
        LEFT JOIN cont_plan_cuentas p ON p.id = c.cuenta_contable_id
       WHERE c.cuenta_contable_id IS NOT NULL
       ORDER BY e.razon_social, c.nombre`,
    columnas: ['id', 'nombre', 'plan_codigo', 'motivo'],
    procesar: async (filas, tx) => {
      const conModulo = new Map<string, boolean>();
      const salida: Fila[] = [];
      for (const f of filas) {
        const empresaId = String(f.empresa_id);
        if (!conModulo.has(empresaId)) conModulo.set(empresaId, await isContabilidadEnabledForEmpresa(tx as never, empresaId));
        let motivo: string | null = null;
        if (!conModulo.get(empresaId)) motivo = 'la empresa no tiene CONTABILIDAD';
        else if (f.plan_codigo == null) motivo = 'la cuenta contable no existe';
        else if (f.plan_empresa_id != null && f.plan_empresa_id !== f.empresa_id) motivo = 'es de otra empresa';
        else if (f.plan_activa !== true) motivo = 'está inactiva';
        else if (f.plan_acepta_movimientos !== true) motivo = 'no acepta movimientos';
        else if (String(f.plan_codigo).startsWith('OLD-')) motivo = 'es una cuenta OLD-';
        if (motivo) salida.push({ ...f, motivo });
      }
      return salida;
    },
    correccion: (f) => `UPDATE tes_cuentas SET cuenta_contable_id = NULL WHERE id = ${comillas(f.id)};`,
  },
  {
    clave: 'descuadre',
    titulo: '3. Descuadre de saldo_actual contra los movimientos confirmados',
    nota: 'saldo_actual debería ser saldo_inicial + ingresos − egresos de los movimientos CONFIRMADO (el sentido sale de sentidoMovimiento: una transferencia destino suma). Cuál es el saldo real lo dice el extracto del banco y lo decide el contador: el script imprime el calculado en un UPDATE comentado, para usar solo si el contador confirma contra el extracto que ese es el saldo real.',
    sql: `
      SELECT e.razon_social AS empresa, c.id, c.nombre, c.moneda, c.activo, c.saldo_inicial, c.saldo_actual
        FROM tes_cuentas c
        JOIN empresas e ON e.id = c.empresa_id
       ORDER BY e.razon_social, c.nombre`,
    columnas: ['id', 'nombre', 'activo', 'moneda', 'saldo_inicial', 'guardado', 'calculado', 'diferencia'],
    procesar: async (filas, tx) => {
      const movimientos = await tx.$queryRawUnsafe<Parameters<typeof calcularDescuadres>[1]>(SQL_MOVIMIENTOS_POR_DIA);
      return calcularDescuadres(filas as never, movimientos);
    },
    correccion: (f) =>
      `UPDATE tes_cuentas SET saldo_actual = ${Number(f.calculado)} WHERE id = ${comillas(f.id)};\nSolo si el contador confirma contra el extracto que el cálculo es el saldo real.`,
    detalle: (f) => (f.detalle_dias as string[]) ?? [],
  },
  {
    clave: 'config_fuera_de_dto',
    titulo: '4. tes_config con valores fuera del DTO nuevo',
    nota: 'El PATCH nuevo exige umbral ≥ 0, días de alerta enteros de 1 a 90 y una moneda base de 3 letras activa en la empresa. La fila existente sigue leyéndose; corregirla evita que el formulario la rechace al guardar.',
    sql: `
      SELECT e.razon_social AS empresa, t.id, t.empresa_id, t.monto_umbral_aprobacion, t.dias_alerta_cheques, t.moneda_base_reportes,
             EXISTS (SELECT 1 FROM empresa_monedas em JOIN moneda m ON m.id = em.moneda_id
                      WHERE em.empresa_id = t.empresa_id AND em.active IS TRUE AND m.codigo = t.moneda_base_reportes) AS moneda_activa
        FROM tes_config t
        JOIN empresas e ON e.id = t.empresa_id
       WHERE t.monto_umbral_aprobacion < 0
          OR t.dias_alerta_cheques < 1 OR t.dias_alerta_cheques > 90
          OR length(t.moneda_base_reportes) <> 3
          OR NOT EXISTS (SELECT 1 FROM empresa_monedas em JOIN moneda m ON m.id = em.moneda_id
                          WHERE em.empresa_id = t.empresa_id AND em.active IS TRUE AND m.codigo = t.moneda_base_reportes)
       ORDER BY e.razon_social`,
    columnas: ['id', 'monto_umbral_aprobacion', 'dias_alerta_cheques', 'moneda_base_reportes', 'moneda_activa'],
    correccion: (f) =>
      `UPDATE tes_config SET monto_umbral_aprobacion = GREATEST(monto_umbral_aprobacion, 0), dias_alerta_cheques = LEAST(GREATEST(dias_alerta_cheques, 1), 90) WHERE id = ${comillas(f.id)};\nLa moneda base ${comillas(f.moneda_base_reportes)} se resuelve activando la moneda o eligiendo otra desde Configuración.`,
  },
  {
    clave: 'reglas',
    titulo: '5. Reglas con cuenta cerrada, ajena o de un tipo fuera del plan',
    nota: 'Una regla cuyo tipo depende de un submódulo que la empresa no tiene habilitado (COB_RECIBOS, COMP_ORDEN_PAGO, TES_GASTOS; por plan, exclusión o sin suscripción vigente) no la lee ningún flujo; una con la cuenta cerrada se ignora. Las reglas guardadas no se tocan.',
    sql: `
      SELECT e.razon_social AS empresa, r.id, r.empresa_id, r.tipo_operacion, r.activo, r.cuenta_id,
             c.nombre AS cuenta, c.activo AS cuenta_activa, c.empresa_id AS cuenta_empresa_id
        FROM tes_reglas r
        JOIN empresas e ON e.id = r.empresa_id
        LEFT JOIN tes_cuentas c ON c.id = r.cuenta_id
       ORDER BY e.razon_social, r.tipo_operacion`,
    columnas: ['id', 'tipo_operacion', 'activo', 'cuenta', 'motivo'],
    procesar: async (filas, tx) => {
      const salida: Fila[] = [];
      for (const f of filas) {
        const motivos: string[] = [];
        const tipo = String(f.tipo_operacion);
        if (f.cuenta_id != null && f.cuenta_empresa_id !== f.empresa_id) motivos.push('la cuenta es de otra empresa');
        else if (f.cuenta_id != null && f.cuenta_activa !== true) motivos.push('la cuenta está cerrada');
        if (!(TIPOS_REGLA_TESORERIA as readonly string[]).includes(tipo)) motivos.push('tipo sin efecto');
        else {
          const codigo = SUBMODULO_DE_REGLA[tipo as keyof typeof SUBMODULO_DE_REGLA];
          const estado = await submoduloHabilitado(tx as never, String(f.empresa_id), codigo);
          if ('mensaje' in estado) motivos.push(`${codigo} sin acceso: ${estado.mensaje}`);
        }
        if (motivos.length) salida.push({ ...f, motivo: motivos.join('; ') });
      }
      return salida;
    },
    correccion: (f) => `UPDATE tes_reglas SET activo = false WHERE id = ${comillas(f.id)};`,
  },
];

/** Los Decimal de Prisma se muestran como número, no como JSON entre comillas. */
const valor = (v: unknown) => {
  if (v == null) return '—';
  if (Prisma.Decimal.isDecimal(v)) return v.toString();
  return typeof v === 'object' && !(v instanceof Date) ? JSON.stringify(v) : String(v);
};

/** Cada línea del SQL de corrección sale comentada con `-- `. */
export const comentar = (sql: string) =>
  sql
    .split('\n')
    .map((l) => `-- ${l}`)
    .join('\n');

export function armarInforme(base: string, fecha: string, resultados: Array<{ seccion: Seccion; filas: Fila[] }>, titulo = 'Revisión de Tesorería S1'): string {
  const lineas: string[] = [`${titulo} — base ${base} — ${fecha} (transacción READ ONLY: transaction_read_only = on)`, ''];
  for (const { seccion, filas } of resultados) {
    lineas.push(`== ${seccion.titulo} ==`, seccion.nota, `Resultado: ${filas.length === 0 ? 'sin casos' : `${filas.length} caso(s)`}`);
    let empresaActual = '';
    for (const f of filas) {
      if (f.empresa !== empresaActual) {
        empresaActual = f.empresa;
        lineas.push(`  Empresa: ${empresaActual}`);
      }
      lineas.push('    ' + seccion.columnas.map((c) => `${c}=${valor(f[c])}`).join(' · '));
      for (const d of seccion.detalle?.(f) ?? []) lineas.push(`        ${d}`);
      const sql = seccion.correccion?.(f);
      if (sql) lineas.push(comentar(sql).replace(/^/gm, '      '));
    }
    lineas.push('');
  }
  return lineas.join('\n');
}

async function main() {
  const prisma = new PrismaClient();
  try {
    const base = (process.env.DATABASE_URL ?? '').replace(/\?.*$/, '').replace(/^.*\//, '');
    const resultados = await prisma.$transaction(
      async (tx) => {
        // Primera sentencia de la transacción: a partir de acá Postgres rechaza cualquier escritura.
        await tx.$executeRawUnsafe('SET TRANSACTION READ ONLY');
        const [{ transaction_read_only: soloLectura }] = await tx.$queryRawUnsafe<Array<{ transaction_read_only: string }>>('SHOW transaction_read_only');
        if (soloLectura !== 'on') throw new Error(`La transacción no quedó en solo lectura (transaction_read_only = ${soloLectura}).`);
        const r: Array<{ seccion: Seccion; filas: Fila[] }> = [];
        for (const seccion of SECCIONES) {
          const crudas = await tx.$queryRawUnsafe<Fila[]>(seccion.sql);
          r.push({ seccion, filas: seccion.procesar ? await seccion.procesar(crudas, tx) : crudas });
        }
        return r;
      },
      { timeout: 120_000 },
    );
    const salida = armarInforme(base, new Date().toISOString(), resultados);
    console.log(salida);
    const dir = join(homedir(), '.local/share/novasis-video-trabajo/tesoreria-s1');
    mkdirSync(dir, { recursive: true });
    writeFileSync(join(dir, 'revisar-tesoreria-s1.txt'), salida + '\n');
  } finally {
    await prisma.$disconnect();
  }
}

if (require.main === module) {
  main().catch((e) => {
    console.error(e);
    process.exitCode = 1;
  });
}
