/**
 * One-shot: fusiona una sucursal en otra de la misma empresa (la absorbida
 * queda desactivada y todo lo operativo pasa a la que absorbe).
 *
 * Caso que lo motivó: Comercial Kety, sucursal "Migracion" (est. 111) dentro de
 * "Matrix" (est. 001).
 *
 * Qué hace, en una sola transacción:
 *
 *   1. PUNTOS DE EXPEDICIÓN — pasan a la que absorbe con el número de punto
 *      nuevo (--punto). Sin el cambio de número, el punto 001 de la absorbida
 *      facturaría como 001-001 y chocaría con la serie de la matriz. Sus
 *      numeraciones (factura, recibo, solicitud, ...) vuelven a 1 con el mismo
 *      timbrado: el prefijo es nuevo, así que no chocan con nada.
 *   2. ASIGNACIONES usuario/caja — pasan a la que absorbe; las que quedarían
 *      repetidas se borran.
 *   3. TODO LO DEMÁS con `sucursal_id` (cajas, depósitos con su stock,
 *      solicitudes de crédito, recibos, sesiones de caja, compras, ...) pasa a
 *      la que absorbe. Los documentos conservan su número: no se renumera nada
 *      emitido.
 *   4. FACTURAS / NC viejas no tienen sucursal sino establecimiento (`dest`) y
 *      no se tocan. La que absorbe anota el establecimiento absorbido en
 *      `config.establecimientos_absorbidos` para que sus usuarios los sigan
 *      viendo (ver `establecimientosDeSucursales` en src/utils/alcance-sucursal.ts).
 *   5. La absorbida queda inactiva (no se borra: el historial la referencia).
 *
 * No corre si la absorbida tiene una sesión de caja abierta: hay que cerrarla y
 * arquearla antes del corte.
 *
 * Uso:
 *   pnpm fusionar:sucursal -- --empresa=<id> --absorbida=<sucursal_id> --destino=<sucursal_id> --punto=111 [--apply]
 *
 * Sin --apply → dry-run (default seguro).
 */
