/**
 * Revisión de Tesorería S3 (Transferencias) 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 3 y 6 son para el contador).
 *
 * Secciones (en este orden):
 *   1. Transferencias confirmadas sin asiento en empresas con CONTABILIDAD.
 *   2. Transferencias a las que les falta una punta o con las dos puntas en estados distintos.
 *   3. Transferencias de moneda extranjera a PYG con asiento de 3 líneas (afectadas por el signo de la diferencia, D12).
 *   4. Transferencias entre dos monedas extranjeras (desde S3 no se pueden crear, D6).
 *   5. Transferencias anuladas con algún movimiento conciliado (desde S3 no se pueden anular, D1).
 *   6. Multimoneda sin `tipo_cambio`, o con el tipo de cambio implícito a más de ±20 % de `cont_tipo_cambio` (F5).
 *
 * Salida: stdout y ~/.local/share/novasis-video-trabajo/tesoreria-s3/revisar-tesoreria-s3.txt.
 * Uso: npx ts-node --transpile-only -r tsconfig-paths/register --project tsconfig.scripts.json scripts/revisar-tesoreria-s3.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 { DESVIO_MAXIMO_TC } from '../src/tesoreria/services/tipo-cambio-transferencia';
import { armarInforme as armarInformeS1, type Fila, type Seccion } from './revisar-tesoreria-s1';

export type { Fila, Seccion };

/** Cada transferencia con sus dos puntas: origen `o` y destino `d` (puede faltar), las monedas y los montos. */
const TRANSFERENCIAS_SQL = `
        FROM tes_movimientos o
        JOIN empresas e ON e.id = o.empresa_id
        JOIN tes_cuentas co ON co.id = o.cuenta_id
        LEFT JOIN tes_movimientos d ON d.transferencia_id = o.transferencia_id AND d.origen_tipo = 'TRANSFERENCIA_DESTINO'
        LEFT JOIN tes_cuentas cd ON cd.id = d.cuenta_id
       WHERE o.origen_tipo = 'TRANSFERENCIA_ORIGEN' AND o.transferencia_id IS NOT NULL`;

const COLUMNAS_TRANSFERENCIA = `e.razon_social AS empresa, o.empresa_id, o.transferencia_id, to_char(o.fecha, 'YYYY-MM-DD') AS fecha, o.estado,
             co.nombre AS cuenta_origen, co.moneda AS moneda_origen, o.monto AS monto_origen,
             cd.nombre AS cuenta_destino, cd.moneda AS moneda_destino, d.monto AS monto_destino`;

const num = (v: unknown): number | null => (v === null || v === undefined || v === '' ? null : Number(v));
const fmt = (n: number) => n.toLocaleString('es-PY', { maximumFractionDigits: 2 });

