/**
 * ╔══════════════════════════════════════════════════════════════════════════╗
 * ║  IMPORTACIÓN: Lista de Productos, Equipos y Repuestos → productos        ║
 * ║               + una lista de precios general por moneda                  ║
 * ╠══════════════════════════════════════════════════════════════════════════╣
 * ║  Uso:                                                                    ║
 * ║    npx ts-node scripts/data_script/cliente-naviera/import-productos-naviera.ts \
 * ║      --ruc=80079841 --dry                                                ║
 * ║    npx ts-node scripts/data_script/cliente-naviera/import-productos-naviera.ts \
 * ║      --ruc=80079841                                                      ║
 * ║                                                                          ║
 * ║  Flags:                                                                  ║
 * ║    --ruc=<8 dígitos>   RUC sin DV de la empresa destino   (obligatorio)  ║
 * ║    --file=<ruta>       Excel (default: "Lista compras de Productos,      ║
 * ║                        Equipos y Repuestos_2.xlsx"; el _1 es una         ║
 * ║                        versión anterior que el _2 ya contiene)           ║
 * ║    --prefijo=<XXX>     Prefijo del cod_producto (default PRD)            ║
 * ║    --sin-categoria     No crea ni asigna la categoría                    ║
 * ║    --dry               Simula: no escribe nada en la BD                  ║
 * ╠══════════════════════════════════════════════════════════════════════════╣
 * ║  Columnas: Proveedor · Detalle · Precio GS · P. USD · P. EURO · IVA.     ║
 * ║  Los precios son de VENTA y cada fila trae uno solo, en una moneda.      ║
 * ║  Defaults acordados con el cliente:                                      ║
 * ║                                                                          ║
 * ║    tipo               = "producto"                                       ║
 * ║    afectación         = Exento (todos, aunque la planilla diga IVA 10)   ║
 * ║    porcentaje_iva     = 0  ·  proporcion_iva = 0                         ║
 * ║    unidad de medida   = UNI (Unidad)                                     ║
 * ║    maneja_inventario  = true                                             ║
 * ║    marca              = el proveedor de la planilla                      ║
 * ║                                                                          ║
 * ║  PRECIO: no hay cotización, así que no se convierte nada. Cada precio    ║
 * ║  va a la lista general de su moneda (LP-PYG, LP-USD, LP-EUR). El         ║
 * ║  backend elige la lista por la moneda de la factura                      ║
 * ║  (lista-precios.service.ts, filtro `moneda`). `productos.precio` se      ║
 * ║  toma como Gs en todo el ERP: solo lleva el precio de los ítems en Gs;   ║
 * ║  los de USD/EUR quedan en 0 ahí.                                         ║
 * ║                                                                          ║
 * ║  Se saltean las filas de flete/envío (shipping, freight, carriage):      ║
 * ║  son cargos del proveedor, no artículos del catálogo.                    ║
 * ╚══════════════════════════════════════════════════════════════════════════╝
 */

import * as path from 'path';
import * as fs from 'fs';
import * as XLSX from 'xlsx';
import { PrismaClient } from '@prisma/client';

// ══════════════════════════════════════════════════════════════════════════
//  ARGUMENTOS
// ══════════════════════════════════════════════════════════════════════════
const args = process.argv.slice(2);
const flag = (nombre: string): string | undefined => {
  const hit = args.find((a) => a.startsWith(`--${nombre}=`));
  return hit ? hit.slice(nombre.length + 3) : undefined;
};

const RUC_EMPRESA = flag('ruc');
const DRY = args.includes('--dry');
const SIN_CATEGORIA = args.includes('--sin-categoria');
const PREFIJO = (flag('prefijo') ?? 'PRD').toUpperCase();
const ARCHIVOS = [
  path.resolve(flag('file') ?? path.join(__dirname, 'Lista compras de Productos, Equipos y Repuestos_2.xlsx')),
];

// ══════════════════════════════════════════════════════════════════════════
//  DEFAULTS DEL PRODUCTO
// ══════════════════════════════════════════════════════════════════════════
const CAT = {
  AFECTACION_EXENTO: 'd8e2cee1-7e25-44b2-8d06-b2bc8748b6a3', // cód 3
  UNIDAD_UNI: '4f6a1318-1a42-454d-874e-a72f6cda04df', // cód 77 — Unidad
};
const NOMBRE_CATEGORIA = 'EQUIPOS Y REPUESTOS';
const TIPO = 'producto';
const USUARIO = 'import-productos-naviera';