import 'dotenv/config';
import { Prisma, PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

/** Tablas que se resuelven aparte y no entran en el traspaso genérico de `sucursal_id`. */
const TRATADAS_APARTE = new Set(['empresas_puntos_expedicion', 'asignacion_sucursal_caja_usuario']);

function parseArgs(argv: string[]) {
  const valor = (nombre: string) => argv.find((a) => a.startsWith(`--${nombre}=`))?.split('=')[1];
  const args = {
    apply: argv.includes('--apply'),
    empresa: valor('empresa'),
    absorbida: valor('absorbida'),
    destino: valor('destino'),
    punto: valor('punto'),
  };
  if (!args.empresa || !args.absorbida || !args.destino || !args.punto) {
    throw new Error('Faltan argumentos: --empresa, --absorbida, --destino y --punto son obligatorios');
  }
  if (!/^\d{3}$/.test(args.punto)) throw new Error('--punto tiene que ser de 3 dígitos (ej. 111)');
  if (args.absorbida === args.destino) throw new Error('--absorbida y --destino son la misma sucursal');
  return args as Required<typeof args>;
}

async function columnasSucursal(tx: Prisma.TransactionClient) {
  const filas = await tx.$queryRaw<Array<{ tabla: string; columna: string }>>`
    SELECT table_name AS tabla, column_name AS columna
    FROM information_schema.columns
    WHERE table_schema = 'public' AND data_type = 'uuid' AND column_name LIKE '%sucursal%'
      AND table_name <> 'empresas_sucursales'
    ORDER BY table_name, column_name`;
  return filas.filter((f) => !TRATADAS_APARTE.has(f.tabla));
}

async function main() {
  const args = parseArgs(process.argv.slice(2));

  const [absorbida, destino] = await Promise.all(
    [args.absorbida, args.destino].map((id) =>
      prisma.empresas_sucursales.findFirst({
        where: { id, empresa_id: args.empresa },
        select: { id: true, descripcion: true, punto_establecimiento: true, active: true, es_default: true, config: true },
      }),
    ),
  );
  if (!absorbida) throw new Error('La sucursal absorbida no existe en esa empresa');
  if (!destino) throw new Error('La sucursal destino no existe en esa empresa');

  console.log(`Fusión: "${absorbida.descripcion}" (est. ${absorbida.punto_establecimiento}) → "${destino.descripcion}" (est. ${destino.punto_establecimiento})`);
  console.log(args.apply ? 'Modo: APPLY\n' : 'Modo: DRY-RUN (sin --apply no se escribe nada)\n');

  const sesionesAbiertas = await prisma.sesiones_caja.findMany({
    where: { sucursal_id: absorbida.id, fecha_cierre: null },
    select: { fecha_apertura: true, cajas: { select: { descripcion: true } } },
  });
  if (sesionesAbiertas.length) {
    const detalle = sesionesAbiertas.map((s) => `${s.cajas?.descripcion ?? '?'} (abierta ${s.fecha_apertura?.toISOString()})`).join(', ');
    const msg = `La absorbida tiene sesiones de caja abiertas: ${detalle}. Cerralas y arqueá antes del corte.`;
    if (args.apply) throw new Error(msg);
    console.log(`⚠  ${msg}\n`);
  }

  const puntos = await prisma.empresas_puntos_expedicion.findMany({
    where: { sucursal_id: absorbida.id },
    select: { id: true, punto_expedicion: true, numeraciones_documento: { select: { id: true, numero_actual: true, tipo_documento: { select: { descripcion: true } } } } },
  });
  if (puntos.length > 1) {
    throw new Error(`La absorbida tiene ${puntos.length} puntos de expedición y --punto alcanza para uno solo; resolvelo a mano o extendé el script`);
  }

  const estNuevo = destino.punto_establecimiento ?? '001';
  const prefijo = `${estNuevo}-${args.punto}-`;
  const [puntoOcupado, facturasPrefijo, recibosPrefijo, solicitudesPrefijo] = await Promise.all([
    prisma.empresas_puntos_expedicion.findFirst({ where: { sucursal_id: destino.id, punto_expedicion: args.punto }, select: { id: true } }),
    prisma.factura_cab.count({ where: { empresa_id: args.empresa, dest: estNuevo, dpunexp: args.punto } }),
    prisma.recibos_cobro.count({ where: { empresa_id: args.empresa, numero_recibo: { startsWith: prefijo } } }),
    prisma.solicitud_credito.count({ where: { empresa_id: args.empresa, numero_solicitud: { startsWith: prefijo } } }),
  ]);
  if (puntoOcupado) throw new Error(`"${destino.descripcion}" ya tiene un punto ${args.punto}`);
  if (facturasPrefijo + recibosPrefijo + solicitudesPrefijo > 0) {
    throw new Error(`Ya hay documentos con el prefijo ${prefijo} (facturas ${facturasPrefijo}, recibos ${recibosPrefijo}, solicitudes ${solicitudesPrefijo}); elegí otro --punto`);
  }

  await prisma.$transaction(
    async (tx) => {
      // 1. Puntos de expedición
      for (const p of puntos) {
        console.log(`Punto ${absorbida.punto_establecimiento}-${p.punto_expedicion} → ${prefijo.slice(0, -1)}; numeraciones a 1:`);
        for (const n of p.numeraciones_documento) console.log(`   ${n.tipo_documento.descripcion}: iba por ${n.numero_actual}`);
        await tx.empresas_puntos_expedicion.update({
          where: { id: p.id },
          // Una sola sucursal admite un punto por defecto (uq_pe_default_por_sucursal) y la que absorbe ya tiene el suyo.
          data: { sucursal_id: destino.id, punto_expedicion: args.punto, num_inicial: '0000001', es_default: false, updated_at: new Date() },
        });
        await tx.numeraciones_documento.updateMany({
          where: { punto_expedicion_id: p.id },
          data: { numero_actual: 1, numero_inicial: 1, updated_at: new Date() },
        });
      }

      // 2. Asignaciones usuario/caja, sin duplicar
      const asignaciones = await tx.asignacion_sucursal_caja_usuario.findMany({
        where: { sucursal_id: absorbida.id },
        select: { id: true, usuario_id: true, caja_id: true },
      });
      let movidas = 0;
      let repetidas = 0;
      for (const a of asignaciones) {
        const yaEsta = await tx.asignacion_sucursal_caja_usuario.findFirst({
          where: { sucursal_id: destino.id, usuario_id: a.usuario_id, caja_id: a.caja_id },
          select: { id: true },
        });
        if (yaEsta) {
          await tx.asignacion_sucursal_caja_usuario.delete({ where: { id: a.id } });
          repetidas++;
        } else {
          await tx.asignacion_sucursal_caja_usuario.update({ where: { id: a.id }, data: { sucursal_id: destino.id, updated_at: new Date() } });
          movidas++;
        }
      }
      console.log(`\nAsignaciones usuario/caja: ${movidas} pasan, ${repetidas} borradas por repetidas`);

      // 3. Todo lo demás con sucursal_id (nombres de tabla/columna salen de information_schema)
      console.log('\nTraspaso de sucursal_id:');
      for (const { tabla, columna } of await columnasSucursal(tx)) {
        const n = await tx.$executeRawUnsafe(
          `UPDATE "${tabla}" SET "${columna}" = $1::uuid WHERE "${columna}" = $2::uuid`,
          destino.id,
          absorbida.id,
        );
        if (n > 0) console.log(`   ${tabla}.${columna}: ${n}`);
      }

      // 4. Establecimiento absorbido, para seguir viendo sus facturas y NC
      const config = (destino.config as Record<string, unknown> | null) ?? {};
      const previos = Array.isArray(config.establecimientos_absorbidos) ? (config.establecimientos_absorbidos as string[]) : [];
      const absorbidos = [...new Set([...previos, absorbida.punto_establecimiento].filter((e): e is string => !!e && e !== estNuevo))];
      await tx.empresas_sucursales.update({
        where: { id: destino.id },
        data: { config: { ...config, establecimientos_absorbidos: absorbidos }, ...(absorbida.es_default ? { es_default: true } : {}), updated_at: new Date() },
      });
      console.log(`\n"${destino.descripcion}".config.establecimientos_absorbidos = ${JSON.stringify(absorbidos)}`);

      // 5. La absorbida queda inactiva
      await tx.empresas_sucursales.update({
        where: { id: absorbida.id },
        data: { active: false, es_default: false, updated_at: new Date() },
      });
      console.log(`"${absorbida.descripcion}" queda inactiva`);

      if (!args.apply) throw new DryRun();
    },
    { timeout: 120_000 },
  );
  console.log('\nListo.');
}

class DryRun extends Error {}

main()
  .catch((e) => {
    if (e instanceof DryRun) {
      console.log('\nDry-run: transacción revertida, no se escribió nada. Corré con --apply para aplicar.');
      return;
    }
    console.error(e);
    process.exitCode = 1;
  })
  .finally(() => prisma.$disconnect());
