import {
  gym_acceso_resultado,
  gym_alcance_sedes,
  gym_apto_fisico_modo,
  gym_modo_vencido,
  gym_plan_tipo,
  gym_socio_estado,
} from '@prisma/client';
import { diasEntre, sumarDias } from './fechas-gym';
import { minutosDelDia } from './reglas';

/**
 * Decisión del ingreso por recepción (docs/plan-gimnasio.md §15.8). Pura: el
 * servicio junta los datos, esto decide. Las membresías que llegan no están
 * anuladas.
 */

export type Semaforo = 'VERDE' | 'AMARILLO' | 'ROJO';

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

export interface EntradaAcceso {
  /** `apto_fisico_vence` ('YYYY-MM-DD' o null) solo cuenta si la empresa pide el apto físico. */
  socio: { estado: gym_socio_estado; sede_base_id: string | null; apto_fisico_vence?: string | null };
  membresias: MembresiaAcceso[];
  sedeId: string;
  dia: string;
  hora: string;
  config: {
    modo_vencido: gym_modo_vencido;
    dias_gracia: number;
    minutos_antipassback: number;
    apto_fisico_modo?: gym_apto_fisico_modo;
    /** Socio sin ningún plan: entra con aviso (true) o no entra (false, por defecto). */
    sin_plan_con_aviso?: boolean;
  };
  /** Minutos desde el último ingreso permitido del socio (null si no hay). */
  minutosDesdeUltimoIngreso: number | null;
}

export interface DecisionAcceso {
  resultado: gym_acceso_resultado;
  semaforo: Semaforo;
  mensaje: string;
  membresia_id: string | null;
  dias_vencida: number | null;
  consumir_credito: boolean;
}

const R = gym_acceso_resultado;

/** Resultados con los que el socio entra (verde o amarillo): una sola lista para recepción, tablero y antipassback. */
export const RESULTADOS_PERMITIDOS: readonly gym_acceso_resultado[] = [
  R.PERMITIDO,
  R.PERMITIDO_FORZADO,
  R.ALERTA_VENCIDA,
  R.ALERTA_GRACIA,
  R.ALERTA_APTO,
  R.ALERTA_SIN_PLAN,
];
const AMARILLOS: readonly gym_acceso_resultado[] = [R.ALERTA_VENCIDA, R.ALERTA_GRACIA, R.ALERTA_APTO, R.ALERTA_SIN_PLAN];

export function semaforoDe(resultado: gym_acceso_resultado): Semaforo {
  if (resultado === R.PERMITIDO || resultado === R.PERMITIDO_FORZADO) return 'VERDE';
  if (AMARILLOS.includes(resultado)) return 'AMARILLO';
  return 'ROJO';
}

export function accesoPermitido(resultado: gym_acceso_resultado): boolean {
  return semaforoDe(resultado) !== 'ROJO';
}

function decision(
  resultado: gym_acceso_resultado,
  mensaje: string,
  extra: Partial<Pick<DecisionAcceso, 'membresia_id' | 'dias_vencida' | 'consumir_credito'>> = {},
): DecisionAcceso {
  return {
    resultado,
    semaforo: semaforoDe(resultado),
    mensaje,
    membresia_id: extra.membresia_id ?? null,
    dias_vencida: extra.dias_vencida ?? null,
    consumir_credito: extra.consumir_credito ?? false,
  };
}

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

export function valeEnSede(m: MembresiaAcceso, sedeId: string, sedeBaseSocio: string | null): boolean {
  switch (m.plan.alcance_sedes) {
    case gym_alcance_sedes.TODAS:
      return true;
    case gym_alcance_sedes.LISTA:
      return m.plan.sedes_permitidas.includes(sedeId);
    default: {
      const base = m.sede_base_id ?? sedeBaseSocio;
      return !base || base === sedeId;
    }
  }
}

/** Franja del plan; si `desde` > `hasta` cruza la medianoche (ej. 22:00–06:00). */
export function enFranja(m: MembresiaAcceso, hora: string): boolean {
  const { hora_desde: desde, hora_hasta: hasta } = m.plan;
  if (!desde || !hasta) return true;
  const h = minutosDelDia(hora);
  const d = minutosDelDia(desde);
  const a = minutosDelDia(hasta);
  return d <= a ? h >= d && h < a : h >= d || h < a;
}

/**
 * La decisión por membresía y, encima, el apto físico (plan §4.2 regla 10): con `apto_fisico_modo` AVISAR un ingreso
 * permitido pasa a amarillo con el aviso; con BLOQUEAR se rechaza. Sin apto cargado cuenta como vencido. No se
 * registra ningún dato clínico, solo la fecha de vencimiento.
 */
