import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
import { gym_membresia_estado, gym_membresia_origen, gym_plan_tipo, gym_renovacion_desde, gym_socio_estado } from '@prisma/client';
import { AuditService } from 'src/audit/audit.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { aFecha, calcularVigencia, deFecha, diaPy, sumarDias } from '../common/fechas-gym';
import { ESTADOS_MEMBRESIA_FUERA } from '../ventas/gym-ventas.service';

/** Hasta cuándo puede llegar un plan cargado a mano: más es un error de tipeo. */
const MAX_DIAS_ADELANTE = 3 * 366;

const FECHA = /^\d{4}-\d{2}-\d{2}$/;

export interface AsignacionSinFactura {
  plan_id: string;
  /** Primer día del plan. Por defecto, hoy. */
  fecha_inicio?: string | null;
  /** Último día. Por defecto, lo que dura el plan desde el inicio. */
  fecha_fin?: string | null;
  /** Paquetes de créditos que vienen usados del sistema anterior. Por defecto, todos los del plan. */
  creditos_restantes?: number | null;
  motivo: string;
}

type PlanVigencia = Parameters<typeof calcularVigencia>[0]['plan'];

/**
 * Plan ya pagado, sin factura (docs/plan-gimnasio.md §15.12): el socio pagó antes del sistema, o en otro lado. Es la
 * excepción a «no hay membresía sin factura» (regla 1), y por eso pide permiso propio, motivo y queda en el reporte
 * «Membresías sin factura». La usan la ficha del socio (origen MANUAL) y la importación de socios (origen MIGRACION).
 *
 * El próximo cobro en caja encadena con ella como con cualquier otra: la renovación empieza al día siguiente del fin.
 */
