/**
 * Revisión de Tesorería S5 (Conciliación) 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 hay que mirar (las secciones 1 y 9 son para el contador).
 *
 * Secciones (en este orden):
 *   1. Extractos que no cierran (solo con los dos saldos).
 *   2. Extractos con alguno de los dos saldos en 0 (posible «vacío» viejo).
 *   3. Líneas conciliadas sin movimiento o con uno no CONFIRMADO.
 *   4. Movimientos conciliados en más de una línea.
 *   5. Líneas conciliadas con un movimiento sin origen creado después del extracto (posibles «+ Mov.» viejos).
 *   6. Movimientos CONCILIACION_* CONFIRMADOS sin línea conciliada.
 *   7. Movimientos CONCILIACION_* CONFIRMADOS sin asiento, en empresas con CONTABILIDAD.
 *   8. Extractos con líneas pendientes en una cuenta cerrada (informativo).
 *   9. Movimientos CONCILIACION_* ANULADOS con asiento CONFIRMADO.
 *
 * Salida: stdout y ~/.local/share/novasis-video-trabajo/tesoreria-s5/revisar-tesoreria-s5.txt.
 * Uso: npx ts-node --transpile-only -r tsconfig-paths/register --project tsconfig.scripts.json scripts/revisar-tesoreria-s5.ts
 */
import 'dotenv/config';
import { mkdirSync, writeFileSync } from 'fs';
import { homedir } from 'os';
import { join } from 'path';
import { PrismaClient } from '@prisma/client';
import { isContabilidadEnabledForEmpresa } from '../src/common/utils/module-access.util';
import { armarInforme as armarInformeS1, type Fila, type Seccion } from './revisar-tesoreria-s1';

export type { Fila, Seccion };

const ORIGENES_CONCILIACION = "m.origen_tipo IN ('CONCILIACION_AJUSTE', 'CONCILIACION_AUTO')";

const DOCUMENTO_CONFIRMADO = `SELECT 1 FROM cont_documentos doc
                          WHERE doc.empresa_id = m.empresa_id AND doc.origen_tipo = 'tes_movimientos'
                            AND doc.origen_id = m.id AND doc.estado = 'CONFIRMADO'`;

const COLUMNAS_EXTRACTO = `e.razon_social AS empresa, x.empresa_id, x.id AS extracto_id, cu.nombre AS cuenta, x.archivo_nombre, x.estado,
             to_char(x.periodo_desde, 'YYYY-MM-DD') AS desde, to_char(x.periodo_hasta, 'YYYY-MM-DD') AS hasta`;

const EXTRACTOS_SQL = `
        FROM tes_extracto_bancario x
        JOIN empresas e ON e.id = x.empresa_id
        JOIN tes_cuentas cu ON cu.id = x.cuenta_id`;

