/**
 * Revisión de Tesorería S2 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 contador tiene que decidir, e imprime el SQL de corrección COMENTADO (cada línea con `-- `) cuando lo hay.
 *
 * Secciones (en este orden):
 *   1. Movimientos (no borradores) con la suma de las categorías distinta del monto, comparada en centavos (A5).
 *   2. Movimientos manuales confirmados sin asiento en empresas con CONTABILIDAD, con el motivo de `motivoSinAsiento` (F13).
 *   3. Movimientos con un `origen_tipo` fuera de los 22 de `ORIGENES_MOVIMIENTO` (F5).
 *   4. Categorías con cuenta contable en empresas sin CONTABILIDAD, o con una cuenta que no es del plan o no acepta movimientos.
 *   5. Borradores cuya suma de categorías no es el monto: no se podrán confirmar.
 *
 * Salida: stdout y ~/.local/share/novasis-video-trabajo/tesoreria-s2/revisar-tesoreria-s2.txt.
 * Uso: npx ts-node --transpile-only -r tsconfig-paths/register --project tsconfig.scripts.json scripts/revisar-tesoreria-s2.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 { motivoSinAsiento } from '../src/tesoreria/asiento-movimiento';
import { ORIGENES_MOVIMIENTO } from '../src/tesoreria/services/origen-movimiento';
import { armarInforme as armarInformeS1, type Fila, type Seccion } from './revisar-tesoreria-s1';

export type { Fila, Seccion };

const comillas = (v: unknown) => `'${String(v).replace(/'/g, "''")}'`;
/** Las 22 claves del catálogo, como lista SQL (son constantes del código, no entrada del usuario). */
const ORIGENES_CONOCIDOS_SQL = Object.keys(ORIGENES_MOVIMIENTO).map(comillas).join(', ');

/** Si la empresa tiene CONTABILIDAD; una consulta por empresa. */
async function conModulo(cache: Map<string, boolean>, empresaId: string, tx: unknown): Promise<boolean> {
  if (!cache.has(empresaId)) cache.set(empresaId, await isContabilidadEnabledForEmpresa(tx as never, empresaId));
  return cache.get(empresaId) as boolean;
}