export function decidirAcceso(e: EntradaAcceso): DecisionAcceso {
  const d = decidirPorMembresia(e);
  const modo = e.config.apto_fisico_modo ?? gym_apto_fisico_modo.OFF;
  if (modo === gym_apto_fisico_modo.OFF || !accesoPermitido(d.resultado) || d.resultado === R.PERMITIDO_FORZADO) return d;
  const vence = e.socio.apto_fisico_vence ?? null;
  if (vence && vence >= e.dia) return d;
  const texto = vence ? `El apto físico venció el ${fmtDia(vence)}` : 'No presentó el apto físico';
  if (modo === gym_apto_fisico_modo.BLOQUEAR) {
    return { ...decision(R.RECHAZADO_APTO, `${texto}: no puede entrar hasta presentarlo`), membresia_id: d.membresia_id };
  }
  // AVISAR: entra igual. Si ya era amarillo (vencida/gracia) conserva ese resultado, que alimenta su reporte.
  return d.resultado === R.PERMITIDO
    ? { ...d, resultado: R.ALERTA_APTO, semaforo: semaforoDe(R.ALERTA_APTO), mensaje: `${d.mensaje}. ${texto}` }
    : { ...d, mensaje: `${d.mensaje}. ${texto}` };
}

function decidirPorMembresia(e: EntradaAcceso): DecisionAcceso {
  if (e.socio.estado !== gym_socio_estado.ACTIVO) {
    return decision(R.RECHAZADO_SOCIO, e.socio.estado === gym_socio_estado.BAJA ? 'El socio está dado de baja' : 'El socio está suspendido');
  }
  const { minutos_antipassback: anti } = e.config;
  if (anti > 0 && e.minutosDesdeUltimoIngreso != null && e.minutosDesdeUltimoIngreso < anti) {
    return decision(R.RECHAZADO_ANTIPASSBACK, `Ya ingresó hace ${Math.floor(e.minutosDesdeUltimoIngreso)} min`);
  }

  const vigentes = e.membresias.filter((m) => m.fecha_inicio <= e.dia && m.fecha_fin >= e.dia);
  const deAcceso = vigentes.filter((m) => m.plan.tipo !== gym_plan_tipo.CREDITOS);

  // 1. Membresía de acceso vigente, en su sede y su franja.
  let rechazo: DecisionAcceso | null = null;
  for (const m of [...deAcceso].sort((a, b) => b.fecha_fin.localeCompare(a.fecha_fin))) {
    if (!valeEnSede(m, e.sedeId, e.socio.sede_base_id)) {
      rechazo ??= decision(R.RECHAZADO_SEDE, `El plan ${m.plan.nombre} no vale en esta sede`, { membresia_id: m.id });
      continue;
    }
    if (!enFranja(m, e.hora)) {
      rechazo ??= decision(R.RECHAZADO_FRANJA, `El plan ${m.plan.nombre} vale de ${m.plan.hora_desde} a ${m.plan.hora_hasta}`, {
        membresia_id: m.id,
      });
      continue;
    }
    const restan = diasEntre(e.dia, m.fecha_fin);
    return decision(R.PERMITIDO, restan === 0 ? `${m.plan.nombre}: vence hoy` : `${m.plan.nombre}: vence el ${fmtDia(m.fecha_fin)} (faltan ${restan} días)`, {
      membresia_id: m.id,
    });
  }
  if (rechazo) return rechazo;

  // 2. Paquete de clases con saldo: descuenta un crédito, como mucho uno por día.
  const paquetes = vigentes
    .filter((m) => m.plan.tipo === gym_plan_tipo.CREDITOS && valeEnSede(m, e.sedeId, e.socio.sede_base_id))
    .sort((a, b) => a.fecha_fin.localeCompare(b.fecha_fin));
  const yaHoy = paquetes.find((m) => m.ultimo_credito_fecha === e.dia);
  if (yaHoy) {
    const saldo = (yaHoy.creditos_totales ?? 0) - yaHoy.creditos_usados;
    return decision(R.PERMITIDO, `${yaHoy.plan.nombre}: el crédito de hoy ya se descontó (quedan ${saldo})`, { membresia_id: yaHoy.id });
  }
  const conSaldo = paquetes.find((m) => (m.creditos_totales ?? 0) > m.creditos_usados);
  if (conSaldo) {
    const saldo = (conSaldo.creditos_totales ?? 0) - conSaldo.creditos_usados - 1;
    return decision(R.PERMITIDO, `${conSaldo.plan.nombre}: se descuenta 1 crédito (quedan ${saldo})`, {
      membresia_id: conSaldo.id,
      consumir_credito: true,
    });
  }

  // 3. Membresía de acceso vencida: según el modo de vencimiento de la empresa.
  const vencida = e.membresias
    .filter((m) => m.plan.tipo !== gym_plan_tipo.CREDITOS && m.fecha_fin < e.dia)
    .sort((a, b) => b.fecha_fin.localeCompare(a.fecha_fin))[0];
  const futura = e.membresias
    .filter((m) => m.fecha_inicio > e.dia)
    .sort((a, b) => a.fecha_inicio.localeCompare(b.fecha_inicio))[0];
  if (vencida && !(futura && futura.plan.tipo !== gym_plan_tipo.CREDITOS)) {
    const dias = diasEntre(vencida.fecha_fin, e.dia);
    const extra = { membresia_id: vencida.id, dias_vencida: dias };
    const texto = `${vencida.plan.nombre}: vencido hace ${dias} ${dias === 1 ? 'día' : 'días'} (${fmtDia(vencida.fecha_fin)})`;
    switch (e.config.modo_vencido) {
      case gym_modo_vencido.AVISAR:
        return decision(R.ALERTA_VENCIDA, `${texto}. Cobrar hoy`, extra);
      case gym_modo_vencido.GRACIA_Y_BLOQUEO:
        return dias <= e.config.dias_gracia
          ? decision(R.ALERTA_GRACIA, `${texto}. En gracia: quedan ${e.config.dias_gracia - dias} días`, extra)
          : decision(R.RECHAZADO_VENCIDA, `${texto}. Terminó la gracia`, extra);
      default:
        return decision(R.RECHAZADO_VENCIDA, texto, extra);
    }
  }
  if (futura) {
    return decision(R.RECHAZADO_SIN_MEMBRESIA, `${futura.plan.nombre}: empieza el ${fmtDia(futura.fecha_inicio)}`, { membresia_id: futura.id });
  }
  if (paquetes.length) {
    return decision(R.RECHAZADO_SIN_CREDITOS, `${paquetes[0].plan.nombre}: no le quedan créditos`, { membresia_id: paquetes[0].id });
  }
  // 4. Sin ningún plan: el gimnasio elige si entra con aviso (p. ej. socios cargados sin vencimiento que todavía no
  // pagaron) o no entra. Queda registrado igual; recepción lo ve en amarillo.
  if (e.config.sin_plan_con_aviso) {
    return decision(R.ALERTA_SIN_PLAN, 'No tiene un plan activo: entró con aviso. Cobrar hoy');
  }
  return decision(R.RECHAZADO_SIN_MEMBRESIA, 'No tiene una membresía comprada');
}

