import { gym_alcance_sedes, gym_plan_tipo } from '@prisma/client';
import { startOfDayAsuncion } from 'src/utils/utilidades';
import { valeEnSede } from '../common/acceso-reglas';
import { aFecha, diaPy, horaPy, sumarDias } from '../common/fechas-gym';
import { minutosDelDia } from '../common/reglas';

/**
 * Reglas de clases y reservas (docs/plan-gimnasio.md §15.9). Puras: el servicio
 * junta los datos, esto decide.
 */

/** Día de la semana ISO (1 = lunes … 7 = domingo) de un día 'YYYY-MM-DD'. */
export function diaSemanaIso(dia: string): number {
  const d = aFecha(dia).getUTCDay();
  return d === 0 ? 7 : d;
}

/** Instante del día `dia` a la hora 'HH:MM' de Asunción. Paraguay no tiene horario de verano desde 2024. */
export function instanteDe(dia: string, hora: string): Date {
  return new Date(startOfDayAsuncion(dia).getTime() + minutosDelDia(hora) * 60_000);
}

/** Días de [desde, hasta] en que la plantilla genera una sesión. */
export function diasDePlantilla(
  p: { dia_semana: number; vigente_desde: string; vigente_hasta: string | null },
  desde: string,
  hasta: string,
): string[] {
  const ini = p.vigente_desde > desde ? p.vigente_desde : desde;
  const fin = p.vigente_hasta && p.vigente_hasta < hasta ? p.vigente_hasta : hasta;
  const dias: string[] = [];
  if (ini > fin) return dias;
  const corrimiento = (p.dia_semana - diaSemanaIso(ini) + 7) % 7;
  for (let d = sumarDias(ini, corrimiento); d <= fin; d = sumarDias(d, 7)) dias.push(d);
  return dias;
}

export interface MembresiaReserva {
  id: string;
  fecha_inicio: string;
  fecha_fin: string;
  sede_base_id: string | null;
  creditos_totales: number | null;
  creditos_usados: number;
  plan: {
    nombre: string;
    tipo: gym_plan_tipo;
    alcance_sedes: gym_alcance_sedes;
    sedes_permitidas: string[];
    hora_desde: string | null;
    hora_hasta: string | null;
    actividades_incluidas: string[];
    creditos_actividades: string[];
  };
}

export type Elegibilidad =
  | { ok: true; membresia_id: string; consume_credito: boolean; mensaje: string }
  | { ok: false; mensaje: string };

/**
 * Con qué membresía reserva el socio la clase del día `dia`:
 * 1. Un plan vigente que incluye la actividad (no descuenta nada).
 * 2. Un paquete (CREDITOS o MIXTO) vigente para esa actividad y con saldo:
 *    descuenta 1 crédito; primero el que vence antes.
 */
export function elegibilidadReserva(e: {
  membresias: MembresiaReserva[];
  actividad: { id: string; nombre: string };
  dia: string;
  sedeId: string;
  sedeBaseSocio: string | null;
}): Elegibilidad {
  const vigentes = e.membresias.filter(
    (m) =>
      m.fecha_inicio <= e.dia &&
      m.fecha_fin >= e.dia &&
      valeEnSede({ ...m, ultimo_credito_fecha: null }, e.sedeId, e.sedeBaseSocio),
  );
  const incluida = vigentes
    .filter((m) => m.plan.tipo !== gym_plan_tipo.CREDITOS && m.plan.actividades_incluidas.includes(e.actividad.id))
    .sort((a, b) => b.fecha_fin.localeCompare(a.fecha_fin))[0];
  if (incluida)
    return {
      ok: true,
      membresia_id: incluida.id,
      consume_credito: false,
      mensaje: `Incluida en ${incluida.plan.nombre}`,
    };

  const paquetes = vigentes
    .filter(
      (m) =>
        (m.plan.tipo === gym_plan_tipo.CREDITOS || m.plan.tipo === gym_plan_tipo.MIXTO) &&
        m.creditos_totales != null &&
        (m.plan.creditos_actividades.length === 0 || m.plan.creditos_actividades.includes(e.actividad.id)),
    )
    .sort((a, b) => a.fecha_fin.localeCompare(b.fecha_fin));
  const conSaldo = paquetes.find((m) => (m.creditos_totales ?? 0) > m.creditos_usados);
  if (conSaldo) {
    const quedan = (conSaldo.creditos_totales ?? 0) - conSaldo.creditos_usados - 1;
    return {
      ok: true,
      membresia_id: conSaldo.id,
      consume_credito: true,
      mensaje: `${conSaldo.plan.nombre}: se descuenta 1 crédito (quedan ${quedan})`,
    };
  }
  if (paquetes.length)
    return { ok: false, mensaje: `${paquetes[0].plan.nombre}: no le quedan créditos. Vendele otro paquete en la caja` };
  return { ok: false, mensaje: `Su plan no incluye ${e.actividad.nombre}. Vendele una clase o un paquete en la caja` };
}

/**
 * Ventana de reserva (`gym_config.ventana_reserva_horas`, plan §6): una clase se reserva desde N horas antes de su
 * inicio. 0 = sin ventana. Devuelve el mensaje del rechazo o null.
 */
export function fueraDeVentana(inicio: Date, ahora: Date, ventanaHoras: number): string | null {
  if (!ventanaHoras || ventanaHoras <= 0) return null;
  const abre = new Date(inicio.getTime() - ventanaHoras * 3_600_000);
  if (ahora.getTime() >= abre.getTime()) return null;
  const [a, m, d] = diaPy(abre).split('-');
  return `Las reservas abren ${ventanaHoras} h antes de la clase: esta se puede reservar desde el ${d}/${m}/${a} a las ${horaPy(abre)}`;
}

/** Cancelar con anticipación devuelve el crédito; tarde, se pierde (como un no-show). */
export function cancelacionATiempo(inicio: Date, ahora: Date, horasSinPenalidad: number): boolean {
  return inicio.getTime() - ahora.getTime() >= horasSinPenalidad * 3_600_000;
}

/** Dos horarios del mismo día se pisan si sus intervalos [inicio, inicio + duración) se cruzan. */
export function seSuperponen(
  a: { hora_inicio: string; duracion_min: number },
  b: { hora_inicio: string; duracion_min: number },
): boolean {
  const ai = minutosDelDia(a.hora_inicio);
  const bi = minutosDelDia(b.hora_inicio);
  return ai < bi + b.duracion_min && bi < ai + a.duracion_min;
}

/** Hora 'HH:MM' de fin (puede pasar de las 24 si la clase cruza la medianoche: se muestra igual). */
export function horaFin(hora: string, duracion: number): string {
  const t = minutosDelDia(hora) + duracion;
  return `${String(Math.floor(t / 60) % 24).padStart(2, '0')}:${String(t % 60).padStart(2, '0')}`;
}
