import { BadRequestException, Injectable, Logger } from '@nestjs/common';
import { gym_membresia_origen, gym_socio_origen, Prisma } from '@prisma/client';
import * as XLSX from 'xlsx';
import { AuditService } from 'src/audit/audit.service';
import { ClientesService } from 'src/clientes/clientes.service';
import type { CreateClienteDto } from 'src/clientes/dto/create-cliente.dto';
import { aTexto, normalizarEncabezado } from 'src/crm/leads/importacion/leads-import.util';
import { PrismaService } from 'src/prisma/prisma.service';
import { siguienteNumeroSocio } from '../../common/socio-utils';
import { MembresiasManualesService } from '../membresias-manuales.service';
import {
  COLUMNAS_SOCIO,
  type ColumnaSocio,
  construirFilaSocio,
  type FilaSocio,
  filaDeEncabezado,
  filaSinDatos,
  mapearColumnas,
} from './importar-socios.util';

/** Más que esto no es una carga de socios, es una migración: se parte el archivo. */
export const MAX_FILAS_SOCIOS = 3000;

/**
 * Qué pasa con cada fila:
 * - `NUEVO`: se crea el cliente y su ficha de socio.
 * - `CLIENTE_EXISTENTE`: el cliente ya está en el ERP; se le crea sólo la ficha.
 * - `YA_ES_SOCIO`: ya tiene ficha; no se toca (salvo el plan ya pagado, si la fila lo trae y se puede cargar).
 * - `ERROR`: no se puede importar (el motivo dice por qué).
 */
export type ResultadoFila = 'NUEVO' | 'CLIENTE_EXISTENTE' | 'YA_ES_SOCIO' | 'ERROR';

export interface FilaEvaluada extends FilaSocio {
  resultado: ResultadoFila;
  motivo?: string;
  numero_socio?: number;
  /** El plan ya pagado que se le carga (sin factura, origen MIGRACION). */
  plan_carga?: { plan_id: string; plan: string; fecha_inicio: string; fecha_fin: string };
  /** Después de importar: si el plan quedó cargado. */
  plan_cargado?: boolean;
  /** Ficha del socio que ya existía (para cargarle el plan). */
  socio_id?: string;
}

interface Catalogos {
  contribuyente: string;
  noContribuyente: string;
  cedula: string;
  personaFisica: string;
  b2b: string;
  b2c: string;
}

/**
 * Carga inicial de socios desde Excel: cliente del ERP + ficha de socio.
 *
 * La ficha queda **incompleta** (`ficha_incompleta`), igual que la que crea una
 * venta a alguien que no pasó por el alta (decisión 11 del módulo): la planilla
 * no trae fecha de nacimiento, foto ni firma, que el alta pide. Recepción la
 * encuentra por CI y la completa cuando el socio viene.
 *
 * Membresías: una membresía nace de una factura, salvo el plan que el socio ya
 * pagó en el sistema anterior. Si la planilla trae plan y vencimiento, se carga
 * sin factura (origen MIGRACION, §15.12), también a quien ya era socio (así se
 * completa una importación hecha sin esas columnas). Sin eso, el socio figura
 * «sin plan» hasta que se le cobre.
 *
 * Dos pasos sin estado intermedio, como la importación de leads del CRM: el
 * preview lee el archivo y clasifica cada fila sin escribir; la importación
 * recibe el mismo archivo. Una fila con error no frena a las demás.
 */
@Injectable()
export class ImportarSociosService {
  private readonly logger = new Logger(ImportarSociosService.name);

  constructor(
    private readonly prisma: PrismaService,
    private readonly clientes: ClientesService,
    private readonly audit: AuditService,
    private readonly manuales: MembresiasManualesService,
  ) {}

  async preview(file: Express.Multer.File, empresa_id: string) {
    const { hoja, filas, columnas } = this.leer(file);
    const evaluadas = await this.clasificar(filas, empresa_id);
    return {
      data: {
        nombre_archivo: file.originalname,
        hoja,
        columnas,
        resumen: this.resumir(evaluadas),
        filas: evaluadas,
      },
    };
  }

