/**
 * Precarga de la regla "el contador decide las cuentas" (spec 2026-10-13).
 *
 * Para cada empresa con Contabilidad, completa los conceptos nuevos y los que
 * antes tenían respaldo con la cuenta que el código usaba hasta hoy, marcados
 * PRECARGA sin confirmar. Así ningún asiento cambia el día del despliegue y el
 * contador ve y confirma cada decisión. Idempotente: no pisa lo ya mapeado.
 *
 * Además informa, por empresa, los respaldos que NO se pueden reproducir con una
 * cuenta (antes se omitía la línea o caía a una cuenta que varía por documento):
 * cuántos documentos ya contabilizados quedarían pendientes si se rehacen, para
 * que el usuario decida antes de desplegar.
 *
 * Uso: npx ts-node -T scripts/data_script/precarga-mapeo-sin-decisiones.ts [--dry] [--empresa <uuid>]
 */
import { PrismaClient } from '@prisma/client';

/**
 * Mapeo actual por concepto. `usable: false` = la fila apunta a una cuenta desactivada o
 * de agrupación: en HEAD los respaldos la tragaban con su catch total y caían a la
 * cuenta de respaldo; ahora es FaltaMapeoError. Sin indicar, se toma como usable.
 */
type Mapeado = Map<string, { cuentaId: string | null; modo: string; usable?: boolean }>;
type Propuesta = { concepto: string; cuentaId: string | null; modo: 'CUENTA' | 'SUMAR_A_PRINCIPAL' };
type Contexto = {
  /** Cuenta que hoy usa cada categoría de tesorería de RRHH (null si no tiene). */
  cuentaCategoria: Partial<Record<'ANTICIPO' | 'PAGO_SUELDOS' | 'PAGO_IPS' | 'PAGO_FINIQUITO', string | null>>;
  /** Módulo Importaciones activo o embarques cargados. Sin indicar, se asume que sí. */
  usaImportaciones?: boolean;
};

/**
 * Componentes propios del finiquito (`desvinculaciones.service.ts`), que caían a la
 * categoría "Pago de Finiquito". El salario pendiente usa SUELDOS_JORNALES, que también
 * es el gasto de la liquidación de sueldos: precargarlo con la cuenta del finiquito
 * decidiría la cuenta de las liquidaciones futuras, así que no se precarga (se informa).
 */
const CONCEPTOS_FINIQUITO = ['INDEMNIZACION', 'PREAVISO', 'VACACIONES_FINIQUITO', 'AGUINALDO_FINIQUITO'];

/** De dónde sale cada precarga, para que el dry-run se pueda leer sin el código al lado. */
const DE_DONDE: Record<string, string> = {
  CHEQUES_EN_CARTERA: 'cuenta de CAJA_GENERAL',
  CHEQUES_EN_TRANSITO: 'cuenta de CHEQUES_EN_CARTERA, si no CAJA_GENERAL',
  PAGO_COMISIONES_FONDOS: 'cuenta de CAJA_GENERAL',
  PROVEEDORES_EXTERIOR: 'cuenta de PROVEEDORES',
  ACREEDORES_VARIOS: 'cuenta de PROVEEDORES',
  ANTICIPO_VIATICO: 'cuenta de ANTICIPO_PERSONAL',
  DESCUENTOS_VARIOS_RRHH: 'cuenta de ANTICIPO_PERSONAL, si no la de la categoría "Anticipo al personal (RRHH)"',
  SUELDOS_A_PAGAR: 'cuenta de la categoría "Pago de Sueldos"',
  IPS_A_DEPOSITAR: 'cuenta de la categoría "Pago de IPS"',
  ...Object.fromEntries(CONCEPTOS_FINIQUITO.map((c) => [c, 'cuenta de la categoría "Pago de Finiquito"'])),
  IMPORTACION_COMPRA: 'cuenta de INVENTARIO',
  IMPORTACION_GASTO: 'sumar a la cuenta del tipo de gasto',
  IMPORTACION_PAGO_PROVEEDOR: 'cuenta de IMPORTACIONES_EN_CURSO',
  IMPORTACION_TRIBUTOS: 'cuenta de IMPORTACIONES_EN_CURSO, si no INVENTARIO',
  IMPORTACION_ANTICIPO_IRE: 'cuenta de RETENCION_RENTA_FAVOR, si no la de IMPORTACION_TRIBUTOS',
  IVA_NO_DEDUCIBLE: 'sumar el IVA a la cuenta del gasto',
};

