import { gym_tarifa_modo, gym_turno_estado as E } from '@prisma/client';
import { Prisma } from '@prisma/client';

/**
 * Reglas puras del spa (plan v0.5 §6.1): cantidad × unidad, horario del día, capacidad del recurso, camino del turno y
 * pago a la profesional. Sin base de datos: las prueba spa-reglas.spec.ts.
 */

/** Cantidad máxima de unidades en un ítem (20 × 50 min ≈ un día entero). */
export const CANTIDAD_MAXIMA = 20;

/** Una cantidad vale si es positiva, no pasa del máximo y es múltiplo de la fracción mínima del servicio (0,5 → 1 · 1,5 · 2). */
export function errorCantidad(cantidad: number, fraccionMinima: number, servicio: string): string | null {
  if (!Number.isFinite(cantidad) || cantidad <= 0) return `La cantidad de ${servicio} tiene que ser mayor que cero`;
  if (cantidad > CANTIDAD_MAXIMA) return `La cantidad de ${servicio} es como máximo ${CANTIDAD_MAXIMA}`;
  const pasos = cantidad / fraccionMinima;
  if (Math.abs(pasos - Math.round(pasos)) > 1e-6)
    return fraccionMinima === 1
      ? `${servicio} se agenda por unidades enteras`
      : `${servicio} se agenda de a ${String(fraccionMinima).replace('.', ',')} (ej. 1, 1,5 o 2)`;
  return null;
}

/** Duración en minutos: cantidad × unidad del servicio (1,5 × 50 = 75). */
export function duracionDe(cantidad: number, unidadMin: number): number {
  return Math.round(cantidad * unidadMin);
}

export type HorarioDia = { desde: string; hasta: string };

/**
 * Horario del spa para un día ISO (1 = lunes … 7 = domingo) desde `gym_config.horario_spa`:
 * `undefined` = la empresa no cargó horario (no se valida), `null` = ese día está cerrado.
 */
export function horarioDelDia(horarioSpa: unknown, diaSemana: number): HorarioDia | null | undefined {
  if (!horarioSpa || typeof horarioSpa !== 'object') return undefined;
  const v = (horarioSpa as Record<string, unknown>)[String(diaSemana)];
  if (!Array.isArray(v) || v.length !== 2 || typeof v[0] !== 'string' || typeof v[1] !== 'string') return null;
  return { desde: v[0], hasta: v[1] };
}

const minutos = (hora: string) => {
  const [h, m] = hora.split(':').map(Number);
  return h * 60 + m;
};
export const aHora = (m: number) => `${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(2, '0')}`;

/** Fin 'HH:MM' de un ítem que empieza a `hora` y dura `duracion` minutos (null si pasa la medianoche). */
export function finDe(hora: string, duracion: number): string | null {
  const fin = minutos(hora) + duracion;
  return fin > 24 * 60 ? null : aHora(fin);
}

/** El turno entra entero en el horario del día: empieza en hora y TERMINA antes del cierre (plan §6.1.4 punto 3). */
export function errorHorario(hora: string, fin: string, horario: HorarioDia | null | undefined): string | null {
  if (horario === undefined) return null;
  if (horario === null) return 'El spa está cerrado ese día';
  if (minutos(hora) < minutos(horario.desde)) return `El spa abre a las ${horario.desde}`;
  if (minutos(fin) > minutos(horario.hasta))
    return `Termina a las ${fin} y el spa cierra a las ${horario.hasta}: elegí un horario más temprano o menos cantidad`;
  return null;
}

export interface Ocupacion {
  id: string;
  inicio: Date;
  fin: Date;
}

const seCruzan = (a: { inicio: Date; fin: Date }, b: { inicio: Date; fin: Date }) =>
  a.inicio.getTime() < b.fin.getTime() && b.inicio.getTime() < a.fin.getTime();

/**
 * ¿Entra uno más en el recurso? En cada instante del nuevo intervalo, los que ya están no pueden llegar a la capacidad
 * (cabina o hidromasaje: 1; sauna: la que tenga). Devuelve el primero que estorba, o null.
 */
export function choqueDeRecurso(
  nuevo: { inicio: Date; fin: Date },
  otros: Ocupacion[],
  capacidad: number,
): Ocupacion | null {
  const cruzados = otros.filter((o) => seCruzan(nuevo, o));
  if (cruzados.length < Math.max(1, capacidad)) return null;
  // Con capacidad > 1 importa cuántos hay a la vez: se revisa cada borde dentro del intervalo nuevo.
  const bordes = [nuevo.inicio.getTime(), ...cruzados.map((o) => o.inicio.getTime())].filter(
    (b) => b >= nuevo.inicio.getTime() && b < nuevo.fin.getTime(),
  );
  for (const b of bordes) {
    const aLaVez = cruzados.filter((o) => o.inicio.getTime() <= b && b < o.fin.getTime());
    if (aLaVez.length >= Math.max(1, capacidad)) return aLaVez[0];
  }
  return null;
}