@Injectable()
export class MembresiasManualesService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
  ) {}

  /** El plan activo de la empresa, con lo que hace falta para calcular la vigencia. */
  async plan(empresa_id: string, plan_id: string) {
    const plan = await this.prisma.gym_planes.findFirst({ where: { id: plan_id, empresa_id, activo: true } });
    if (!plan) throw new BadRequestException('El plan no existe o está dado de baja');
    return plan;
  }

  /** Fechas y créditos que tendría el plan si empieza ese día (para precargar el formulario). */
  async vigencia(empresa_id: string, plan_id: string, desde?: string | null) {
    const plan = await this.plan(empresa_id, plan_id);
    return { ...propuesta(plan, desde || diaPy()), tipo: plan.tipo };
  }

  /**
   * Revisa lo que se quiere cargar sin escribir. Devuelve las fechas finales o el motivo por el que no se puede (la
   * importación lo usa como aviso de la fila; la ficha, como error).
   */
  async validar(
    empresa_id: string,
    /** null: el socio todavía no existe (la importación lo crea), no hay con qué pisarse. */
    socio_id: string | null,
    plan: PlanVigencia & { id: string; nombre: string },
    d: Omit<AsignacionSinFactura, 'plan_id' | 'motivo'>,
  ): Promise<{ ok: true; fecha_inicio: string; fecha_fin: string; creditos_totales: number | null; creditos_usados: number } | { ok: false; motivo: string }> {
    const hoy = diaPy();
    const inicio = d.fecha_inicio || hoy;
    if (!FECHA.test(inicio)) return { ok: false, motivo: 'La fecha de inicio no es válida' };
    if (d.fecha_fin && !FECHA.test(d.fecha_fin)) return { ok: false, motivo: 'La fecha de fin no es válida' };
    const v = propuesta(plan, inicio);
    const fin = d.fecha_fin || v.fecha_fin;
    if (fin < inicio) return { ok: false, motivo: 'La fecha de fin es anterior a la de inicio' };
    if (fin < hoy) return { ok: false, motivo: `El plan venció el ${aDdMm(fin)}: no hace falta cargarlo, se cobra en caja` };
    if (fin > sumarDias(hoy, MAX_DIAS_ADELANTE)) return { ok: false, motivo: `El ${aDdMm(fin)} está a más de 3 años: revisá la fecha de fin` };

    let creditos_totales = v.creditos_totales;
    let creditos_usados = 0;
    if (creditos_totales != null && d.creditos_restantes != null) {
      const restantes = Math.max(0, Math.floor(d.creditos_restantes));
      if (restantes > creditos_totales) creditos_totales = restantes;
      creditos_usados = creditos_totales - restantes;
    }

    if (socio_id && plan.tipo !== gym_plan_tipo.CREDITOS) {
      // Un socio tiene una sola membresía de acceso a la vez (regla 7): no se pisa con otra.
      const pisa = await this.prisma.gym_membresias.findFirst({
        where: {
          empresa_id,
          socio_id,
          estado: { notIn: ESTADOS_MEMBRESIA_FUERA },
          plan: { tipo: { not: gym_plan_tipo.CREDITOS } },
          fecha_inicio: { lte: aFecha(fin) },
          fecha_fin: { gte: aFecha(inicio) },
        },
        include: { plan: { select: { nombre: true } } },
        orderBy: { fecha_inicio: 'asc' },
      });
      if (pisa) {
        return {
          ok: false,
          motivo: `Ya tiene ${pisa.plan.nombre} del ${aDdMm(deFecha(pisa.fecha_inicio))} al ${aDdMm(deFecha(pisa.fecha_fin))}: elegí fechas que no se pisen o anulá esa membresía`,
        };
      }
    }
    return { ok: true, fecha_inicio: inicio, fecha_fin: fin, creditos_totales, creditos_usados };
  }

  /** Crea la membresía sin factura. Lanza si no se puede (lo que `validar` explica). */
  async asignar(
    empresa_id: string,
    socio_id: string,
    d: AsignacionSinFactura,
    user_id: string | undefined,
    origen: gym_membresia_origen = gym_membresia_origen.MANUAL,
  ) {
    const motivo = d.motivo?.trim().slice(0, 500);
    if (!motivo || motivo.length < 3) throw new BadRequestException('Indicá por qué se carga sin factura (por ejemplo, «pagó en efectivo antes del sistema»)');
    const socio = await this.prisma.gym_socios.findFirst({
      where: { id: socio_id, empresa_id },
      select: { id: true, numero_socio: true, estado: true, sede_base_id: true },
    });
    if (!socio) throw new NotFoundException('No se encontró el socio');
    if (socio.estado === gym_socio_estado.BAJA) throw new BadRequestException('El socio está de baja: reactivalo antes de cargarle un plan');
    const plan = await this.plan(empresa_id, d.plan_id);
    const v = await this.validar(empresa_id, socio_id, plan, d);
    if ('motivo' in v) throw new ConflictException(v.motivo);

    const membresia = await this.prisma.gym_membresias.create({
      data: {
        empresa_id,
        socio_id,
        plan_id: plan.id,
        sede_base_id: socio.sede_base_id,
        fecha_inicio: aFecha(v.fecha_inicio),
        fecha_fin: aFecha(v.fecha_fin),
        fecha_fin_original: aFecha(v.fecha_fin),
        estado: gym_membresia_estado.ACTIVA,
        origen,
        periodos: 1,
        creditos_totales: v.creditos_totales,
        creditos_usados: v.creditos_usados,
        motivo_sin_factura: motivo,
        created_by: user_id ?? null,
      },
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'CREAR',
      entity_type: 'gym_membresias',
      entity_id: membresia.id,
      descripcion: `Membresía ${plan.nombre} del socio N° ${socio.numero_socio} sin factura (${v.fecha_inicio} a ${v.fecha_fin}): ${motivo}`,
      new_value: { plan: plan.nombre, origen, fecha_inicio: v.fecha_inicio, fecha_fin: v.fecha_fin, creditos_totales: v.creditos_totales, creditos_usados: v.creditos_usados, motivo },
    });
    return membresia;
  }
}

/** La vigencia de un período del plan desde ese día, sin encadenar con otra membresía. */
function propuesta(plan: PlanVigencia, desde: string) {
  return calcularVigencia({ plan, periodos: 1, diaVenta: desde, anteriorFin: null, renovacionDesde: gym_renovacion_desde.FIN_ANTERIOR });
}

function aDdMm(iso: string) {
  const [a, m, d] = iso.split('-');
  return `${d}/${m}/${a}`;
}
