import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import {
  gym_actividad_tipo,
  gym_reserva_estado,
  gym_sala_tipo,
  gym_sesion_estado,
  gym_staff_tipo,
  Prisma,
} from '@prisma/client';
import { AuditService } from 'src/audit/audit.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { aFecha, deFecha, diaPy, sumarDias } from '../common/fechas-gym';
import { diasDePlantilla, horaFin, instanteDe, seSuperponen } from './clases-reglas';
import { CreateHorarioGymDto, UpdateHorarioGymDto } from './dto/clases.dto';

/** Actividades que se dictan con horario y cupo (musculación e instalaciones no). */
export const ACTIVIDADES_CON_HORARIO: gym_actividad_tipo[] = [
  gym_actividad_tipo.CLASE_GRUPAL,
  gym_actividad_tipo.CLASE_PREMIUM,
  gym_actividad_tipo.PT,
];

/** Reservas que ocupan un lugar o esperan uno. */
export const RESERVAS_VIVAS: gym_reserva_estado[] = [
  gym_reserva_estado.CONFIRMADA,
  gym_reserva_estado.LISTA_ESPERA,
  gym_reserva_estado.ASISTIO,
];

/** Semanas hacia adelante que el cron deja generadas (§6: 4 semanas). */
export const HORIZONTE_DIAS = 28;

const INCLUDE = {
  sede: { select: { id: true, nombre: true } },
  sala: { select: { id: true, nombre: true, capacidad: true } },
  actividad: { select: { id: true, nombre: true, color: true, tipo: true } },
  instructor: { select: { id: true, nombre: true } },
} satisfies Prisma.gym_horarios_plantillaInclude;

type Plantilla = Prisma.gym_horarios_plantillaGetPayload<{ include: typeof INCLUDE }>;

function plano(p: Plantilla) {
  return {
    ...p,
    vigente_desde: deFecha(p.vigente_desde),
    vigente_hasta: p.vigente_hasta ? deFecha(p.vigente_hasta) : null,
    hora_fin: horaFin(p.hora_inicio, p.duracion_min),
  };
}

/**
 * Horario semanal de clases (plantilla) y las sesiones concretas que genera.
 * Las sesiones sin reservas son derivadas: si cambia el día o la hora se
 * regeneran; las que ya tienen reservas se conservan para no perder a nadie.
 */