export function decidirPrecarga(mapeados: Mapeado, ctx: Contexto): Propuesta[] {
  // Una referencia inutilizable cuenta como sin cuenta: la cadena cae igual que en HEAD
  // (p. ej. puente desactivada → los tributos van a INVENTARIO).
  const cuenta = (c: string) => {
    const f = mapeados.get(c);
    return f && f.usable !== false ? f.cuentaId : null;
  };
  const categoria = (c: keyof Contexto['cuentaCategoria']) => ctx.cuentaCategoria[c] ?? null;
  const propuestas: Propuesta[] = [];
  const proponer = (concepto: string, cuentaId: string | null) => {
    if (mapeados.has(concepto) || !cuentaId) return;
    propuestas.push({ concepto, cuentaId, modo: 'CUENTA' });
  };
  const proponerSumar = (concepto: string) => {
    if (mapeados.has(concepto)) return;
    propuestas.push({ concepto, cuentaId: null, modo: 'SUMAR_A_PRINCIPAL' });
  };

  // Respaldos que desaparecen: la cuenta a la que caían. CHEQUES_A_PAGAR no: caía a la
  // cuenta de tesorería de cada detalle (o Caja), que no se reproduce con una sola
  // cuenta; lo informa `noReproducibles` y lo mapea el contador.
  proponer('CHEQUES_EN_CARTERA', cuenta('CAJA_GENERAL'));
  proponer('CHEQUES_EN_TRANSITO', cuenta('CHEQUES_EN_CARTERA') ?? cuenta('CAJA_GENERAL'));
  proponer('PAGO_COMISIONES_FONDOS', cuenta('CAJA_GENERAL'));
  proponer('PROVEEDORES_EXTERIOR', cuenta('PROVEEDORES'));
  proponer('ACREEDORES_VARIOS', cuenta('PROVEEDORES'));
  proponer('ANTICIPO_VIATICO', cuenta('ANTICIPO_PERSONAL'));

  // Movimientos de tesorería de RRHH: la cuenta que les ponía la categoría.
  proponer('DESCUENTOS_VARIOS_RRHH', cuenta('ANTICIPO_PERSONAL') ?? categoria('ANTICIPO'));
  proponer('SUELDOS_A_PAGAR', categoria('PAGO_SUELDOS'));
  proponer('IPS_A_DEPOSITAR', categoria('PAGO_IPS'));
  for (const c of CONCEPTOS_FINIQUITO) proponer(c, categoria('PAGO_FINIQUITO'));

  // Conceptos nuevos: lo que hacía el código. Solo en empresas que importan:
  // sin embarques ninguno se usa y serían filas para confirmar sin sentido.
  if (ctx.usaImportaciones !== false) {
    const puente = cuenta('IMPORTACIONES_EN_CURSO');
    const tributos = puente ?? cuenta('INVENTARIO');
    proponer('IMPORTACION_COMPRA', cuenta('INVENTARIO'));
    proponerSumar('IMPORTACION_GASTO');
    proponer('IMPORTACION_PAGO_PROVEEDOR', puente);
    proponer('IMPORTACION_TRIBUTOS', tributos);
    proponer('IMPORTACION_ANTICIPO_IRE', cuenta('RETENCION_RENTA_FAVOR') ?? tributos);
  }
  proponerSumar('IVA_NO_DEDUCIBLE');

  return propuestas;
}

/** Un respaldo que no se reproduce con una cuenta: documentos ya asentados que, rehechos, quedarían pendientes. */
type NoReproducible = { concepto: string; antes: string; documentos: number; ahora: string };

async function contar(prisma: PrismaClient, sql: string, empresaId: string): Promise<number> {
  const filas = await prisma.$queryRawUnsafe<Array<{ n: bigint }>>(sql, empresaId);
  return Number(filas[0]?.n ?? 0);
}