export const SECCIONES: Seccion[] = [
  {
    clave: 'no_cierran',
    titulo: '1. Extractos que no cierran (para el contador)',
    nota: 'saldo inicial + créditos − débitos no da el saldo final: las líneas leídas no coinciden con lo que dice el banco. Desde S5 la pantalla lo muestra sin bloquear nada. Los extractos con algún saldo nulo no entran: no hay con qué comparar.',
    sql: `
      SELECT ${COLUMNAS_EXTRACTO}, x.saldo_inicial, x.saldo_final, t.creditos, t.debitos,
             x.saldo_inicial + t.creditos - t.debitos AS saldo_calculado,
             x.saldo_final - (x.saldo_inicial + t.creditos - t.debitos) AS diferencia
      ${EXTRACTOS_SQL}
        JOIN LATERAL (SELECT COALESCE(SUM(l.credito), 0) AS creditos, COALESCE(SUM(l.debito), 0) AS debitos
                        FROM tes_extracto_lineas l WHERE l.extracto_id = x.id) t ON true
       WHERE x.saldo_inicial IS NOT NULL AND x.saldo_final IS NOT NULL
         AND x.saldo_inicial + t.creditos - t.debitos <> x.saldo_final
       ORDER BY e.razon_social, x.periodo_desde`,
    columnas: ['extracto_id', 'cuenta', 'archivo_nombre', 'desde', 'hasta', 'saldo_inicial', 'saldo_final', 'saldo_calculado', 'diferencia'],
  },
  {
    clave: 'saldo_en_cero',
    titulo: '2. Extractos con algún saldo en 0',
    nota: 'La pantalla vieja mandaba 0 al dejar el saldo vacío (cada uno por separado) y el PDF también. La migración no toca los datos (D5): un 0 viejo sigue siendo 0 y el control de saldo lo toma como dato. Revisar con el cliente si era un vacío.',
    sql: `
      SELECT ${COLUMNAS_EXTRACTO}, x.saldo_inicial, x.saldo_final
      ${EXTRACTOS_SQL}
       WHERE x.saldo_inicial = 0 OR x.saldo_final = 0
       ORDER BY e.razon_social, x.periodo_desde`,
    columnas: ['extracto_id', 'cuenta', 'archivo_nombre', 'desde', 'hasta', 'saldo_inicial', 'saldo_final'],
  },
  {
    clave: 'conciliada_sin_movimiento',
    titulo: '3. Líneas conciliadas sin movimiento vigente',
    nota: 'La línea figura conciliada pero su movimiento no existe o no está CONFIRMADO: la conciliación apunta a algo que no movió el saldo. Desconciliarla y volver a conciliar.',
    sql: `
      SELECT e.razon_social AS empresa, x.empresa_id, x.id AS extracto_id, l.id AS linea_id, to_char(l.fecha, 'YYYY-MM-DD') AS fecha, l.debito, l.credito,
             l.movimiento_id, m.estado AS mov_estado, m.origen_tipo
        FROM tes_extracto_lineas l
        JOIN tes_extracto_bancario x ON x.id = l.extracto_id
        JOIN empresas e ON e.id = x.empresa_id
        LEFT JOIN tes_movimientos m ON m.id = l.movimiento_id
       WHERE l.conciliado AND (m.id IS NULL OR m.estado <> 'CONFIRMADO')
       ORDER BY e.razon_social, l.fecha`,
    columnas: ['extracto_id', 'linea_id', 'fecha', 'debito', 'credito', 'movimiento_id', 'mov_estado', 'origen_tipo'],
  },
  {
    clave: 'movimiento_en_varias',
    titulo: '4. Movimientos conciliados en más de una línea',
    nota: 'Un movimiento solo puede estar en una línea. Desde S5 el bloqueo lo impide; estos quedaron de antes: desconciliar la que sobra.',
    sql: `
      SELECT e.razon_social AS empresa, x.empresa_id, l.movimiento_id, COUNT(*)::int AS lineas, array_agg(l.id::text ORDER BY l.fecha) AS linea_ids
        FROM tes_extracto_lineas l
        JOIN tes_extracto_bancario x ON x.id = l.extracto_id
        JOIN empresas e ON e.id = x.empresa_id
       WHERE l.conciliado AND l.movimiento_id IS NOT NULL
       GROUP BY e.razon_social, x.empresa_id, l.movimiento_id
      HAVING COUNT(*) > 1
       ORDER BY e.razon_social, l.movimiento_id`,
    columnas: ['movimiento_id', 'lineas', 'linea_ids'],
  },
  {
    clave: 'posibles_mov_viejos',
    titulo: '5. Líneas conciliadas con un movimiento sin origen creado después del extracto',
    nota: 'Posibles «+ Mov.» viejos, que nacían con origen nulo: el control que frena eliminar el extracto (C8) no los alcanza. Si se elimina ese extracto, siguen vivos sin rastro.',
    sql: `
      SELECT e.razon_social AS empresa, x.empresa_id, x.id AS extracto_id, l.id AS linea_id, l.movimiento_id, to_char(m.fecha, 'YYYY-MM-DD') AS fecha, m.monto, m.descripcion
        FROM tes_extracto_lineas l
        JOIN tes_extracto_bancario x ON x.id = l.extracto_id
        JOIN empresas e ON e.id = x.empresa_id
        JOIN tes_movimientos m ON m.id = l.movimiento_id
       WHERE l.conciliado AND m.origen_tipo IS NULL AND m.created_at > x.created_at
       ORDER BY e.razon_social, m.fecha`,
    columnas: ['extracto_id', 'linea_id', 'movimiento_id', 'fecha', 'monto', 'descripcion'],
  },
  {
    clave: 'conciliacion_sin_linea',
    titulo: '6. Movimientos de la conciliación confirmados sin línea conciliada',
    nota: 'Se crearon desde una línea que ya no los tiene (se desconcilió o se eliminó el extracto) y siguen moviendo el saldo. Si no corresponden, se anulan en Movimientos.',
    sql: `
      SELECT e.razon_social AS empresa, m.empresa_id, m.id AS movimiento_id, m.origen_tipo, to_char(m.fecha, 'YYYY-MM-DD') AS fecha, cu.nombre AS cuenta, m.monto, m.descripcion
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
        JOIN tes_cuentas cu ON cu.id = m.cuenta_id
       WHERE ${ORIGENES_CONCILIACION}
         AND m.estado = 'CONFIRMADO'
         AND NOT EXISTS (SELECT 1 FROM tes_extracto_lineas l WHERE l.movimiento_id = m.id AND l.conciliado)
       ORDER BY e.razon_social, m.fecha, m.id`,
    columnas: ['movimiento_id', 'origen_tipo', 'fecha', 'cuenta', 'monto', 'descripcion'],
  },
  {
    clave: 'conciliacion_sin_asiento',
    titulo: '7. Movimientos de la conciliación confirmados sin asiento (empresas con CONTABILIDAD)',
    nota: 'Sin documento contable CONFIRMADO. Desde S5 la pantalla dice por qué y ofrece «Reintentar contabilización» en la línea, una vez corregida la causa.',
    sql: `
      SELECT e.razon_social AS empresa, m.empresa_id, m.id AS movimiento_id, m.origen_tipo, to_char(m.fecha, 'YYYY-MM-DD') AS fecha, cu.nombre AS cuenta, m.monto
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
        JOIN tes_cuentas cu ON cu.id = m.cuenta_id
       WHERE ${ORIGENES_CONCILIACION}
         AND m.estado = 'CONFIRMADO'
         AND NOT EXISTS (${DOCUMENTO_CONFIRMADO})
       ORDER BY e.razon_social, m.fecha, m.id`,
    columnas: ['movimiento_id', 'origen_tipo', 'fecha', 'cuenta', 'monto'],
    procesar: async (filas, tx) => {
      const cache = new Map<string, boolean>();
      const salida: Fila[] = [];
      for (const f of filas) {
        const empresaId = String(f.empresa_id);
        if (!cache.has(empresaId)) cache.set(empresaId, await isContabilidadEnabledForEmpresa(tx as never, empresaId));
        if (cache.get(empresaId)) salida.push(f);
      }
      return salida;
    },
  },
  {
    clave: 'pendientes_cuenta_cerrada',
    titulo: '8. Extractos con líneas pendientes en una cuenta cerrada',
    nota: 'Informativo. Se pueden conciliar y marcar; «Crear movimiento» pide reactivar la cuenta en Cuentas.',
    sql: `
      SELECT ${COLUMNAS_EXTRACTO}, COUNT(*)::int AS pendientes
      ${EXTRACTOS_SQL}
        JOIN tes_extracto_lineas l ON l.extracto_id = x.id
       WHERE cu.activo = false AND NOT l.conciliado AND NOT l.sin_correspondencia
       GROUP BY e.razon_social, x.empresa_id, x.id, cu.nombre, x.archivo_nombre, x.estado, x.periodo_desde, x.periodo_hasta
       ORDER BY e.razon_social, x.periodo_desde`,
    columnas: ['extracto_id', 'cuenta', 'archivo_nombre', 'desde', 'hasta', 'estado', 'pendientes'],
  },
  {
    clave: 'anulados_con_asiento',
    titulo: '9. Movimientos de la conciliación anulados con asiento confirmado (para el contador)',
    nota: 'El movimiento se anuló y su asiento sigue CONFIRMADO: los libros mantienen algo que Tesorería ya no tiene. No se corrige en S5: lo decide el contador (F4).',
    sql: `
      SELECT e.razon_social AS empresa, m.empresa_id, m.id AS movimiento_id, m.origen_tipo, to_char(m.fecha, 'YYYY-MM-DD') AS fecha, to_char(m.anulado_en, 'YYYY-MM-DD') AS anulado,
             cu.nombre AS cuenta, m.monto, m.motivo_anulacion
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
        JOIN tes_cuentas cu ON cu.id = m.cuenta_id
       WHERE ${ORIGENES_CONCILIACION}
         AND m.estado = 'ANULADO'
         AND EXISTS (${DOCUMENTO_CONFIRMADO})
       ORDER BY e.razon_social, m.fecha, m.id`,
    columnas: ['movimiento_id', 'origen_tipo', 'fecha', 'anulado', 'cuenta', 'monto', 'motivo_anulacion'],
  },
];

export const armarInforme = (base: string, fecha: string, resultados: Array<{ seccion: Seccion; filas: Fila[] }>): string =>
  armarInformeS1(base, fecha, resultados, 'Revisión de Tesorería S5 (Conciliació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-s5');
    mkdirSync(dir, { recursive: true });
    writeFileSync(join(dir, 'revisar-tesoreria-s5.txt'), salida + '\n');
  } finally {
    await prisma.$disconnect();
  }
}

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