/**
 * Parte pura de la importación de socios: lectura de columnas, validación del
 * documento y normalización del contacto. Sin Nest ni Prisma, para probarla
 * contra planillas reales sin base.
 *
 * Reusa del CRM lo que ya resolvió el mismo problema: `aTexto` (celdas de Excel
 * a texto), `normalizarEncabezado`, `partirRuc` y el DV por módulo 11.
 */
import { dvValido } from 'src/crm/cierre/ruc.util';
import { aTexto, normalizarEncabezado, partirRuc } from 'src/crm/leads/importacion/leads-import.util';

/**
 * Columnas que entiende el importador. `nombre` y `documento` son obligatorias. `plan`, `plan_desde` y `plan_vence`
 * cargan el plan que el socio ya pagó en el sistema anterior (sin factura, §15.12): el plan solo entra con su
 * vencimiento.
 */
export const COLUMNAS_SOCIO = ['nombre', 'documento', 'email', 'celular', 'observaciones', 'plan', 'plan_desde', 'plan_vence'] as const;
export type ColumnaSocio = (typeof COLUMNAS_SOCIO)[number];

/** Encabezados que se aceptan para cada columna, ya normalizados (sin acentos ni signos). */
const ALIAS: Record<ColumnaSocio, string[]> = {
  nombre: ['nombre', 'nombre y apellido', 'nombre completo', 'cliente', 'socio', 'razon social', 'nombres'],
  documento: ['documento', 'ci', 'c i', 'cedula', 'ruc', 'ruc ci', 'ci ruc', 'ruc o ci', 'nro documento', 'nro de documento'],
  email: ['email', 'e mail', 'mail', 'correo', 'correo electronico'],
  celular: ['celular', 'telefono', 'tel', 'cel', 'phone', 'whatsapp', 'movil', 'telefono celular'],
  observaciones: ['observaciones', 'observacion', 'obs', 'notas', 'nota', 'comentario', 'comentarios'],
  plan: ['plan', 'plan actual', 'tipo de plan', 'membresia', 'plan del socio'],
  plan_desde: ['desde', 'inicio', 'fecha de inicio', 'fecha inicio', 'plan desde', 'inicio del plan'],
  plan_vence: ['vence', 'vencimiento', 'fecha de vencimiento', 'fecha vencimiento', 'vence el', 'hasta', 'plan vence', 'fin del plan', 'fecha fin', 'fecha de fin'],
};

/** Qué columna de la planilla corresponde a cada campo. Lo que no se reconoce queda afuera. */
export function mapearColumnas(encabezados: string[]): Partial<Record<ColumnaSocio, string>> {
  const porNormalizado = new Map<string, string>();
  for (const h of encabezados) {
    const n = normalizarEncabezado(h);
    if (n && !porNormalizado.has(n)) porNormalizado.set(n, h);
  }
  const mapeo: Partial<Record<ColumnaSocio, string>> = {};
  const usados = new Set<string>();
  for (const campo of COLUMNAS_SOCIO) {
    for (const alias of ALIAS[campo]) {
      const original = porNormalizado.get(alias);
      if (original && !usados.has(original)) {
        mapeo[campo] = original;
        usados.add(original);
        break;
      }
    }
  }
  return mapeo;
}

/**
 * Dónde empiezan los datos: la primera fila (de las 10 primeras) que tiene las
 * columnas de nombre y documento. Muchas planillas traen un título o filas en
 * blanco arriba del encabezado.
 */
export function filaDeEncabezado(filas: unknown[][]): number {
  const limite = Math.min(filas.length, 10);
  for (let i = 0; i < limite; i++) {
    const mapeo = mapearColumnas((filas[i] ?? []).map(aTexto));
    if (mapeo.nombre && mapeo.documento) return i;
  }
  return -1;
}

export interface FilaSocio {
  /** Número de fila en Excel (1 = primera fila de la hoja), que es lo que ve la persona. */
  fila: number;
  nombre: string;
  /** El documento tal como vino, para mostrarlo en el reporte. */
  documento: string;
  /** Con DV ("1234567-8") es RUC: la persona es contribuyente. Sin DV es cédula. */
  ruc?: string;
  dv?: string;
  nro_documento?: string;
  email?: string;
  celular?: string;
  observaciones?: string;
  /** Nombre del plan ya pagado, tal como vino (se busca entre los planes activos al clasificar). */
  plan?: string;
  /** 'YYYY-MM-DD'. Si no viene, el plan cuenta desde el día de la importación. */
  plan_desde?: string;
  /** 'YYYY-MM-DD'. Obligatorio para cargar el plan. */
  plan_vence?: string;
  /** Datos que se descartaron sin frenar la fila (p. ej. un email mal escrito). */
  avisos: string[];
  /** Si está, la fila no se puede importar. */
  error?: string;
}