export const SECCIONES: Seccion[] = [
  {
    clave: 'suma_distinta',
    titulo: '1. Movimientos con la suma de las categorías distinta del monto',
    nota: 'Desde S2 el alta exige que la suma de las categorías sea el monto. Estos movimientos ya existen: el saldo se movió por el monto y el asiento (si hay Contabilidad) iría por los detalles. Cuál es el correcto lo dice el contador; el script no corrige nada.',
    sql: `
      SELECT e.razon_social AS empresa, m.id, m.empresa_id, to_char(m.fecha, 'YYYY-MM-DD') AS fecha, c.nombre AS cuenta, m.estado,
             m.monto, SUM(d.monto) AS suma, m.monto - SUM(d.monto) AS diferencia
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
        JOIN tes_cuentas c ON c.id = m.cuenta_id
        JOIN tes_movimiento_det d ON d.movimiento_id = m.id
       WHERE m.estado <> 'BORRADOR'
       GROUP BY e.razon_social, m.id, m.empresa_id, m.fecha, c.nombre, m.estado, m.monto
      HAVING ROUND(SUM(d.monto) * 100) <> ROUND(m.monto * 100)
       ORDER BY e.razon_social, m.fecha, m.id`,
    columnas: ['id', 'fecha', 'cuenta', 'estado', 'monto', 'suma', 'diferencia'],
  },
  {
    clave: 'manual_sin_asiento',
    titulo: '2. Movimientos manuales confirmados sin asiento (empresas con CONTABILIDAD)',
    nota: 'Los movimientos manuales confirmados que no tienen asiento. El motivo sale de la misma función que usa el integrador (motivoSinAsiento); no evalúa conceptos sin mapear: si no halla otra causa dice «revisar el mapeo». Corregido el motivo, se regeneran desde Contabilidad › Conciliación.',
    sql: `
      SELECT e.razon_social AS empresa, m.id, m.empresa_id, to_char(m.fecha, 'YYYY-MM-DD') AS fecha, c.nombre AS cuenta, m.tipo, m.monto,
             c.cuenta_contable_id,
             (SELECT cat.nombre
                FROM tes_movimiento_det d
                JOIN tes_categorias cat ON cat.id = d.categoria_id
               WHERE d.movimiento_id = m.id AND d.cuenta_contable_id IS NULL AND d.concepto_contable IS NULL
                 AND cat.cuenta_contable_id IS NULL
                 AND NOT EXISTS (SELECT 1 FROM tes_categoria_cuenta_contable x
                                  WHERE x.empresa_id = m.empresa_id AND x.categoria_id = d.categoria_id AND x.cuenta_contable_id IS NOT NULL)
               LIMIT 1) AS categoria_sin_cuenta,
             EXISTS (SELECT 1 FROM cont_periodos p
                      WHERE p.empresa_id = m.empresa_id AND p.estado IN ('ABIERTO', 'AJUSTE')
                        AND p.fecha_inicio <= m.fecha AND p.fecha_fin >= m.fecha) AS periodo_abierto
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
        JOIN tes_cuentas c ON c.id = m.cuenta_id
       WHERE m.estado = 'CONFIRMADO' AND m.origen_tipo IS NULL
         AND NOT EXISTS (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)
       ORDER BY e.razon_social, c.nombre, m.fecha, m.id`,
    columnas: ['id', 'fecha', 'cuenta', 'tipo', 'monto', 'motivo'],
    procesar: async (filas, tx) => {
      const cache = new Map<string, boolean>();
      const salida: Fila[] = [];
      for (const f of filas) {
        if (!(await conModulo(cache, String(f.empresa_id), tx))) continue;
        const r = motivoSinAsiento({
          se_contabiliza_por_origen: false,
          tiene_modulo: true,
          tiene_documento: false,
          cuenta_contable_id: (f.cuenta_contable_id as string | null) ?? null,
          falta_mapeo: [],
          categoria_sin_cuenta: (f.categoria_sin_cuenta as string | null) ?? null,
          periodo_abierto: f.periodo_abierto !== false,
        });
        const motivo = r ? (r.categoria ? `${r.motivo} (${r.categoria})` : r.motivo) : 'revisar el mapeo';
        salida.push({ ...f, motivo });
      }
      return salida;
    },
  },
  {
    clave: 'origen_desconocido',
    titulo: '3. Movimientos con un origen fuera de la tabla de orígenes',
    nota: 'Desde S2 la pantalla traduce los 22 orígenes de ORIGENES_MOVIMIENTO; uno que no está en la lista se muestra como «Documento vinculado» y no se puede anular desde Tesorería. Hay que agregarlo a la tabla o corregir el movimiento.',
    sql: `
      SELECT e.razon_social AS empresa, m.origen_tipo, COUNT(*)::int AS cantidad
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
       WHERE m.origen_tipo IS NOT NULL AND m.origen_tipo NOT IN (${ORIGENES_CONOCIDOS_SQL})
       GROUP BY e.razon_social, m.origen_tipo
       ORDER BY e.razon_social, m.origen_tipo`,
    columnas: ['origen_tipo', 'cantidad'],
  },
  {
    clave: 'categoria_contable',
    titulo: '4. Categorías con una cuenta contable que S2 no aceptaría',
    nota: 'Sin CONTABILIDAD la cuenta contable de una categoría 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 guardado se conserva hasta que el contador decida.',
    sql: `
      SELECT e.razon_social AS empresa, k.empresa_id, k.id, k.nombre, 'categoría propia' AS origen, 'categoria' AS tabla,
             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_categorias k
        JOIN empresas e ON e.id = k.empresa_id
        LEFT JOIN cont_plan_cuentas p ON p.id = k.cuenta_contable_id
       WHERE k.cuenta_contable_id IS NOT NULL AND k.empresa_id IS NOT NULL
      UNION ALL
      SELECT e.razon_social AS empresa, x.empresa_id, x.id, k.nombre, 'mapeo de categoría del sistema' AS origen, 'mapeo' AS tabla,
             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_categoria_cuenta_contable x
        JOIN empresas e ON e.id = x.empresa_id
        JOIN tes_categorias k ON k.id = x.categoria_id
        LEFT JOIN cont_plan_cuentas p ON p.id = x.cuenta_contable_id
       WHERE x.cuenta_contable_id IS NOT NULL
       ORDER BY empresa, nombre`,
    columnas: ['id', 'nombre', 'origen', 'plan_codigo', 'motivo'],
    procesar: async (filas, tx) => {
      const cache = new Map<string, boolean>();
      const salida: Fila[] = [];
      for (const f of filas) {
        let motivo: string | null = null;
        if (!(await conModulo(cache, String(f.empresa_id), tx))) 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) =>
      f.tabla === 'mapeo'
        ? `DELETE FROM tes_categoria_cuenta_contable WHERE id = ${comillas(f.id)};`
        : `UPDATE tes_categorias SET cuenta_contable_id = NULL WHERE id = ${comillas(f.id)};`,
  },
  {
    clave: 'borradores_no_confirmables',
    titulo: '5. Borradores con la suma de las categorías distinta del monto',
    nota: 'Confirmar vuelve a validar la suma: estos borradores darán CATEGORIAS_NO_SUMAN y habrá que eliminarlos o rehacerlos.',
    sql: `
      SELECT e.razon_social AS empresa, m.id, m.empresa_id, to_char(m.fecha, 'YYYY-MM-DD') AS fecha, c.nombre AS cuenta,
             m.monto, COALESCE(SUM(d.monto), 0) AS suma, m.monto - COALESCE(SUM(d.monto), 0) AS diferencia
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
        JOIN tes_cuentas c ON c.id = m.cuenta_id
        LEFT JOIN tes_movimiento_det d ON d.movimiento_id = m.id
       WHERE m.estado = 'BORRADOR'
       GROUP BY e.razon_social, m.id, m.empresa_id, m.fecha, c.nombre, m.monto
      HAVING ROUND(COALESCE(SUM(d.monto), 0) * 100) <> ROUND(m.monto * 100)
       ORDER BY e.razon_social, m.fecha, m.id`,
    columnas: ['id', 'fecha', 'cuenta', 'monto', 'suma', 'diferencia'],
  },
];

export const armarInforme = (base: string, fecha: string, resultados: Array<{ seccion: Seccion; filas: Fila[] }>): string =>
  armarInformeS1(base, fecha, resultados, 'Revisión de Tesorería S2');

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-s2');
    mkdirSync(dir, { recursive: true });
    writeFileSync(join(dir, 'revisar-tesoreria-s2.txt'), salida + '\n');
  } finally {
    await prisma.$disconnect();
  }
}

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