/**
 * One-shot: regulariza los descuentos de consumo de funcionarios que ya se
 * hicieron por planilla pero nunca cancelaron la factura.
 *
 * El problema: hasta ahora RRHH cargaba el descuento a mano, escribiendo el
 * número de factura en la observación (cuando lo escribía). La plata se le
 * descontaba al funcionario, pero la factura quedaba abierta en cuentas por
 * cobrar, así que el empleado seguía figurando como deudor para siempre.
 *
 * Qué hace por cada descuento ya aplicado:
 *   1. Resuelve a qué factura corresponde (ver más abajo).
 *   2. Baja el saldo de esa cuenta por cobrar.
 *   3. Emite el recibo que lo documenta, con medio DESCUENTO_PLANILLA y fecha
 *      fin del mes liquidado (criterio que pidió el contador).
 *   4. Marca la línea con origen CONSUMO_FUNCIONARIO y la referencia a la
 *      cuenta por cobrar, para que quede trazable y no se reprocese.
 *
 * Cómo resuelve la factura, en orden:
 *   a. Número escrito en la observación ("Fact. Nro 2165", "pago fact. 2353").
 *   b. Si no hay, por MONTO EXACTO contra las facturas abiertas del funcionario,
 *      y sólo si hay UNA sola candidata. Si hay varias o ninguna, no adivina:
 *      lo reporta y lo saltea.
 *
 * No toca los conceptos que no son consumo facturado. "Uniforme" y
 * "Coorporativo" son planes de cuotas internos — se verificó que no existe
 * ninguna factura por esos importes — así que quedan fuera por defecto.
 *
 * Los asientos NO los genera este script: los recibos quedan creados y el
 * asiento se emite desde Contabilidad → Conciliación Contable → Regenerar,
 * que es el mecanismo normal del sistema.
 *
 * Idempotente: saltea las líneas que ya tienen origen CONSUMO_FUNCIONARIO.
 *
 * Uso:
 *   pnpm exec ts-node scripts/regularizar-consumo-funcionario.ts \
 *     --empresa=<id> [--desde=2026-06] [--conceptos=Mercadería] [--apply]
 *
 * Sin --apply → dry-run (default seguro).
 */