/** Documento asentado (CONFIRMADO) del origen dado; `$1` = empresa. */
const asentado = (origenTipo: string, idSql: string) =>
  `EXISTS (SELECT 1 FROM cont_documentos cd WHERE cd.empresa_id = $1::uuid AND cd.origen_tipo = '${origenTipo}' AND cd.origen_id = ${idSql} AND cd.estado = 'CONFIRMADO')`;

/**
 * Conceptos con fila que apunta a una cuenta inutilizable. La precarga no los pisa (es una
 * decisión ya tomada), pero en HEAD caían al respaldo y ahora quedan pendientes.
 */
export function mapeosInutilizables(mapeados: Mapeado): string[] {
  return [...mapeados].filter(([, f]) => f.usable === false).map(([c]) => c).sort();
}

export async function noReproducibles(prisma: PrismaClient, empresaId: string, mapeados: Mapeado, propuestas: Propuesta[]): Promise<NoReproducible[]> {
  // Falta = sin fila (o con cuenta inutilizable) y sin precarga: el integrador lo pide y no lo encuentra.
  const usable = (c: string) => !!mapeados.get(c)?.cuentaId && mapeados.get(c)?.usable !== false;
  const queda = (c: string) => !usable(c) && !propuestas.some((p) => p.concepto === c);
  const out: NoReproducible[] = [];
  const agregar = (concepto: string, antes: string, documentos: number, ahora = 'rehechos quedarían pendientes con aviso') => {
    if (documentos > 0) out.push({ concepto, antes, documentos, ahora });
  };

  // OP con cheque: sin CHEQUES_A_PAGAR el cheque se acreditaba a la cuenta de tesorería
  // del detalle o a Caja (varía por documento), así que no se precarga. Rehechas sin el
  // concepto (o con una cuenta inutilizable) quedarían pendientes con aviso.
  if (queda('CHEQUES_A_PAGAR')) {
    agregar('CHEQUES_A_PAGAR', 'cheque contra la cuenta de tesorería del detalle o Caja (no se precarga: no hay una sola cuenta que lo reproduzca)', await contar(prisma, `
      SELECT COUNT(DISTINCT op.id) AS n FROM orden_pago_proveedor_cab op
      JOIN orden_pago_proveedor_det d ON d.orden_pago_id = op.id
      JOIN medio_pago mp ON mp.id = d.medio_pago_id AND mp.codigo = 2
      WHERE op.empresa_id = $1::uuid AND ${asentado('orden_pago_proveedor_cab', 'op.id')}`, empresaId),
      'rehechas quedarían pendientes con aviso hasta que el contador mapee CHEQUES_A_PAGAR');
  }

  // Transferencias entre monedas: sin el concepto se omitía la diferencia de cambio.
  for (const c of ['DIFERENCIA_CAMBIO_GANADA', 'DIFERENCIA_CAMBIO_PERDIDA']) {
    if (!queda(c)) continue;
    agregar(c, 'transferencia entre monedas sin línea de diferencia (cota superior: no se mira si hubo diferencia)', await contar(prisma, `
      SELECT COUNT(DISTINCT o.transferencia_id) AS n FROM tes_movimientos o
      JOIN tes_movimientos d ON d.transferencia_id = o.transferencia_id AND d.origen_tipo = 'TRANSFERENCIA_DESTINO'
      JOIN tes_cuentas co ON co.id = o.cuenta_id
      JOIN tes_cuentas cdn ON cdn.id = d.cuenta_id
      WHERE o.empresa_id = $1::uuid AND o.origen_tipo = 'TRANSFERENCIA_ORIGEN' AND co.moneda <> cdn.moneda
        AND ${asentado('tes_transferencias', 'o.transferencia_id')}`, empresaId));
  }

  if (queda('ANTICIPO_DESPACHO')) {
    // Despacho con anticipo y cuenta puente: antes se acreditaba al proveedor del embarque.
    if (usable('IMPORTACIONES_EN_CURSO')) {
      agregar('ANTICIPO_DESPACHO', 'despacho con anticipo acreditado al proveedor del embarque', await contar(prisma, `
        SELECT COUNT(*) AS n FROM imp_despachos de
        WHERE de.empresa_id = $1::uuid AND ${asentado('imp_despacho', 'de.id')}
          AND EXISTS (SELECT 1 FROM tes_movimientos m WHERE m.embarque_id = de.embarque_id
                      AND m.tipo_pago_importacion = 'DESPACHO' AND m.estado <> 'ANULADO')`, empresaId));
    }
    // Anticipo al despachante: antes iba a la cuenta de la categoría del movimiento.
    agregar('ANTICIPO_DESPACHO', 'anticipo al despachante (tesorería) contra la cuenta de su categoría', await contar(prisma, `
      SELECT COUNT(*) AS n FROM tes_movimientos m
      WHERE m.empresa_id = $1::uuid AND m.embarque_id IS NOT NULL AND m.tipo_pago_importacion = 'DESPACHO'
        AND ${asentado('tes_movimientos', 'm.id')}`, empresaId));
  }

  // Pago al proveedor del exterior sin puente: antes iba a la categoría (varía por movimiento).
  if (queda('IMPORTACION_PAGO_PROVEEDOR')) {
    agregar('IMPORTACION_PAGO_PROVEEDOR', 'pago imputado a importación contra la cuenta de su categoría', await contar(prisma, `
      SELECT COUNT(*) AS n FROM tes_movimientos m
      WHERE m.empresa_id = $1::uuid AND m.embarque_id IS NOT NULL AND m.tipo_pago_importacion = 'PROVEEDOR'
        AND ${asentado('tes_movimientos', 'm.id')}`, empresaId));
  }

  // SUELDOS_JORNALES: el salario pendiente del finiquito caía a la categoría; ahora el
  // pago queda pendiente con aviso. Los finiquitos ya pagados guardaron su cuenta y no cambian.
  if (queda('SUELDOS_JORNALES')) {
    agregar('SUELDOS_JORNALES', 'salario pendiente del finiquito contra la cuenta de la categoría "Pago de Finiquito"', await contar(prisma, `
      SELECT COUNT(*) AS n FROM rrhh_desvinculaciones dv
      WHERE dv.empresa_id = $1::uuid AND dv.estado <> 'ANULADO' AND dv.salario_pendiente + dv.otros_haberes > 0
        AND NOT EXISTS (SELECT 1 FROM tes_movimientos m WHERE m.empresa_id = $1::uuid AND m.origen_tipo = 'rrhh_desvinculacion' AND m.origen_id = dv.id)`, empresaId),
      'finiquitos con componente de sueldo aún sin pagar (cota superior: el neteo de descuentos puede dejarlo en 0): al pagarse quedarían pendientes con aviso hasta mapearlo');
    agregar('SUELDOS_JORNALES', 'liquidación de sueldos sin asiento (el concepto es obligatorio)', await contar(prisma, `
      SELECT COUNT(*) AS n FROM rrhh_liquidaciones_cabecera l
      WHERE l.empresa_id = $1::uuid AND l.estado = 'CERRADA'
        AND NOT EXISTS (SELECT 1 FROM cont_documentos cd WHERE cd.empresa_id = $1::uuid AND cd.origen_tipo = 'rrhh_liquidacion' AND cd.origen_id = l.id)`, empresaId),
      'liquidaciones cerradas sin asiento: siguen así hasta que el contador lo mapee');
  }

  // Devengamiento de comisiones con IVA: sin IVA_CREDITO_10 se asentaba todo como gasto.
  if (queda('IVA_CREDITO_10')) {
    agregar('IVA_CREDITO_10', 'devengamiento de comisiones con IVA asentado todo como gasto (cota superior)', await contar(prisma, `
      SELECT COUNT(*) AS n FROM cont_documentos cd
      WHERE cd.empresa_id = $1::uuid AND cd.origen_tipo = 'liquidacion_comisiones_deveng' AND cd.estado = 'CONFIRMADO'`, empresaId));
  }

  // Recibo multi en moneda extranjera: en HEAD una línea opcional sin concepto se omitía y la
  // diferencia de cambio absorbía el descuadre, así que el asiento salía igual. Ahora queda
  // pendiente. Cota superior: no mira si el recibo usaba ese concepto.
  const opcionalesRecibo = ['RETENCION_IVA_FAVOR', 'RETENCION_RENTA_FAVOR', 'ANTICIPOS_CLIENTES', 'PROVEEDORES', 'INTERESES_MORATORIOS_COBRADOS',
    'CONSUMO_FUNCIONARIO_PUENTE', 'SUELDOS_JORNALES', 'CHEQUES_EN_CARTERA', 'CHEQUES_EN_TRANSITO'].filter(queda);
  if (opcionalesRecibo.length && (usable('DIFERENCIA_CAMBIO_GANADA') || usable('DIFERENCIA_CAMBIO_PERDIDA'))) {
    agregar(opcionalesRecibo.join(', '), 'recibo multi en moneda extranjera: la línea se omitía y la diferencia de cambio absorbía el descuadre (cota superior)', await contar(prisma, `
      SELECT COUNT(*) AS n FROM cont_documentos cd
      JOIN recibos_cobro r ON r.id = cd.origen_id
      LEFT JOIN moneda mo ON mo.id = r.moneda_id
      WHERE cd.empresa_id = $1::uuid AND cd.origen_tipo = 'recibos_multi' AND cd.estado = 'CONFIRMADO'
        AND COALESCE(mo.codigo, 'PYG') <> 'PYG'`, empresaId));
  }

  return out;
}

