/**
 * One-shot: vincula a cada funcionario con su ficha de cliente.
 *
 * Por qué hace falta: lo que el empleado compra en la empresa se le factura
 * como a cualquier cliente y se le descuenta del sueldo. Sin el vínculo, la
 * liquidación no sabe qué facturas proponerle y la deuda queda abierta para
 * siempre aunque ya se le haya descontado.
 *
 * El matcheo NO es trivial: en la base conviven dos formatos y dos campos.
 *   - rrhh_empleados.cedula_identidad viene CON puntos ("5.616.813")
 *   - personas la guarda SIN puntos, y según sea contribuyente o no la deja
 *     en `ruc` o en `nro_documento`.
 * Buscando literal, de 15 empleados de DOBA matcheaba 1. Normalizando a solo
 * dígitos y mirando los dos campos, matchean 9.
 *
 * Por defecto solo VINCULA fichas existentes. Crear fichas nuevas para los que
 * no son clientes todavía requiere --crear, porque en una empresa grande eso
 * llena el padrón de clientes que nadie pidió.
 *
 * Idempotente: saltea a los que ya tienen cliente_id.
 *
 * Uso:
 *   pnpm exec ts-node scripts/backfill-empleado-cliente.ts [--empresa=<id>] [--crear] [--apply]
 *
 * Sin --apply → dry-run (default seguro).
 */
import 'dotenv/config';
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

/** Cédulas obviamente de prueba: no se les crea ficha de cliente. */
const CEDULAS_DE_PRUEBA = new Set(['123456', '654321', '1234567', '0', '11111111']);

function parseArgs(argv: string[]) {
  const empresaArg = argv.find((a) => a.startsWith('--empresa='));
  return {
    apply: argv.includes('--apply'),
    crear: argv.includes('--crear'),
    empresa: empresaArg ? empresaArg.split('=')[1] : undefined,
  };
}

const soloDigitos = (v: string | null | undefined) => (v ?? '').replace(/\D/g, '');

async function main() {
  const { apply, crear, empresa } = parseArgs(process.argv.slice(2));

  console.log(`\nBackfill empleado → cliente  [${apply ? 'APLICANDO' : 'DRY-RUN'}]`);
  console.log(`Crear fichas nuevas: ${crear ? 'SÍ' : 'no (solo vincula existentes)'}\n`);

  const empleados = await prisma.rrhh_empleados.findMany({
    where: { ...(empresa ? { empresa_id: empresa } : {}), cliente_id: null },
    select: {
      id: true,
      empresa_id: true,
      numero_empleado: true,
      nombres: true,
      apellidos: true,
      cedula_identidad: true,
      ruc: true,
    },
    orderBy: [{ empresa_id: 'asc' }, { numero_empleado: 'asc' }],
  });

  if (!empleados.length) {
    console.log('No hay empleados sin cliente_id. Nada que hacer.');
    return;
  }

  let vinculados = 0;
  let creados = 0;
  let salteados = 0;

  for (const e of empleados) {
    const nombre = `${e.nombres} ${e.apellidos}`.replace(/\s+/g, ' ').trim();
    const ci = soloDigitos(e.cedula_identidad);
    const etiqueta = `  #${e.numero_empleado.padEnd(4)} ${nombre.padEnd(36)}`;

    if (!ci) {
      console.log(`${etiqueta} SALTEADO — sin cédula utilizable`);
      salteados++;
      continue;
    }

    // Busca la ficha comparando normalizado de los dos lados, en ruc y en
    // nro_documento, porque en personas también hay documentos con puntos.
    const encontrado = await prisma.$queryRaw<{ id: string; razon_social: string }[]>`
      SELECT c.id, p.razon_social
      FROM   clientes c
      JOIN   personas p ON p.id = c.persona_id
      WHERE  p.empresa_id = ${e.empresa_id}::uuid
        AND  c.deleted = false
        AND  COALESCE(p.deleted, false) = false
        AND  (
               regexp_replace(COALESCE(p.ruc, ''), '\\D', '', 'g') = ${ci}
            OR regexp_replace(COALESCE(p.nro_documento, ''), '\\D', '', 'g') = ${ci}
             )
      ORDER  BY c.created_at ASC
      LIMIT  1
    `;

    if (encontrado.length) {
      console.log(`${etiqueta} vincula → ${encontrado[0].razon_social}`);
      if (apply) {
        await prisma.rrhh_empleados.update({
          where: { id: e.id },
          data: { cliente_id: encontrado[0].id },
        });
      }
      vinculados++;
      continue;
    }

    if (!crear) {
      console.log(`${etiqueta} sin ficha — se omite (usar --crear para crearla)`);
      salteados++;
      continue;
    }

    if (CEDULAS_DE_PRUEBA.has(ci)) {
      console.log(`${etiqueta} SALTEADO — cédula de prueba (${ci})`);
      salteados++;
      continue;
    }

    console.log(`${etiqueta} CREA ficha nueva (CI ${ci})`);
    if (apply) {
      // B2C: el funcionario compra como consumidor final.
      const tipoOperacion = await prisma.tipo_operacion.findFirst({
        where: { codigo: 2 },
        select: { id: true },
      });
      if (!tipoOperacion) {
        console.log('    ERROR: no existe el tipo de operación B2C (código 2). Abortando.');
        process.exitCode = 1;
        return;
      }

      const persona = await prisma.personas.create({
        data: {
          empresa_id: e.empresa_id,
          razon_social: nombre,
          nro_documento: ci,
          ruc: soloDigitos(e.ruc) || null,
        },
        select: { id: true },
      });
      const cliente = await prisma.clientes.create({
        data: { persona_id: persona.id, tipo_operacion_id: tipoOperacion.id },
        select: { id: true },
      });
      await prisma.rrhh_empleados.update({
        where: { id: e.id },
        data: { cliente_id: cliente.id },
      });
    }
    creados++;
  }

  console.log(
    `\nResumen: ${vinculados} vinculados · ${creados} fichas nuevas · ${salteados} salteados`,
  );
  if (!apply) console.log('Fue un dry-run. Volvé a correrlo con --apply para aplicar.\n');
}

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