type Moneda = 'PYG' | 'USD' | 'EUR';
/** Columna del Excel (0-based) → moneda del precio. */
const COLUMNAS_PRECIO: [number, Moneda][] = [
  [2, 'PYG'],
  [3, 'USD'],
  [4, 'EUR'],
];
const LISTAS: Record<Moneda, { codigo: string; nombre: string }> = {
  PYG: { codigo: 'LP-PYG', nombre: 'Precios en guaraníes' },
  USD: { codigo: 'LP-USD', nombre: 'Precios en dólares' },
  EUR: { codigo: 'LP-EUR', nombre: 'Precios en euros' },
};

/** Filas que son cargos de envío del proveedor, no artículos. */
const ES_FLETE = /\b(shipping|freight|carriage)\b/i;

/** Errores de tipeo de la planilla. Se aplican a proveedor y descripción. */
const CORRECCIONES: [RegExp, string][] = [
  [/\\+"/g, '"'], // MONITOR 23.8\\\" → 23.8"
  [/TELEDYNE FLIER/gi, 'TELEDYNE FLIR'],
  [/Watherdock/gi, 'Weatherdock'],
  [/\bAxion2\b/g, 'Axiom2'],
  [/Monitorning/gi, 'Monitoring'],
];

// ══════════════════════════════════════════════════════════════════════════
//  LOG
// ══════════════════════════════════════════════════════════════════════════
const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
const LOG_FILE = path.join(__dirname, `import-productos-naviera-${stamp}.log`);
const logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
const say = (linea: string) => {
  console.log(linea);
  logStream.write(linea + '\n');
};

// ══════════════════════════════════════════════════════════════════════════
//  HELPERS
// ══════════════════════════════════════════════════════════════════════════

/** Clave de comparación: sin acentos, sin espacios dobles, sin punto final. */
const normalizar = (s: string) =>
  s
    .toLowerCase()
    .normalize('NFD')
    .replace(/[̀-ͯ]/g, '')
    .replace(/\s+/g, ' ')
    .replace(/\.+$/, '')
    .trim();

const corregir = (s: string) =>
  CORRECCIONES.reduce((acc, [re, rep]) => acc.replace(re, rep), s).replace(/\s+/g, ' ').trim();

const fmt = (n: number, m: Moneda) => `${m} ${n.toLocaleString('es-PY', { maximumFractionDigits: 4 })}`;

interface Producto {
  origen: string; // "archivo_2:fila 45"
  proveedor: string;
  descripcion: string;
  clave: string;
  moneda: Moneda | null; // null = la fila no trae precio
  precio: number;
}

// ══════════════════════════════════════════════════════════════════════════
//  LECTURA
// ══════════════════════════════════════════════════════════════════════════
function leerExcel(ruta: string): { productos: Producto[]; descartadas: string[] } {
  const wb = XLSX.readFile(ruta);
  const hoja = wb.Sheets[wb.SheetNames[0]];
  const filas: any[][] = XLSX.utils.sheet_to_json(hoja, { header: 1, defval: null, raw: true });
  const corto = path.basename(ruta).replace(/^.*_(\d+)\.xlsx$/i, 'archivo_$1');
  const productos: Producto[] = [];
  const descartadas: string[] = [];

  // El encabezado es la fila cuya columna B dice "Detalle de MERCADERIA…".
  const iEncabezado = filas.findIndex((f) => /detalle/i.test(String(f?.[1] ?? '')));
  if (iEncabezado < 0) throw new Error(`${ruta}: no encuentro la fila de encabezado ("Detalle…")`);

  filas.slice(iEncabezado + 1).forEach((fila, k) => {
    const origen = `${corto}:fila ${iEncabezado + 2 + k}`;
    const proveedor = corregir(String(fila?.[0] ?? ''));
    const descripcion = corregir(String(fila?.[1] ?? ''));
    const precios = COLUMNAS_PRECIO.map(([col, moneda]) => [moneda, Number(fila?.[col])] as const).filter(
      ([, v]) => Number.isFinite(v) && v !== 0,
    );
    if (!proveedor && !descripcion && !precios.length) return; // fila vacía

    if (descripcion.length < 3) {
      descartadas.push(`${origen}: sin descripción (proveedor "${proveedor}")`);
      return;
    }
    if (ES_FLETE.test(descripcion)) {
      descartadas.push(`${origen}: "${descripcion}" es flete/envío, no un artículo`);
      return;
    }
    if (precios.length > 1) {
      descartadas.push(`${origen}: "${descripcion}" trae precio en más de una moneda`);
      return;
    }
    const [moneda, precio] = precios[0] ?? [null, 0];
    productos.push({ origen, proveedor, descripcion, clave: normalizar(descripcion), moneda, precio });
  });

  return { productos, descartadas };
}

// ══════════════════════════════════════════════════════════════════════════
//  MAIN
// ══════════════════════════════════════════════════════════════════════════
const prisma = new PrismaClient();

async function main() {
  if (!RUC_EMPRESA) throw new Error('Falta --ruc=<8 dígitos>. Ej: --ruc=80079841');
  for (const a of ARCHIVOS) if (!fs.existsSync(a)) throw new Error(`No existe el archivo: ${a}`);

  say('═'.repeat(78));
  say('  IMPORTACIÓN DE PRODUCTOS, EQUIPOS Y REPUESTOS');
  say('═'.repeat(78));
  ARCHIVOS.forEach((a) => say(`  Archivo   : ${a}`));
  say(`  RUC       : ${RUC_EMPRESA}`);
  say(`  IVA       : Exento (0% · proporción 0)`);
  say(`  Categoría : ${SIN_CATEGORIA ? '(ninguna)' : NOMBRE_CATEGORIA}`);
  say(`  Modo      : ${DRY ? 'DRY-RUN (no escribe)' : 'REAL'}`);
  say(`  Log       : ${LOG_FILE}`);
  say('═'.repeat(78));

  const empresa = await prisma.empresas.findUnique({
    where: { ruc: RUC_EMPRESA },
    select: { id: true, ruc: true, razon_social: true },
  });
  if (!empresa) throw new Error(`No existe empresa con RUC ${RUC_EMPRESA}`);
  say(`\n▸ Empresa: ${empresa.razon_social} (${empresa.ruc})  id=${empresa.id}\n`);

  // ── 1. Leer y unir los archivos ───────────────────────────────────────
  const leidos: Producto[] = [];
  const descartadas: string[] = [];
  for (const a of ARCHIVOS) {
    const r = leerExcel(a);
    leidos.push(...r.productos);
    descartadas.push(...r.descartadas);
  }
  say(`▸ Excel: ${leidos.length} filas válidas`);
  if (descartadas.length) {
    say(`  ${descartadas.length} filas descartadas:`);
    descartadas.forEach((d) => say(`    ✗ ${d}`));
  }

  // ── 2. Duplicados dentro del Excel ────────────────────────────────────
  // Misma descripción, proveedor, moneda y precio = la misma fila: se
  // descarta en silencio. Si cambia el precio o el proveedor, se avisa.
  const porClave = new Map<string, Producto>();
  const conflictos: string[] = [];
  let repetidas = 0;
  for (const p of leidos) {
    const previa = porClave.get(p.clave);
    if (!previa) {
      porClave.set(p.clave, p);
      continue;
    }
    repetidas++;
    if (previa.proveedor !== p.proveedor || previa.moneda !== p.moneda || previa.precio !== p.precio) {
      conflictos.push(
        `${p.origen} "${p.descripcion}" (${p.proveedor}, ${p.moneda ? fmt(p.precio, p.moneda) : 'sin precio'}) ` +
          `≠ ${previa.origen} (${previa.proveedor}, ${previa.moneda ? fmt(previa.precio, previa.moneda) : 'sin precio'}) — queda la primera`,
      );
    }
  }
  say(`\n  Filas repetidas         : ${repetidas}`);
  if (conflictos.length) {
    say(`  ${conflictos.length} repetidas con datos distintos:`);
    conflictos.forEach((c) => say(`    ~ ${c}`));
  }

  const unicos = [...porClave.values()];
  const sinPrecio = unicos.filter((p) => !p.moneda);
  if (sinPrecio.length) {
    say(`\n  ${sinPrecio.length} sin precio (se crean, pero no entran a ninguna lista):`);
    sinPrecio.forEach((p) => say(`    ! ${p.origen} ${p.descripcion}`));
  }

  // ── 3. Contrastar con lo que la empresa ya tiene ──────────────────────
  const existentes = await prisma.productos.findMany({
    where: { empresa_id: empresa.id, deleted: false },
    select: { id: true, descripcion: true, cod_producto: true },
  });
  const idPorClave = new Map(existentes.map((p) => [normalizar(p.descripcion), p.id]));
  const codigosUsados = new Set(existentes.map((p) => p.cod_producto).filter(Boolean) as string[]);

  const aCrear = unicos.filter((p) => !idPorClave.has(p.clave));
  const yaEstaban = unicos.filter((p) => idPorClave.has(p.clave));
  say(`\n  Únicos en el Excel       : ${unicos.length}`);
  say(`  Ya existían en la empresa: ${yaEstaban.length}  (no se tocan; solo se completa su precio de lista si falta)`);
  say(`  A crear                  : ${aCrear.length}`);
  yaEstaban.forEach((p) => say(`    ~ ya existe: ${p.descripcion}`));

  // ── 4. Categoría ──────────────────────────────────────────────────────
  let categoriaId: string | null = null;
  if (!SIN_CATEGORIA) {
    const existente = await prisma.categorias.findFirst({
      where: { empresa_id: empresa.id, descripcion: NOMBRE_CATEGORIA, deleted_at: false },
      select: { id: true },
    });
    if (existente) {
      categoriaId = existente.id;
      say(`\n▸ Categoría "${NOMBRE_CATEGORIA}" ya existía  id=${categoriaId}`);
    } else if (DRY) {
      say(`\n▸ Categoría "${NOMBRE_CATEGORIA}" se crearía`);
    } else {
      const creada = await prisma.categorias.create({
        data: { empresa_id: empresa.id, descripcion: NOMBRE_CATEGORIA, activo: true, deleted_at: false },
        select: { id: true },
      });
      categoriaId = creada.id;
      say(`\n▸ Categoría "${NOMBRE_CATEGORIA}" creada  id=${categoriaId}`);
    }
  }

  // ── 5. Marcas (una por proveedor) ─────────────────────────────────────
  const marcasEmpresa = await prisma.marcas.findMany({
    where: { empresa_id: empresa.id },
    select: { id: true, descripcion: true },
  });
  const marcaPorClave = new Map(marcasEmpresa.map((m) => [normalizar(m.descripcion), m.id]));
  const proveedores = [...new Set(aCrear.map((p) => p.proveedor).filter(Boolean))].sort();
  say(`\n▸ Marcas (${proveedores.length} proveedores):`);
  for (const nombre of proveedores) {
    const clave = normalizar(nombre);
    if (marcaPorClave.has(clave)) {
      say(`  = ${nombre}  (ya existía)`);
      continue;
    }
    if (DRY) {
      marcaPorClave.set(clave, '(dry)');
      say(`  + ${nombre}  (se crearía)`);
      continue;
    }
    const creada = await prisma.marcas.create({
      data: { empresa_id: empresa.id, descripcion: nombre.slice(0, 100), active: true, usuario: USUARIO },
      select: { id: true },
    });
    marcaPorClave.set(clave, creada.id);
    say(`  + ${nombre}`);
  }

  // ── 6. Listas de precios (una general por moneda usada) ───────────────
  const monedasUsadas = [...new Set(unicos.map((p) => p.moneda).filter(Boolean) as Moneda[])];
  const listaPorMoneda = new Map<Moneda, string>();
  say(`\n▸ Listas de precios:`);
  for (const moneda of monedasUsadas) {
    const { codigo, nombre } = LISTAS[moneda];
    const existente = await prisma.lista_precios.findFirst({
      where: { empresa_id: empresa.id, codigo },
      select: { id: true, moneda: true },
    });
    if (existente) {
      if (existente.moneda !== moneda) {
        throw new Error(`La lista ${codigo} ya existe pero en ${existente.moneda}, no en ${moneda}. Revisarla a mano.`);
      }
      listaPorMoneda.set(moneda, existente.id);
      say(`  = ${codigo}  ${nombre}  (ya existía)`);
    } else if (DRY) {
      listaPorMoneda.set(moneda, '(dry)');
      say(`  + ${codigo}  ${nombre}  [${moneda}, general]  (se crearía)`);
    } else {
      const creada = await prisma.lista_precios.create({
        data: {
          empresa_id: empresa.id,
          codigo,
          nombre,
          descripcion: 'Importada de la planilla de productos, equipos y repuestos',
          tipo_aplicacion: 'general',
          moneda,
          prioridad: 1,
          usuario_creacion: USUARIO,
        },
        select: { id: true },
      });
      listaPorMoneda.set(moneda, creada.id);
      say(`  + ${codigo}  ${nombre}  [${moneda}, general]`);
    }
  }

  // ── 7. Crear productos + precio en su lista ───────────────────────────
  say('\n▸ Creando productos:');
  let creados = 0;
  let preciosCargados = 0;
  let secuencia = 0;
  const errores: string[] = [];
  const porMoneda: Record<string, number> = {};

  /** Siguiente código libre con el prefijo, saltando los ya usados. */
  const siguienteCodigo = (): string => {
    let codigo: string;
    do {
      secuencia++;
      codigo = `${PREFIJO}${String(secuencia).padStart(4, '0')}`;
    } while (codigosUsados.has(codigo));
    codigosUsados.add(codigo);
    return codigo;
  };

  /** Agrega el precio a la lista de su moneda si todavía no está. No pisa uno cargado. */
  const cargarPrecio = async (productoId: string, p: Producto): Promise<string> => {
    if (!p.moneda) return '';
    const listaId = listaPorMoneda.get(p.moneda)!;
    if (!DRY) {
      const previo = await prisma.lista_precios_productos.findFirst({
        where: { lista_precios_id: listaId, producto_id: productoId },
        select: { precio_base: true },
      });
      if (previo) {
        const actual = Number(previo.precio_base);
        return actual === p.precio ? '' : `  (en ${LISTAS[p.moneda].codigo} ya tiene ${fmt(actual, p.moneda)}; no se pisa)`;
      }
      await prisma.lista_precios_productos.create({
        data: { lista_precios_id: listaId, producto_id: productoId, precio_base: p.precio, origen_precio: 'manual' },
      });
    }
    preciosCargados++;
    porMoneda[p.moneda] = (porMoneda[p.moneda] ?? 0) + 1;
    return '';
  };

  for (const p of aCrear) {
    const codigo = siguienteCodigo();
    try {
      let productoId = '(dry)';
      if (!DRY) {
        const creado = await prisma.productos.create({
          data: {
            empresa_id: empresa.id,
            descripcion: p.descripcion,
            cod_producto: codigo,
            tipo: TIPO,
            afectacion_id: CAT.AFECTACION_EXENTO,
            porcentaje_iva: 0,
            proporcion_iva: 0,
            unidad_medida_id: CAT.UNIDAD_UNI,
            categoria_id: categoriaId,
            marca_id: p.proveedor ? marcaPorClave.get(normalizar(p.proveedor)) : null,
            maneja_inventario: true,
            maneja_lote: false,
            // productos.precio se lee como Gs en todo el ERP: ver la nota de cabecera.
            precio: p.moneda === 'PYG' ? p.precio : 0,
            usuario: USUARIO,
            active: true,
            deleted: false,
          },
          select: { id: true },
        });
        productoId = creado.id;
      }
      creados++;
      const nota = await cargarPrecio(productoId, p);
      const precio = p.moneda ? fmt(p.precio, p.moneda) : 'sin precio';
      say(`  + ${codigo}  [${p.proveedor}]  ${p.descripcion}  → ${precio}${nota}`);
    } catch (e: any) {
      errores.push(`${p.origen} "${p.descripcion}": ${e.message}`);
      say(`  ✗ ${codigo}  ${p.descripcion}  → ${e.message}`);
    }
  }

  for (const p of yaEstaban) {
    try {
      const nota = await cargarPrecio(idPorClave.get(p.clave)!, p);
      if (nota) say(`  ~ ${p.descripcion}${nota}`);
    } catch (e: any) {
      errores.push(`${p.origen} "${p.descripcion}": ${e.message}`);
    }
  }

  // ── 8. Resumen ────────────────────────────────────────────────────────
  say('\n' + '═'.repeat(78));
  say('  RESUMEN');
  say('═'.repeat(78));
  say(`  Filas válidas en los Excel : ${leidos.length}`);
  say(`  Descartadas                : ${descartadas.length}`);
  say(`  Repetidas                  : ${repetidas}  (${conflictos.length} con datos distintos)`);
  say(`  Ya existían en la empresa  : ${yaEstaban.length}`);
  say(`  Productos creados          : ${creados}`);
  say(`  Precios cargados en listas : ${preciosCargados}  ${JSON.stringify(porMoneda)}`);
  say(`  Errores                    : ${errores.length}`);
  errores.forEach((e) => say(`    ✗ ${e}`));

  say('\n  ⚠ Para facturar en USD/EUR la empresa tiene que tener esas monedas');
  say('    habilitadas (Configuración → Monedas) y la factura en esa moneda.');

  if (DRY) say('\n  (DRY-RUN: no se escribió nada en la base de datos)');
  say('');
}

main()
  .catch((e) => {
    say(`\n✖ ${e.message}\n`);
    process.exitCode = 1;
  })
  .finally(async () => {
    logStream.end();
    await prisma.$disconnect();
  });