/** Avisos que no cambian asientos existentes pero conviene saber antes de desplegar. */
async function avisos(prisma: PrismaClient, empresaId: string, mapeados: Mapeado, propuestas: Propuesta[]): Promise<string[]> {
  const out: string[] = [];
  if (!mapeados.has('BANCO')) {
    out.push('BANCO sin mapear: viáticos cuya cuenta de tesorería no tenga cuenta contable quedan pendientes con aviso (antes: sin asiento). No se precarga.');
  }
  // Estos conceptos también los usa la liquidación de sueldos: precargarlos hace que
  // las liquidaciones cerradas sin asiento (por falta de mapeo) se puedan regenerar con esa cuenta.
  const deSueldos = ['SUELDOS_A_PAGAR', 'IPS_A_DEPOSITAR', 'DESCUENTOS_VARIOS_RRHH'].filter((c) =>
    propuestas.some((p) => p.concepto === c),
  );
  if (deSueldos.length) {
    const n = await contar(prisma, `
      SELECT COUNT(*) AS n FROM rrhh_liquidaciones_cabecera l
      WHERE l.empresa_id = $1::uuid AND l.estado = 'CERRADA'
        AND NOT EXISTS (SELECT 1 FROM cont_documentos cd WHERE cd.empresa_id = $1::uuid AND cd.origen_tipo = 'rrhh_liquidacion' AND cd.origen_id = l.id)`, empresaId);
    if (n > 0) {
      out.push(`${deSueldos.join(', ')} también los usa la liquidación de sueldos: ${n} liquidaciones cerradas sin asiento usarían la cuenta precargada si se regeneran.`);
    }
  }
  return out;
}