@Injectable()
export class HorariosGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
  ) {}

  async listar(empresa_id: string, f: { sede_id?: string; incluir_inactivos?: boolean } = {}) {
    const filas = await this.prisma.gym_horarios_plantilla.findMany({
      where: { empresa_id, ...(f.incluir_inactivos ? {} : { activo: true }), ...(f.sede_id && { sede_id: f.sede_id }) },
      include: INCLUDE,
      orderBy: [{ dia_semana: 'asc' }, { hora_inicio: 'asc' }],
    });
    return filas.map(plano);
  }

  private async deEmpresa(id: string, empresa_id: string) {
    const p = await this.prisma.gym_horarios_plantilla.findFirst({ where: { id, empresa_id }, include: INCLUDE });
    if (!p) throw new NotFoundException('No se encontró el horario');
    return p;
  }

  /** Valida referencias y superposiciones; completa duración y cupo por defecto. */
  private async normalizar(
    empresa_id: string,
    d: Required<Omit<CreateHorarioGymDto, 'duracion_min' | 'cupo'>> & { duracion_min?: number; cupo?: number },
    excluirId?: string,
  ) {
    const [sede, actividad, sala, instructor] = await Promise.all([
      this.prisma.gym_sedes.findFirst({ where: { id: d.sede_id, empresa_id, activo: true }, select: { id: true } }),
      this.prisma.gym_actividades.findFirst({
        where: { id: d.actividad_id, empresa_id, activo: true },
        select: { id: true, nombre: true, tipo: true, duracion_min: true },
      }),
      d.sala_id
        ? this.prisma.gym_salas.findFirst({
            where: { id: d.sala_id, empresa_id, activo: true },
            select: { id: true, nombre: true, sede_id: true, tipo: true, capacidad: true },
          })
        : null,
      d.instructor_id
        ? this.prisma.gym_staff.findFirst({
            where: { id: d.instructor_id, empresa_id, activo: true },
            select: { id: true, nombre: true, tipo: true },
          })
        : null,
    ]);
    if (!sede) throw new BadRequestException('La sede no existe o está dada de baja');
    if (!actividad) throw new BadRequestException('La actividad no existe o está dada de baja');
    if (!ACTIVIDADES_CON_HORARIO.includes(actividad.tipo)) {
      throw new BadRequestException(
        `${actividad.nombre} no se dicta con horario: sólo las clases y el personal trainer`,
      );
    }
    if (d.sala_id && (!sala || sala.sede_id !== d.sede_id || sala.tipo !== gym_sala_tipo.SALA)) {
      throw new BadRequestException('La sala no existe, está dada de baja o no es de esa sede');
    }
    if (d.instructor_id && (!instructor || instructor.tipo !== gym_staff_tipo.INSTRUCTOR)) {
      throw new BadRequestException('El instructor no existe o está dado de baja');
    }
    const duracion_min = d.duracion_min ?? actividad.duracion_min ?? 60;
    const cupo = d.cupo ?? sala?.capacidad ?? null;
    if (!cupo) throw new BadRequestException('Indicá el cupo (la sala no tiene capacidad cargada)');
    if (d.vigente_hasta && d.vigente_hasta < d.vigente_desde)
      throw new BadRequestException('La vigencia termina antes de empezar');

    // Superposición con otro horario activo del mismo día: misma sala o mismo instructor.
    const mismoDia = await this.prisma.gym_horarios_plantilla.findMany({
      where: {
        empresa_id,
        activo: true,
        dia_semana: d.dia_semana,
        ...(excluirId && { id: { not: excluirId } }),
        OR: [
          ...(d.sala_id ? [{ sala_id: d.sala_id }] : []),
          ...(d.instructor_id ? [{ instructor_id: d.instructor_id }] : []),
        ],
      },
      include: INCLUDE,
    });
    const nuevo = { hora_inicio: d.hora_inicio, duracion_min };
    for (const otro of mismoDia) {
      const cruzaVigencia =
        (!otro.vigente_hasta || deFecha(otro.vigente_hasta) >= d.vigente_desde) &&
        (!d.vigente_hasta || d.vigente_hasta >= deFecha(otro.vigente_desde));
      if (!cruzaVigencia || !seSuperponen(nuevo, otro)) continue;
      const quien =
        d.sala_id && otro.sala_id === d.sala_id ? `la sala ${otro.sala?.nombre}` : `${otro.instructor?.nombre}`;
      throw new BadRequestException(
        `Se superpone con ${otro.actividad.nombre} de ${otro.hora_inicio} a ${horaFin(otro.hora_inicio, otro.duracion_min)} en ${quien}`,
      );
    }
    return { duracion_min, cupo };
  }

  async crear(dto: CreateHorarioGymDto, empresa_id: string, user_id?: string) {
    const d = {
      ...dto,
      sala_id: dto.sala_id ?? null,
      instructor_id: dto.instructor_id ?? null,
      vigente_desde: dto.vigente_desde ?? diaPy(),
      vigente_hasta: dto.vigente_hasta ?? null,
    };
    const { duracion_min, cupo } = await this.normalizar(empresa_id, d);
    const p = await this.prisma.gym_horarios_plantilla.create({
      data: {
        empresa_id,
        sede_id: d.sede_id,
        actividad_id: d.actividad_id,
        sala_id: d.sala_id,
        instructor_id: d.instructor_id,
        dia_semana: d.dia_semana,
        hora_inicio: d.hora_inicio,
        duracion_min,
        cupo,
        vigente_desde: aFecha(d.vigente_desde),
        vigente_hasta: d.vigente_hasta ? aFecha(d.vigente_hasta) : null,
        created_by: user_id ?? null,
      },
      include: INCLUDE,
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'CREAR',
      entity_type: 'gym_horarios_plantilla',
      entity_id: p.id,
      descripcion: `Horario de ${p.actividad.nombre} ${p.hora_inicio}`,
      new_value: plano(p),
    });
    await this.asegurarSesiones(empresa_id, diaPy(), sumarDias(diaPy(), HORIZONTE_DIAS), [p.id]);
    return plano(p);
  }

  async actualizar(id: string, dto: UpdateHorarioGymDto, empresa_id: string, user_id?: string) {
    const antes = await this.deEmpresa(id, empresa_id);
    if (!antes.activo) throw new BadRequestException('El horario está dado de baja');
    const a = plano(antes);
    const d = {
      sede_id: dto.sede_id ?? a.sede_id,
      actividad_id: dto.actividad_id ?? a.actividad_id,
      sala_id: dto.sala_id !== undefined ? dto.sala_id : a.sala_id,
      instructor_id: dto.instructor_id !== undefined ? dto.instructor_id : a.instructor_id,
      dia_semana: dto.dia_semana ?? a.dia_semana,
      hora_inicio: dto.hora_inicio ?? a.hora_inicio,
      duracion_min: dto.duracion_min ?? a.duracion_min,
      cupo: dto.cupo ?? a.cupo,
      vigente_desde: dto.vigente_desde ?? a.vigente_desde,
      vigente_hasta: dto.vigente_hasta !== undefined ? dto.vigente_hasta : a.vigente_hasta,
    };
    const { duracion_min, cupo } = await this.normalizar(empresa_id, d, id);
    const cambiaHorario =
      d.sede_id !== a.sede_id ||
      d.actividad_id !== a.actividad_id ||
      d.dia_semana !== a.dia_semana ||
      d.hora_inicio !== a.hora_inicio ||
      duracion_min !== a.duracion_min ||
      d.vigente_desde !== a.vigente_desde ||
      d.vigente_hasta !== a.vigente_hasta;

    const p = await this.prisma.gym_horarios_plantilla.update({
      where: { id },
      data: {
        sede_id: d.sede_id,
        actividad_id: d.actividad_id,
        sala_id: d.sala_id,
        instructor_id: d.instructor_id,
        dia_semana: d.dia_semana,
        hora_inicio: d.hora_inicio,
        duracion_min,
        cupo,
        vigente_desde: aFecha(d.vigente_desde),
        vigente_hasta: d.vigente_hasta ? aFecha(d.vigente_hasta) : null,
        updated_at: new Date(),
      },
      include: INCLUDE,
    });
    const conservadas = await this.ajustarFuturas(empresa_id, p, cambiaHorario);
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'EDITAR',
      entity_type: 'gym_horarios_plantilla',
      entity_id: id,
      descripcion: `Horario de ${p.actividad.nombre} ${p.hora_inicio}`,
      old_value: a,
      new_value: plano(p),
    });
    return { ...plano(p), sesiones_con_reservas_conservadas: conservadas };
  }

  /** Baja lógica: no genera más clases. Las futuras sin reservas se quitan; las que tienen reservas quedan. */
  async baja(id: string, empresa_id: string, user_id?: string) {
    const p = await this.deEmpresa(id, empresa_id);
    if (!p.activo) return { ok: true, sesiones_con_reservas_conservadas: 0 };
    await this.prisma.gym_horarios_plantilla.update({ where: { id }, data: { activo: false, updated_at: new Date() } });
    const conservadas = await this.ajustarFuturas(empresa_id, { ...p, activo: false }, true);
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'ELIMINAR',
      entity_type: 'gym_horarios_plantilla',
      entity_id: id,
      descripcion: `Baja del horario de ${p.actividad.nombre} ${p.hora_inicio}`,
    });
    return { ok: true, sesiones_con_reservas_conservadas: conservadas };
  }

  /**
   * Lleva las sesiones futuras de la plantilla a su versión actual. Si cambió el
   * horario, las que no tienen reservas se quitan y se regeneran; las que tienen
   * reservas se conservan como están (devuelve cuántas). Sala, instructor y cupo
   * se actualizan siempre.
   */
  private async ajustarFuturas(empresa_id: string, p: Plantilla, cambiaHorario: boolean): Promise<number> {
    const futuras = await this.prisma.gym_sesiones.findMany({
      where: { empresa_id, plantilla_id: p.id, estado: gym_sesion_estado.PROGRAMADA, inicio: { gt: new Date() } },
      select: { id: true, _count: { select: { gym_reservas: { where: { estado: { in: RESERVAS_VIVAS } } } } } },
    });
    const conReservas = futuras.filter((s) => s._count.gym_reservas > 0).map((s) => s.id);
    const sinReservas = futuras.filter((s) => s._count.gym_reservas === 0).map((s) => s.id);
    if (cambiaHorario && sinReservas.length) {
      // Derivadas de la plantilla y sin nadie anotado: se regeneran (ver docstring de la clase).
      await this.prisma.gym_reservas.deleteMany({
        where: { empresa_id, sesion_id: { in: sinReservas }, estado: gym_reserva_estado.CANCELADA },
      });
      await this.prisma.gym_sesiones.deleteMany({ where: { empresa_id, id: { in: sinReservas } } });
    }
    const aActualizar = cambiaHorario ? conReservas : [...conReservas, ...sinReservas];
    if (aActualizar.length) {
      await this.prisma.gym_sesiones.updateMany({
        where: { empresa_id, id: { in: aActualizar } },
        data: { sala_id: p.sala_id, instructor_id: p.instructor_id, cupo: p.cupo, updated_at: new Date() },
      });
    }
    if (p.activo) await this.asegurarSesiones(empresa_id, diaPy(), sumarDias(diaPy(), HORIZONTE_DIAS), [p.id]);
    return cambiaHorario ? conReservas.length : 0;
  }

  /**
   * Genera (idempotente) las sesiones de las plantillas activas entre `desde` y
   * `hasta`. Nunca hacia atrás: desde hoy.
   */
  async asegurarSesiones(empresa_id: string, desde: string, hasta: string, plantillaIds?: string[]): Promise<number> {
    const hoy = diaPy();
    const ini = desde < hoy ? hoy : desde;
    if (ini > hasta) return 0;
    const plantillas = await this.prisma.gym_horarios_plantilla.findMany({
      where: {
        empresa_id,
        activo: true,
        ...(plantillaIds && { id: { in: plantillaIds } }),
        vigente_desde: { lte: aFecha(hasta) },
        OR: [{ vigente_hasta: null }, { vigente_hasta: { gte: aFecha(ini) } }],
      },
    });
    const ahora = Date.now();
    const filas: Prisma.gym_sesionesCreateManyInput[] = [];
    for (const p of plantillas) {
      const dias = diasDePlantilla(
        {
          dia_semana: p.dia_semana,
          vigente_desde: deFecha(p.vigente_desde),
          vigente_hasta: p.vigente_hasta ? deFecha(p.vigente_hasta) : null,
        },
        ini,
        hasta,
      );
      for (const dia of dias) {
        const inicio = instanteDe(dia, p.hora_inicio);
        if (inicio.getTime() + p.duracion_min * 60_000 < ahora) continue;
        filas.push({
          empresa_id,
          plantilla_id: p.id,
          sede_id: p.sede_id,
          sala_id: p.sala_id,
          actividad_id: p.actividad_id,
          instructor_id: p.instructor_id,
          dia: aFecha(dia),
          inicio,
          fin: new Date(inicio.getTime() + p.duracion_min * 60_000),
          cupo: p.cupo,
        });
      }
    }
    if (!filas.length) return 0;
    // ON CONFLICT DO NOTHING contra ux_gym_sesiones_plantilla (plantilla_id, inicio).
    const r = await this.prisma.gym_sesiones.createMany({ data: filas, skipDuplicates: true });
    return r.count;
  }

  /** Cron diario: deja generadas las próximas 4 semanas de todas las empresas con horarios. */
  async asegurarTodas(): Promise<number> {
    const empresas = await this.prisma.gym_config.findMany({ select: { empresa_id: true } });
    let total = 0;
    for (const { empresa_id } of empresas)
      total += await this.asegurarSesiones(empresa_id, diaPy(), sumarDias(diaPy(), HORIZONTE_DIAS));
    return total;
  }
}