import 'dotenv/config';
import { Prisma, PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

const MEDIO_DESCUENTO_PLANILLA = 'DESCUENTO_PLANILLA';
const r2 = (n: number) => Math.round((n + Number.EPSILON) * 100) / 100;
const num = (v: unknown) => (Number.isFinite(Number(v)) ? Number(v) : 0);

function parseArgs(argv: string[]) {
  const get = (k: string) =>
    argv
      .find((a) => a.startsWith(`--${k}=`))
      ?.split('=')
      .slice(1)
      .join('=');
  return {
    apply: argv.includes('--apply'),
    empresa: get('empresa'),
    desde: get('desde') ?? '2026-06',
    conceptos: (get('conceptos') ?? 'Mercadería')
      .split(',')
      .map((s) => s.trim())
      .filter(Boolean),
  };
}

/** Extrae el número de factura de un texto libre: "pago fact. 2353" → "2353". */
function numeroDeFacturaEnTexto(obs: string | null): string | null {
  if (!obs) return null;
  const m = obs.match(/(?:fact\.?|factura)\s*(?:nro\.?|n°|no\.?|#)?\s*(\d{3,7})/i);
  return m ? m[1] : null;
}

async function main() {
  const { apply, empresa, desde, conceptos } = parseArgs(process.argv.slice(2));
  if (!empresa) {
    console.error('Falta --empresa=<uuid>');
    process.exit(1);
  }
  const [anioDesde, mesDesde] = desde.split('-').map(Number);

  console.log(`\nRegularización de consumo de funcionarios  [${apply ? 'APLICANDO' : 'DRY-RUN'}]`);
  console.log(`Empresa ${empresa} · desde ${desde} · conceptos: ${conceptos.join(', ')}\n`);

  const lineas = await prisma.rrhh_liquidaciones_detalle.findMany({
    where: {
      tipo: 'EGRESO',
      origen: { not: 'CONSUMO_FUNCIONARIO' }, // idempotencia
      concepto: { empresa_id: empresa, nombre: { in: conceptos } },
      liquidacion: {
        empresa_id: empresa,
        estado: 'CERRADA',
        OR: [{ periodo_anio: { gt: anioDesde } }, { periodo_anio: anioDesde, periodo_mes: { gte: mesDesde } }],
      },
    },
    include: {
      liquidacion: { select: { id: true, periodo_anio: true, periodo_mes: true } },
      empleado: {
        select: {
          id: true,
          numero_empleado: true,
          nombres: true,
          apellidos: true,
          cliente_id: true,
          sucursal_id: true,
        },
      },
      concepto: { select: { nombre: true } },
    },
    orderBy: [{ liquidacion: { periodo_anio: 'asc' } }, { liquidacion: { periodo_mes: 'asc' } }],
  });

  if (!lineas.length) {
    console.log('No hay descuentos pendientes de regularizar.');
    return;
  }

  let ok = 0;
  const pendientes: string[] = [];

  for (const l of lineas) {
    const emp = l.empleado;
    const nombre = `${emp.nombres} ${emp.apellidos}`.replace(/\s+/g, ' ').trim();
    const periodo = `${String(l.liquidacion.periodo_mes).padStart(2, '0')}/${l.liquidacion.periodo_anio}`;
    const monto = r2(num(l.monto));
    const et = `  ${periodo}  ${nombre.padEnd(32)} ${String(monto).padStart(10)}`;

    if (!emp.cliente_id) {
      pendientes.push(`${et} → SIN ficha de cliente (correr primero backfill:empleado-cliente)`);
      continue;
    }

    const abiertas = await prisma.cuentas_cobrar.findMany({
      where: { empresa_id: empresa, cliente_id: emp.cliente_id, saldo_pendiente: { gt: 0 } },
      select: {
        id: true,
        saldo_pendiente: true,
        monto_total: true,
        factura_venta_id: true,
        factura_cab: { select: { dnumdoc: true, dest: true, dpunexp: true } },
      },
      orderBy: { fecha_emision: 'asc' },
    });

    // a) por número escrito en la observación
    const nroObs = numeroDeFacturaEnTexto(l.observacion);
    let candidatas = nroObs
      ? abiertas.filter((c) => c.factura_cab?.dnumdoc?.replace(/^0+/, '') === nroObs.replace(/^0+/, ''))
      : [];
    let via = 'observación';

    // b) si no, por monto exacto — y sólo si es inequívoco
    if (!candidatas.length) {
      candidatas = abiertas.filter((c) => Math.abs(num(c.monto_total) - monto) < 0.01);
      via = 'monto exacto';
    }

    if (candidatas.length === 0) {
      const detalle = nroObs
        ? `no se encontró la factura ${nroObs} abierta`
        : 'ninguna factura abierta por ese importe';
      pendientes.push(`${et} → SIN MATCH: ${detalle}`);
      continue;
    }
    if (candidatas.length > 1) {
      const nums = candidatas.map((c) => c.factura_cab?.dnumdoc).join(', ');
      pendientes.push(`${et} → AMBIGUO: coinciden ${candidatas.length} facturas (${nums}). Decide DOBA.`);
      continue;
    }

    const cuenta = candidatas[0];
    const saldo = num(cuenta.saldo_pendiente);
    const aCobrar = r2(Math.min(monto, saldo));
    const sobrante = r2(monto - aCobrar);
    const nro = cuenta.factura_cab?.dnumdoc ?? '(sin factura)';

    console.log(`${et} → factura ${nro} (${via})${sobrante > 0 ? `  ⚠ descontado de más: ${sobrante}` : ''}`);
    if (sobrante > 0) {
      pendientes.push(`${et} → se descontaron ${sobrante} MÁS que la factura ${nro}. Decide DOBA cómo devolverlo.`);
    }

    if (apply) {
      await prisma.$transaction(async (tx) => {
        const nuevoSaldo = r2(saldo - aCobrar);
        await tx.cuentas_cobrar.update({
          where: { id: cuenta.id },
          data: {
            saldo_pendiente: nuevoSaldo,
            estado: nuevoSaldo <= 0 ? 'cobrada' : 'pendiente',
            updated_at: new Date(),
          },
        });

        // Fecha fin del mes liquidado, según pidió el contador.
        const finDeMes = new Date(l.liquidacion.periodo_anio, l.liquidacion.periodo_mes, 0);
        const numeroRecibo = await generarNumero(tx, empresa, emp.sucursal_id);

        const recibo = await tx.recibos_cobro.create({
          data: {
            empresa_id: empresa,
            sucursal_id: emp.sucursal_id,
            cliente_id: emp.cliente_id!,
            numero_recibo: numeroRecibo,
            fecha_emision: finDeMes,
            monto_total: aCobrar,
            // Los totales que lee el asiento (integrarReciboMulti).
            total_facturas: aCobrar,
            total_pagado: aCobrar,
            estado: 'emitido',
            modo: 'MULTI',
            observacion: `Regularización — descuento por planilla ${periodo}`,
            medios_pago_multi: { create: [{ medio: MEDIO_DESCUENTO_PLANILLA, monto: aCobrar }] },
          },
          select: { id: true },
        });

        if (cuenta.factura_venta_id) {
          await tx.recibo_cobro_facturas.create({
            data: {
              recibo_cobro_id: recibo.id,
              factura_cab_id: cuenta.factura_venta_id,
              cuota_id: cuenta.id,
              monto_saldo_previo: saldo,
              monto_pagado: aCobrar,
              orden: 0,
            },
          });
        }

        await tx.rrhh_liquidaciones_detalle.update({
          where: { id: l.id },
          data: { origen: 'CONSUMO_FUNCIONARIO', referencia_origen_id: cuenta.id, updated_at: new Date() },
        });
      });
    }
    ok++;
  }

  console.log(`\n${ok} descuentos regularizados.`);
  if (pendientes.length) {
    console.log(`\n${pendientes.length} requieren decisión de DOBA:`);
    pendientes.forEach((p) => console.log(p));
  }
  if (!apply) console.log('\nFue un dry-run. Volvé a correrlo con --apply para aplicar.\n');
  if (apply) console.log('\nFalta generar los asientos: Contabilidad → Conciliación Contable → Regenerar.\n');
}

/** Mismo criterio de numeración que RecibosService._generarNumeroTx. */
async function generarNumero(tx: Prisma.TransactionClient, empresaId: string, sucursalId: string): Promise<string> {
  const filas = await tx.$queryRaw<Array<{ id: string; numero_actual: number; punto_expedicion_id: string }>>`
    SELECT nd.id, nd.numero_actual, nd.punto_expedicion_id
      FROM numeraciones_documento nd
      INNER JOIN tipo_documento td ON td.id = nd.tipo_documento_id
      INNER JOIN empresas_puntos_expedicion epe ON epe.id = nd.punto_expedicion_id
     WHERE td.codigo = 100 AND nd.empresa_id = ${empresaId}::uuid
       AND epe.sucursal_id = ${sucursalId}::uuid AND nd.active = true
     ORDER BY nd.created_at ASC LIMIT 1 FOR UPDATE`;
  if (!filas.length) throw new Error('No hay numeración activa de Recibo de pago (código 100) para la sucursal');

  const punto = await tx.empresas_puntos_expedicion.findUnique({
    where: { id: filas[0].punto_expedicion_id },
    include: { empresas_sucursales: { select: { punto_establecimiento: true } } },
  });
  const dest = punto?.empresas_sucursales?.punto_establecimiento || '001';
  const dpunexp = punto?.punto_expedicion || '001';

  let candidato = filas[0].numero_actual;
  for (let i = 0; i < 10000; i++) {
    const numero = `${dest}-${dpunexp}-${String(candidato).padStart(7, '0')}`;
    const existe = await tx.recibos_cobro.findFirst({
      where: { empresa_id: empresaId, numero_recibo: numero },
      select: { id: true },
    });
    if (!existe) {
      await tx.numeraciones_documento.update({
        where: { id: filas[0].id },
        data: { numero_actual: candidato + 1 },
      });
      return numero;
    }
    candidato += 1;
  }
  throw new Error('No se encontró un número de recibo libre');
}

main()
  .then(() => prisma.$disconnect())
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