export type SituacionSocio = 'VIGENTE' | 'VENCIDA' | 'FUTURA' | 'SIN_PLAN';

/**
 * Situación de la membresía de acceso del socio para listados y avisos: la
 * vigente que vence más tarde; si no hay, la próxima a empezar; si no, la última
 * vencida. Los paquetes de créditos no cuentan (no dan acceso libre).
 */
export function situacionDeAcceso<T extends { fecha_inicio: string; fecha_fin: string; plan: { tipo: gym_plan_tipo } }>(
  membresias: T[],
  dia: string,
): { situacion: SituacionSocio; membresia: T | null; dias: number | null } {
  const acceso = membresias.filter((m) => m.plan.tipo !== gym_plan_tipo.CREDITOS);
  const vigente = acceso
    .filter((m) => m.fecha_inicio <= dia && m.fecha_fin >= dia)
    .sort((a, b) => b.fecha_fin.localeCompare(a.fecha_fin))[0];
  if (vigente) {
    // Si ya renovó por adelantado, el vencimiento real es el de la renovación.
    const fin = [...acceso].sort((a, b) => a.fecha_inicio.localeCompare(b.fecha_inicio)).reduce((max, m) => (m.fecha_inicio <= sumarDias(max, 1) && m.fecha_fin > max ? m.fecha_fin : max), vigente.fecha_fin);
    return { situacion: 'VIGENTE', membresia: vigente, dias: diasEntre(dia, fin) };
  }
  const futura = acceso.filter((m) => m.fecha_inicio > dia).sort((a, b) => a.fecha_inicio.localeCompare(b.fecha_inicio))[0];
  if (futura) return { situacion: 'FUTURA', membresia: futura, dias: diasEntre(dia, futura.fecha_inicio) };
  const vencida = acceso.filter((m) => m.fecha_fin < dia).sort((a, b) => b.fecha_fin.localeCompare(a.fecha_fin))[0];
  if (vencida) return { situacion: 'VENCIDA', membresia: vencida, dias: diasEntre(vencida.fecha_fin, dia) };
  return { situacion: 'SIN_PLAN', membresia: null, dias: null };
}