  async importar(file: Express.Multer.File, empresa_id: string, sede_id: string | undefined, user_id?: string) {
    const { filas } = this.leer(file);
    const sedeBase = await this.sedeBase(empresa_id, sede_id);
    const catalogos = await this.catalogos();
    const evaluadas = await this.clasificar(filas, empresa_id);

    const motivoPlan = `Plan ya pagado, importado de la planilla «${file.originalname}»`.slice(0, 500);
    for (const f of evaluadas) {
      if (f.resultado === 'ERROR') continue;
      if (f.resultado !== 'YA_ES_SOCIO') {
        try {
          const clienteId = (await this.buscarCliente(f, empresa_id))?.id ?? (await this.crearCliente(f, empresa_id, catalogos, user_id));
          const ficha = await this.crearFicha(clienteId, f, empresa_id, sedeBase, user_id);
          f.numero_socio = ficha.numero_socio;
          f.socio_id = ficha.id;
        } catch (e) {
          // Una fila mala no cancela la importación: el reporte dice cuál falló y por qué.
          f.resultado = 'ERROR';
          f.motivo = this.mensaje(e);
          continue;
        }
      }
      if (f.plan_carga && f.socio_id) {
        try {
          await this.manuales.asignar(
            empresa_id,
            f.socio_id,
            { plan_id: f.plan_carga.plan_id, fecha_inicio: f.plan_carga.fecha_inicio, fecha_fin: f.plan_carga.fecha_fin, motivo: motivoPlan },
            user_id,
            gym_membresia_origen.MIGRACION,
          );
          f.plan_cargado = true;
        } catch (e) {
          // El socio queda importado; el plan, no (se cobra en caja o se carga desde la ficha).
          f.plan_cargado = false;
          f.avisos.push(`El plan no se cargó: ${this.mensaje(e)}`);
        }
      }
    }

    const resumen = this.resumir(evaluadas);
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'CREAR',
      entity_type: 'gym_socios',
      entity_id: empresa_id,
      descripcion: `Importación de socios (${file.originalname}): ${resumen.nuevos} nuevos, ${resumen.clientes_existentes} clientes existentes, ${resumen.ya_socios} ya eran socios, ${resumen.errores} con error, ${resumen.planes} planes ya pagados cargados`,
      new_value: { archivo: file.originalname, resumen },
    });
    this.logger.log(`Importación de socios ${file.originalname}: ${JSON.stringify(resumen)}`);

    return {
      message:
        `${resumen.nuevos + resumen.clientes_existentes} socios importados de ${evaluadas.length} filas` +
        (resumen.planes ? `; ${resumen.planes} con su plan ya pagado` : ''),
      data: {
        resumen,
        // El reporte de lo que no entró: es lo que la persona necesita para corregir la planilla.
        no_importadas: evaluadas.filter((f) => f.resultado === 'ERROR' || (f.resultado === 'YA_ES_SOCIO' && !f.plan_cargado)),
        // Filas importadas con algo que se descartó (p. ej. el plan que no se pudo cargar).
        con_avisos: evaluadas.filter((f) => f.resultado !== 'ERROR' && f.avisos.length > 0),
      },
    };
  }

  // ─────────────────────────────── lectura ───────────────────────────────

  /**
   * La primera hoja que tiene columnas de nombre y documento. Las planillas
   * reales suelen traer varias (proveedores, precios…) y un título arriba.
   */
  private leer(file: Express.Multer.File) {
    let libro: XLSX.WorkBook;
    try {
      // Las fechas con el formato por defecto de Excel (que muestra mes/día) salen como 'YYYY-MM-DD'; las que tienen un
      // formato propio (dd/mm/aaaa) salen como se ven. Así el vencimiento del plan no se lee al revés.
      libro = XLSX.read(file.buffer, { type: 'buffer', cellDates: true, dateNF: 'yyyy-mm-dd' });
    } catch {
      throw new BadRequestException('No se pudo leer el archivo. Tiene que ser .xlsx, .xls o .csv');
    }
    for (const hoja of libro.SheetNames) {
      const celdas = XLSX.utils.sheet_to_json<unknown[]>(libro.Sheets[hoja], { header: 1, defval: '', raw: false, blankrows: true });
      const inicio = filaDeEncabezado(celdas);
      if (inicio < 0) continue;

      const encabezado = (celdas[inicio] ?? []).map(aTexto);
      const mapeo = mapearColumnas(encabezado);
      const indices: Partial<Record<ColumnaSocio, number>> = {};
      for (const campo of COLUMNAS_SOCIO) {
        const columna = mapeo[campo];
        if (columna) indices[campo] = encabezado.indexOf(columna);
      }

      const filas: FilaSocio[] = [];
      for (let i = inicio + 1; i < celdas.length; i++) {
        if (filaSinDatos(celdas[i] ?? [])) continue;
        filas.push(construirFilaSocio(celdas[i] ?? [], indices, i + 1));
      }
      if (filas.length > MAX_FILAS_SOCIOS) {
        throw new BadRequestException(`La hoja «${hoja}» tiene ${filas.length} filas y el máximo es ${MAX_FILAS_SOCIOS}. Partila en varios archivos.`);
      }
      return { hoja, filas, columnas: mapeo };
    }
    throw new BadRequestException(
      'No encontramos una hoja con columnas de nombre y documento. La planilla tiene que tener al menos «Nombre» y «CI» (o «RUC», «Documento»).',
    );
  }

  // ───────────────────────────── clasificación ─────────────────────────────

  /** Decide qué pasa con cada fila mirando la base y el propio archivo. No escribe. */
  private async clasificar(filas: FilaSocio[], empresa_id: string): Promise<FilaEvaluada[]> {
    const planes = filas.some((f) => f.plan)
      ? await this.prisma.gym_planes.findMany({ where: { empresa_id, activo: true } })
      : [];
    const planPorNombre = new Map(planes.map((p) => [normalizarEncabezado(p.nombre), p]));
    const vistos = new Map<string, number>();
    const resultado: FilaEvaluada[] = [];
    for (const f of filas) {
      if (f.error) {
        resultado.push({ ...f, resultado: 'ERROR', motivo: f.error });
        continue;
      }
      const numero = f.ruc ?? f.nro_documento ?? '';
      const anterior = vistos.get(numero);
      if (anterior) {
        resultado.push({ ...f, resultado: 'ERROR', motivo: `El documento ya aparece en la fila ${anterior} del archivo` });
        continue;
      }
      vistos.set(numero, f.fila);

      const cliente = await this.buscarCliente(f, empresa_id);
      if (!cliente) {
        resultado.push({ ...f, resultado: 'NUEVO' });
        continue;
      }
      const socio = await this.prisma.gym_socios.findUnique({
        where: { empresa_id_cliente_id: { empresa_id, cliente_id: cliente.id } },
        select: { id: true, numero_socio: true },
      });
      resultado.push(
        socio
          ? { ...f, resultado: 'YA_ES_SOCIO', numero_socio: socio.numero_socio, socio_id: socio.id, motivo: `Ya es el socio Nº ${socio.numero_socio}` }
          : { ...f, resultado: 'CLIENTE_EXISTENTE', motivo: `Ya es cliente: ${cliente.nombre}` },
      );
    }
    for (const f of resultado) {
      if (f.resultado === 'ERROR' || !f.plan || !f.plan_vence) continue;
      const plan = planPorNombre.get(normalizarEncabezado(f.plan));
      if (!plan) {
        f.avisos.push(`No hay un plan activo llamado «${f.plan}»: se importa sin plan`);
        continue;
      }
      const v = await this.manuales.validar(empresa_id, f.socio_id ?? null, plan, { fecha_inicio: f.plan_desde, fecha_fin: f.plan_vence });
      if ('motivo' in v) {
        f.avisos.push(`${v.motivo}: se importa sin plan`);
        continue;
      }
      f.plan_carga = { plan_id: plan.id, plan: plan.nombre, fecha_inicio: v.fecha_inicio, fecha_fin: v.fecha_fin };
      if (f.resultado === 'YA_ES_SOCIO') f.motivo = `Ya es el socio Nº ${f.numero_socio}: se le carga el plan`;
    }
    return resultado;
  }

  /**
   * El cliente con ese número, sea como RUC o como cédula: la misma persona puede
   * estar cargada de las dos formas y no se la duplica.
   */
  private async buscarCliente(f: FilaSocio, empresa_id: string) {
    const numero = f.ruc ?? f.nro_documento;
    if (!numero) return null;
    const c = await this.prisma.clientes.findFirst({
      where: { deleted: false, personas: { empresa_id, deleted: false, OR: [{ ruc: numero }, { nro_documento: numero }] } },
      select: { id: true, personas: { select: { razon_social: true } } },
      orderBy: { created_at: 'asc' },
    });
    return c ? { id: c.id, nombre: c.personas?.razon_social ?? '' } : null;
  }

  // ─────────────────────────────── escritura ───────────────────────────────

  /**
   * Por `ClientesService.create`, como el alta manual: mismas validaciones,
   * mismo control de duplicados y límite del plan. Con RUC es contribuyente
   * (B2B, persona física); con cédula, consumidor final (B2C).
   */
  private async crearCliente(f: FilaSocio, empresa_id: string, cat: Catalogos, user_id?: string): Promise<string> {
    const esRuc = Boolean(f.ruc);
    const dto = {
      tipo_operacion_id: esRuc ? cat.b2b : cat.b2c,
      naturaleza_id: esRuc ? cat.contribuyente : cat.noContribuyente,
      razon_social: f.nombre,
      ...(esRuc
        ? { ruc: f.ruc, dv: Number(f.dv), tipo_contribuyente_id: cat.personaFisica }
        : { nro_documento: f.nro_documento, tipo_documento_id: cat.cedula }),
      email: f.email,
      celular: f.celular,
    } as CreateClienteDto;
    const creado = await this.clientes.create(dto, empresa_id, user_id);
    const id = creado?.data?.cliente?.id;
    if (!id) throw new BadRequestException('No se pudo crear el cliente');
    return id;
  }

  private async crearFicha(cliente_id: string, f: FilaSocio, empresa_id: string, sede_base_id: string | null, user_id?: string) {
    const socio = await this.prisma.$transaction(async (tx) =>
      tx.gym_socios.create({
        data: {
          empresa_id,
          cliente_id,
          numero_socio: await siguienteNumeroSocio(tx, empresa_id),
          email: f.email ?? null,
          telefono: f.celular ?? null,
          sede_base_id,
          origen: gym_socio_origen.MIGRACION,
          ficha_incompleta: true,
          observaciones: f.observaciones ?? null,
          created_by: user_id ?? null,
        },
        select: { id: true, numero_socio: true },
      }),
    );
    return socio;
  }

  // ─────────────────────────────── auxiliares ───────────────────────────────

  /** La sede elegida, o la única activa. Con varias sedes hay que elegir. */
  private async sedeBase(empresa_id: string, sede_id?: string): Promise<string | null> {
    if (sede_id) {
      const sede = await this.prisma.gym_sedes.findFirst({ where: { id: sede_id, empresa_id, activo: true }, select: { id: true } });
      if (!sede) throw new BadRequestException('La sede elegida no existe o está dada de baja');
      return sede.id;
    }
    const sedes = await this.prisma.gym_sedes.findMany({ where: { empresa_id, activo: true }, select: { id: true }, take: 2 });
    if (sedes.length > 1) throw new BadRequestException('Hay más de una sede: elegí a cuál pertenecen los socios');
    return sedes[0]?.id ?? null;
  }

  private async catalogos(): Promise<Catalogos> {
    const [naturalezas, cedula, personaFisica, operaciones] = await Promise.all([
      this.prisma.naturaleza_receptor.findMany({ select: { id: true, codigo: true } }),
      this.prisma.tipo_documento_identidad.findFirst({ where: { codigo: 1 }, select: { id: true } }),
      this.prisma.tipo_contribuyente.findFirst({ where: { codigo: 1 }, select: { id: true } }),
      this.prisma.tipo_operacion.findMany({ where: { codigo: { in: [1, 2] } }, select: { id: true, codigo: true } }),
    ]);
    const nat = (c: number) => naturalezas.find((n) => Number(n.codigo) === c)?.id;
    const ope = (c: number) => operaciones.find((o) => Number(o.codigo) === c)?.id;
    const cat = {
      contribuyente: nat(1),
      noContribuyente: nat(2),
      cedula: cedula?.id,
      personaFisica: personaFisica?.id,
      b2b: ope(1),
      b2c: ope(2),
    };
    const falta = Object.entries(cat).filter(([, v]) => !v).map(([k]) => k);
    if (falta.length) throw new BadRequestException(`Faltan catálogos fiscales en el ERP: ${falta.join(', ')}`);
    return cat as Catalogos;
  }

  private resumir(filas: FilaEvaluada[]) {
    const contar = (r: ResultadoFila) => filas.filter((f) => f.resultado === r).length;
    return {
      total: filas.length,
      nuevos: contar('NUEVO'),
      clientes_existentes: contar('CLIENTE_EXISTENTE'),
      ya_socios: contar('YA_ES_SOCIO'),
      errores: contar('ERROR'),
      // En la vista previa, los que se van a cargar; después de importar, los cargados.
      planes: filas.filter((f) => (f.plan_cargado ?? !!f.plan_carga) && f.resultado !== 'ERROR').length,
    };
  }

  private mensaje(e: unknown): string {
    if (e instanceof Prisma.PrismaClientKnownRequestError && e.code === 'P2002') return 'Ya tiene ficha de socio';
    const r = (e as { response?: { message?: string | string[] } })?.response;
    if (r?.message) return Array.isArray(r.message) ? r.message.join('; ') : r.message;
    return e instanceof Error ? e.message : 'Error desconocido';
  }
}