/** Los que ocupan recurso y profesional: un cancelado o un no-show liberaron el lugar. */
export const TURNOS_QUE_OCUPAN: E[] = [E.RESERVADO, E.LLEGO, E.EN_CURSO, E.REALIZADO, E.FACTURADO];

/** El camino del turno: hacia adelante se puede saltar pasos; hacia atrás, de a uno (deshacer). */
const CAMINO: E[] = [E.RESERVADO, E.LLEGO, E.EN_CURSO, E.REALIZADO];

export function errorTransicion(actual: E, nuevo: E, cortesia: boolean): string | null {
  if (actual === nuevo) return 'El turno ya está en ese estado';
  if (actual === E.CANCELADO) return 'El turno está cancelado';
  if (actual === E.FACTURADO) return 'El turno ya está facturado: para cambiarlo, anulá la factura';
  if (nuevo === E.FACTURADO) return 'Un turno pasa a facturado cuando se emite su factura en la caja';
  if (nuevo === E.CANCELADO) return 'Para cancelar un turno indicá el motivo (Cancelar)';
  if (nuevo === E.NO_SHOW)
    return actual === E.RESERVADO || actual === E.LLEGO ? null : 'Solo se marca «No vino» antes de empezar';
  if (actual === E.NO_SHOW) return nuevo === E.RESERVADO ? null : 'Primero volvé el turno a reservado';
  const a = CAMINO.indexOf(actual);
  const n = CAMINO.indexOf(nuevo);
  if (n > a) return null;
  if (actual === E.REALIZADO && cortesia) return 'El turno es una cortesía: no se vuelve atrás';
  return a - n === 1 ? null : 'Se vuelve atrás de a un paso';
}

/** Lo que cobra la profesional por un ítem: monto × cantidad, o % del importe facturado. Redondeado a los decimales de la moneda. */
export function aPagar(
  tarifa: { modo: gym_tarifa_modo; valor: Prisma.Decimal | number | string },
  cantidad: Prisma.Decimal | number | string,
  importeFacturado: Prisma.Decimal | number | string,
  decimales: number,
): Prisma.Decimal {
  const valor = new Prisma.Decimal(tarifa.valor);
  const monto =
    tarifa.modo === gym_tarifa_modo.PORCENTAJE
      ? new Prisma.Decimal(importeFacturado).mul(valor).div(100)
      : valor.mul(new Prisma.Decimal(cantidad));
  return monto.toDecimalPlaces(decimales, Prisma.Decimal.ROUND_HALF_UP);
}

/** Decimales de una moneda para el dinero del gimnasio: 0 en guaraníes, 2 en el resto (regla del ERP). */
export const decimalesDe = (codigo: string | null | undefined) => (codigo === 'PYG' ? 0 : 2);

/**
 * Valida el horario del spa que se guarda en `gym_config.horario_spa`: claves «1»…«7» (lunes a domingo), cada una
 * `null` (cerrado) o `["HH:MM", "HH:MM"]` con la apertura antes del cierre. Devuelve los errores (vacío = vale).
 */
export function erroresHorarioSpa(h: unknown): string[] {
  if (h === null) return [];
  if (typeof h !== 'object' || Array.isArray(h)) return ['El horario del spa va por día de la semana'];
  const errores: string[] = [];
  const HORA = /^([01]\d|2[0-3]):[0-5]\d$/;
  const nombres = ['', 'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo'];
  for (const [k, v] of Object.entries(h as Record<string, unknown>)) {
    const d = Number(k);
    if (!Number.isInteger(d) || d < 1 || d > 7) {
      errores.push(`Día inválido en el horario del spa: ${k}`);
      continue;
    }
    if (v === null) continue;
    if (!Array.isArray(v) || v.length !== 2 || !v.every((x) => typeof x === 'string' && HORA.test(x))) {
      errores.push(`El horario del ${nombres[d]} va como ["14:00", "21:30"] o vacío si está cerrado`);
      continue;
    }
    if (v[0] >= v[1]) errores.push(`El ${nombres[d]} el spa tiene que abrir antes de cerrar`);
  }
  return errores;
}