/** Cuenta que hoy usa una categoría de tesorería del sistema para la empresa. */
async function cuentaDeCategoria(prisma: PrismaClient, empresaId: string, codigoInterno: string, primeroLaGlobal: boolean): Promise<string | null> {
  const cat = await prisma.tes_categorias.findFirst({
    where: { codigo_interno: codigoInterno, is_sistema: true },
    select: { id: true, cuenta_contable_id: true },
  });
  if (!cat) return null;
  const propia = await prisma.tes_categoria_cuenta_contable.findFirst({
    where: { empresa_id: empresaId, categoria_id: cat.id },
    select: { cuenta_contable_id: true },
  });
  // Anticipo/sueldos/IPS guardaban `categoria.cuenta_contable_id` en el detalle y, si era
  // null, el integrador usaba la de la empresa; el finiquito dejaba el detalle sin cuenta
  // y el integrador miraba primero la de la empresa. Mismo orden que el código de antes.
  return primeroLaGlobal
    ? cat.cuenta_contable_id ?? propia?.cuenta_contable_id ?? null
    : propia?.cuenta_contable_id ?? cat.cuenta_contable_id ?? null;
}

async function main() {
  const dry = process.argv.includes('--dry');
  const i = process.argv.indexOf('--empresa');
  const soloEmpresa = i > -1 ? process.argv[i + 1] : null;
  const prisma = new PrismaClient();
  try {
    const empresas = await prisma.suscripcion_modulos.findMany({
      where: { activo: true, modulos: { codigo: 'CONTABILIDAD' }, ...(soloEmpresa ? { suscripciones: { empresa_id: soloEmpresa } } : {}) },
      select: { suscripciones: { select: { empresa_id: true } } },
    });
    const ids = [...new Set(empresas.map((e) => e.suscripciones?.empresa_id).filter((v): v is string => !!v))];
    console.log(`${dry ? '[DRY] ' : ''}${ids.length} empresas con Contabilidad`);

    let insertadas = 0;
    for (const empresaId of ids) {
      const filas = await prisma.cont_mapeo_cuentas.findMany({
        where: { empresa_id: empresaId },
        select: { concepto: true, cuenta_id: true, modo: true, cuenta: { select: { active: true, acepta_movimientos: true } } },
      });
      const mapeados: Mapeado = new Map(
        filas.map((f) => [f.concepto, { cuentaId: f.cuenta_id, modo: f.modo, usable: !f.cuenta || (f.cuenta.active && f.cuenta.acepta_movimientos) }]),
      );

      const [moduloImp, embarques] = await Promise.all([
        prisma.suscripcion_modulos.count({ where: { activo: true, modulos: { codigo: 'IMPORTACIONES' }, suscripciones: { empresa_id: empresaId } } }),
        prisma.imp_embarques.count({ where: { empresa_id: empresaId } }),
      ]);
      const propuestas = decidirPrecarga(mapeados, {
        cuentaCategoria: {
          ANTICIPO: await cuentaDeCategoria(prisma, empresaId, 'ANTICIPO_PERSONAL_RRHH', true),
          PAGO_SUELDOS: await cuentaDeCategoria(prisma, empresaId, 'PAGO_SUELDOS', true),
          PAGO_IPS: await cuentaDeCategoria(prisma, empresaId, 'PAGO_IPS', true),
          PAGO_FINIQUITO: await cuentaDeCategoria(prisma, empresaId, 'PAGO_FINIQUITO', false),
        },
        usaImportaciones: moduloImp > 0 || embarques > 0,
      });

      const empresa = await prisma.empresas.findUnique({ where: { id: empresaId }, select: { razon_social: true } });
      const cuentas = await prisma.cont_plan_cuentas.findMany({
        where: { id: { in: propuestas.map((p) => p.cuentaId).filter((v): v is string => !!v) } },
        select: { id: true, codigo: true, descripcion: true },
      });
      const etiqueta = new Map(cuentas.map((c) => [c.id, `${c.codigo} ${c.descripcion ?? ''}`]));

      console.log(`\n== ${empresaId} ${empresa?.razon_social ?? ''} — ${propuestas.length} conceptos a precargar${moduloImp || embarques ? '' : ' (no usa importaciones: IMPORTACION_* no se precargan)'}`);
      for (const p of propuestas) {
        const destino = p.modo === 'CUENTA' ? etiqueta.get(p.cuentaId as string) ?? p.cuentaId : 'sumar a la principal';
        console.log(`  + ${p.concepto} → ${destino}   [${DE_DONDE[p.concepto] ?? ''}]`);
      }
      const nr = await noReproducibles(prisma, empresaId, mapeados, propuestas);
      for (const c of mapeosInutilizables(mapeados)) {
        console.log(`  ! CUENTA INUTILIZABLE ${c}: la fila apunta a una cuenta desactivada o de agrupación; en HEAD caía al respaldo, ahora queda pendiente; no se pisa — reasignalo`);
      }
      for (const n of nr) console.log(`  ! NO REPRODUCIBLE ${n.concepto}: ${n.documentos} documentos asentados (antes: ${n.antes}); ${n.ahora}`);
      for (const a of await avisos(prisma, empresaId, mapeados, propuestas)) console.log(`  i ${a}`);

      if (dry || propuestas.length === 0) continue;
      const r = await prisma.cont_mapeo_cuentas.createMany({
        data: propuestas.map((p) => ({ empresa_id: empresaId, concepto: p.concepto, cuenta_id: p.cuentaId, modo: p.modo, origen: 'PRECARGA' })),
        skipDuplicates: true,
      });
      insertadas += r.count;
      console.log(`  insertadas: ${r.count}`);
    }
    console.log(dry ? '\n[DRY] no se escribió nada' : `\nTotal insertadas: ${insertadas}`);
  } finally {
    await prisma.$disconnect();
  }
}

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