const EMAIL = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
/** Lo que la gente escribe en una celda para decir «no tiene». */
const VACIOS = new Set(['-', '--', 'no', 'no tiene', 'n/a', 'na', 's/d', 'sd', '0']);

function limpio(valor: unknown): string {
  const t = aTexto(valor).replace(/\s+/g, ' ').trim();
  return VACIOS.has(t.toLowerCase()) ? '' : t;
}

/**
 * Celular en el formato local que usa el resto del ERP: un móvil paraguayo de 9
 * dígitos sin el 0 ("981123456") se completa a "0981123456". Lo demás (fijos,
 * extranjeros) se deja como vino, sin inventar prefijos.
 */
export function normalizarCelular(crudo: string): string | undefined {
  const digitos = crudo.replace(/\D/g, '');
  if (!digitos) return undefined;
  if (/^9\d{8}$/.test(digitos)) return `0${digitos}`;
  if (/^5959\d{8}$/.test(digitos)) return `0${digitos.slice(3)}`;
  return digitos.slice(0, 20);
}

/** Lee una fila de la planilla y la valida. No consulta la base. */
export function construirFilaSocio(celdas: unknown[], indices: Partial<Record<ColumnaSocio, number>>, fila: number): FilaSocio {
  const leer = (c: ColumnaSocio) => {
    const i = indices[c];
    return i === undefined ? '' : limpio(celdas[i]);
  };
  const nombre = leer('nombre').toUpperCase();
  const documento = leer('documento');
  const r: FilaSocio = { fila, nombre, documento, avisos: [] };

  const email = leer('email').toLowerCase();
  if (email) {
    if (EMAIL.test(email) && email.length <= 80) r.email = email;
    else r.avisos.push(`El email «${email}» no es válido: se importa sin email`);
  }
  r.celular = normalizarCelular(leer('celular'));
  r.observaciones = leer('observaciones') || undefined;
  leerPlan(r, leer('plan'), leer('plan_desde'), leer('plan_vence'));

  if (nombre.length < 4) {
    r.error = nombre ? 'El nombre tiene que tener al menos 4 letras' : 'Falta el nombre';
    return r;
  }
  if (!documento) {
    r.error = 'Falta el documento (CI o RUC): el socio se identifica con él en recepción';
    return r;
  }
  const { ruc, dv } = partirRuc(documento.replace(/\./g, ''), '');
  if (!/^\d{3,8}$/.test(ruc)) {
    r.error = `El documento «${documento}» no es un número de CI o RUC válido`;
    return r;
  }
  if (documento.includes('-')) {
    if (!dvValido(ruc, dv)) {
      r.error = `El dígito verificador de «${documento}» no corresponde a ese RUC`;
      return r;
    }
    r.ruc = ruc;
    r.dv = dv;
  } else {
    r.nro_documento = ruc;
  }
  return r;
}

/** Una fila sin ninguna celda con contenido: Excel arrastra cientos al final. */
export function filaSinDatos(celdas: unknown[]): boolean {
  return celdas.every((c) => aTexto(c) === '');
}

/**
 * Fecha de una celda: 'YYYY-MM-DD' (lo que da Excel con `dateNF`) o día/mes/año como se escribe acá (30/11/2026,
 * 30-11-26, 30.11.2026). Devuelve 'YYYY-MM-DD' o null si no es una fecha real.
 */
export function leerFecha(texto: string): string | null {
  const t = texto.trim();
  let a: number, m: number, d: number;
  let x = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T].*)?$/.exec(t);
  if (x) {
    [a, m, d] = [Number(x[1]), Number(x[2]), Number(x[3])];
  } else {
    x = /^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2}|\d{4})$/.exec(t);
    if (!x) return null;
    [d, m, a] = [Number(x[1]), Number(x[2]), Number(x[3])];
    if (a < 100) a += 2000;
  }
  const f = new Date(Date.UTC(a, m - 1, d));
  if (f.getUTCFullYear() !== a || f.getUTCMonth() !== m - 1 || f.getUTCDate() !== d) return null;
  return f.toISOString().slice(0, 10);
}

/** El plan ya pagado de la fila. Si algo no cierra, la fila se importa igual, sin plan, con el aviso. */
function leerPlan(r: FilaSocio, plan: string, desde: string, vence: string) {
  if (!plan) {
    if (vence) r.avisos.push('Tiene vencimiento pero no dice el plan: se importa sin plan');
    return;
  }
  if (!vence) {
    r.avisos.push(`Falta el vencimiento del plan «${plan}»: se importa sin plan`);
    return;
  }
  const hasta = leerFecha(vence);
  if (!hasta) {
    r.avisos.push(`El vencimiento «${vence}» no es una fecha: se importa sin plan`);
    return;
  }
  if (desde) {
    const inicio = leerFecha(desde);
    if (inicio) r.plan_desde = inicio;
    else r.avisos.push(`El inicio «${desde}» no es una fecha: el plan cuenta desde hoy`);
  }
  r.plan = plan;
  r.plan_vence = hasta;
}