/** 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: 'sin_asiento',
    titulo: '1. Transferencias confirmadas sin asiento (empresas con CONTABILIDAD)',
    nota: 'Confirmadas sin documento contable CONFIRMADO. Desde S3 el alta dice por qué no hay asiento; las anteriores se contabilizan con «Reintentar contabilización» en la pestaña Transferencias, una vez corregida la causa (cuenta contable de la cuenta, mapeo de la diferencia de cambio o período).',
    sql: `
      SELECT ${COLUMNAS_TRANSFERENCIA}
      ${TRANSFERENCIAS_SQL}
         AND o.estado = 'CONFIRMADO'
         AND NOT EXISTS (SELECT 1 FROM cont_documentos doc
                          WHERE doc.empresa_id = o.empresa_id AND doc.origen_tipo = 'tes_transferencias'
                            AND doc.origen_id = o.transferencia_id AND doc.estado = 'CONFIRMADO')
       ORDER BY e.razon_social, o.fecha, o.transferencia_id`,
    columnas: ['transferencia_id', 'fecha', 'cuenta_origen', 'monto_origen', 'cuenta_destino', 'monto_destino'],
    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)) salida.push(f);
      return salida;
    },
  },
  {
    clave: 'puntas',
    titulo: '2. Transferencias sin una de sus puntas o con las puntas en estados distintos',
    nota: 'Una transferencia son dos movimientos (salida y entrada) con el mismo transferencia_id y el mismo estado. Si falta uno o están en estados distintos, el saldo de una de las cuentas no refleja la transferencia. Revisar a mano con el cliente.',
    sql: `
      SELECT e.razon_social AS empresa, m.empresa_id, m.transferencia_id, to_char(MIN(m.fecha), 'YYYY-MM-DD') AS fecha,
             COUNT(*) FILTER (WHERE m.origen_tipo = 'TRANSFERENCIA_ORIGEN')::int AS n_origen,
             COUNT(*) FILTER (WHERE m.origen_tipo = 'TRANSFERENCIA_DESTINO')::int AS n_destino,
             string_agg(DISTINCT m.estado, ',' ORDER BY m.estado) AS estados
        FROM tes_movimientos m
        JOIN empresas e ON e.id = m.empresa_id
       WHERE m.transferencia_id IS NOT NULL AND m.origen_tipo IN ('TRANSFERENCIA_ORIGEN', 'TRANSFERENCIA_DESTINO')
       GROUP BY e.razon_social, m.empresa_id, m.transferencia_id
       ORDER BY e.razon_social, fecha, m.transferencia_id`,
    columnas: ['transferencia_id', 'fecha', 'n_origen', 'n_destino', 'estados', 'motivo'],
    procesar: async (filas) =>
      filas.flatMap((f) => {
        const motivos: string[] = [];
        if (Number(f.n_origen) !== 1) motivos.push(Number(f.n_origen) === 0 ? 'sin punta origen' : `${f.n_origen} puntas origen`);
        if (Number(f.n_destino) !== 1) motivos.push(Number(f.n_destino) === 0 ? 'sin punta destino' : `${f.n_destino} puntas destino`);
        if (String(f.estados ?? '').includes(',')) motivos.push(`estados distintos (${f.estados})`);
        return motivos.length ? [{ ...f, motivo: motivos.join('; ') }] : [];
      }),
  },
  {
    clave: 'extranjera_a_pyg',
    titulo: '3. Transferencias de moneda extranjera a guaraníes con asiento de 3 líneas (para el contador)',
    nota: 'Hasta S3 el asiento de una transferencia de moneda extranjera a guaraníes con diferencia de cambio salía con los importes cruzados y la diferencia con el signo al revés (ganancia registrada como pérdida y al revés). Desde S3 se arma bien; estas son las anteriores. Cómo corregirlas lo decide el contador (el script no toca nada).',
    sql: `
      SELECT ${COLUMNAS_TRANSFERENCIA},
             (SELECT COUNT(*)::int FROM cont_documentos doc
                JOIN cont_asientos a ON a.documento_id = doc.id
                JOIN cont_asientos_det l ON l.asiento_id = a.id
               WHERE doc.empresa_id = o.empresa_id AND doc.origen_tipo = 'tes_transferencias'
                 AND doc.origen_id = o.transferencia_id AND doc.estado = 'CONFIRMADO') AS lineas
      ${TRANSFERENCIAS_SQL}
         AND co.moneda <> 'PYG' AND cd.moneda = 'PYG'
       ORDER BY e.razon_social, o.fecha, o.transferencia_id`,
    columnas: ['transferencia_id', 'fecha', 'estado', 'cuenta_origen', 'monto_origen', 'cuenta_destino', 'monto_destino', 'lineas'],
    procesar: async (filas) => filas.filter((f) => f.moneda_origen !== 'PYG' && f.moneda_destino === 'PYG' && Number(f.lineas) >= 3),
  },
  {
    clave: 'entre_extranjeras',
    titulo: '4. Transferencias entre dos monedas extranjeras',
    nota: 'El importe acreditado se calculaba como monto × tipo de cambio aunque ninguna cuenta fuera en guaraníes. Desde S3 no se pueden crear (hay que pasar por una cuenta en guaraníes). Revisar el saldo de la cuenta destino con el cliente.',
    sql: `
      SELECT ${COLUMNAS_TRANSFERENCIA}
      ${TRANSFERENCIAS_SQL}
         AND co.moneda <> cd.moneda AND co.moneda <> 'PYG' AND cd.moneda <> 'PYG'
       ORDER BY e.razon_social, o.fecha, o.transferencia_id`,
    columnas: ['transferencia_id', 'fecha', 'estado', 'cuenta_origen', 'moneda_origen', 'monto_origen', 'cuenta_destino', 'moneda_destino', 'monto_destino'],
    procesar: async (filas) =>
      filas.filter((f) => f.moneda_origen && f.moneda_destino && f.moneda_origen !== f.moneda_destino && f.moneda_origen !== 'PYG' && f.moneda_destino !== 'PYG'),
  },
  {
    clave: 'anuladas_conciliadas',
    titulo: '5. Transferencias anuladas con algún movimiento conciliado',
    nota: 'La línea del extracto quedó conciliada con un movimiento anulado. Desde S3 una transferencia conciliada no se anula; estas son anteriores. Se desconcilian en Conciliación bancaria.',
    sql: `
      SELECT e.razon_social AS empresa, m.empresa_id, m.transferencia_id, m.id AS movimiento_id, m.origen_tipo,
             to_char(m.fecha, 'YYYY-MM-DD') AS fecha, c.nombre AS cuenta, m.monto, l.id AS linea_id
        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_extracto_lineas l ON l.movimiento_id = m.id
       WHERE m.origen_tipo IN ('TRANSFERENCIA_ORIGEN', 'TRANSFERENCIA_DESTINO')
         AND m.estado = 'ANULADO' AND l.conciliado = true
       ORDER BY e.razon_social, m.fecha, m.transferencia_id`,
    columnas: ['transferencia_id', 'fecha', 'origen_tipo', 'cuenta', 'monto', 'linea_id'],
  },
  {
    clave: 'tipo_cambio',
    titulo: '6. Transferencias entre monedas sin tipo de cambio o con un tipo de cambio lejos del de Contabilidad (para el contador)',
    nota: `Confirmadas entre guaraníes y otra moneda. Sin tipo_cambio: se cargaron antes del campo y la pantalla muestra «—». El tipo de cambio implícito es guaraníes / moneda extranjera; si se aparta más de ±${DESVIO_MAXIMO_TC * 100} % del de cont_tipo_cambio a esa fecha, el importe acreditado (y el asiento) puede estar mal, como la de DOBA del 04/09 (Gs. 32.000 → US$ 5.364,63). Es dinero: lo decide el contador.`,
    sql: `
      SELECT ${COLUMNAS_TRANSFERENCIA}, o.tipo_cambio,
             (SELECT tc.tasa FROM cont_tipo_cambio tc
               WHERE tc.empresa_id = o.empresa_id AND tc.moneda = CASE WHEN co.moneda = 'PYG' THEN cd.moneda ELSE co.moneda END
                 AND tc.fecha <= o.fecha
               ORDER BY tc.fecha DESC LIMIT 1) AS tasa_sistema
      ${TRANSFERENCIAS_SQL}
         AND o.estado = 'CONFIRMADO' AND co.moneda <> cd.moneda AND (co.moneda = 'PYG' OR cd.moneda = 'PYG')
       ORDER BY e.razon_social, o.fecha, o.transferencia_id`,
    columnas: ['transferencia_id', 'fecha', 'cuenta_origen', 'monto_origen', 'cuenta_destino', 'monto_destino', 'tipo_cambio', 'tc_implicito', 'tasa_sistema', 'motivo'],
    procesar: async (filas) =>
      filas.flatMap((f) => {
        const origenPyg = f.moneda_origen === 'PYG';
        const pyg = num(origenPyg ? f.monto_origen : f.monto_destino);
        const extranjera = num(origenPyg ? f.monto_destino : f.monto_origen);
        const implicito = pyg !== null && extranjera ? pyg / extranjera : null;
        const tasa = num(f.tasa_sistema);
        const motivos: string[] = [];
        if (num(f.tipo_cambio) === null) motivos.push('sin tipo_cambio');
        if (implicito !== null && tasa && tasa > 1 && Math.abs(implicito - tasa) / tasa > DESVIO_MAXIMO_TC) {
          motivos.push(`TC implícito Gs. ${fmt(implicito)} a más de ±${DESVIO_MAXIMO_TC * 100} % de Gs. ${fmt(tasa)}`);
        }
        return motivos.length ? [{ ...f, tc_implicito: implicito === null ? null : fmt(implicito), motivo: motivos.join('; ') }] : [];
      }),
  },
];

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

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

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