import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
import { gym_turno_estado, Prisma } from '@prisma/client';
import { AuditService } from 'src/audit/audit.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { textoONull } from '../common/gym-utils';
import { HORA_RE, minutosDelDia } from '../common/reglas';
import { CreateSalaGymDto, CreateSedeGymDto, UpdateSalaGymDto, UpdateSedeGymDto } from './dto/sede.dto';
import { exigirSinHorariosActivos } from '../common/uso-horarios';

const DIAS = ['lun', 'mar', 'mie', 'jue', 'vie', 'sab', 'dom'] as const;

/** Horario por día: cada día es null (cerrado) o { abre, cierra } en HH:MM. */
export function erroresHorario(horario: Record<string, unknown> | null | undefined): string[] {
  if (!horario) return [];
  const errores: string[] = [];
  for (const [dia, valor] of Object.entries(horario)) {
    if (!(DIAS as readonly string[]).includes(dia)) {
      errores.push(`Día desconocido en el horario: ${dia}`);
      continue;
    }
    if (valor === null) continue;
    const v = valor as { abre?: unknown; cierra?: unknown };
    if (typeof v.abre !== 'string' || typeof v.cierra !== 'string' || !HORA_RE.test(v.abre) || !HORA_RE.test(v.cierra)) {
      errores.push(`Horario del ${dia}: las horas van en formato HH:MM`);
    } else if (minutosDelDia(v.abre) >= minutosDelDia(v.cierra)) {
      errores.push(`Horario del ${dia}: la apertura tiene que ser anterior al cierre`);
    }
  }
  return errores;
}

/**
 * Sedes (sucursal del ERP + caja + depósito) y sus salas y cabinas.
 * Nada se borra: la baja es lógica, como en el resto del ERP.
 */
@Injectable()
export class SedesGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
  ) {}

  listar(empresa_id: string, incluir_inactivas = false) {
    return this.prisma.gym_sedes.findMany({
      where: { empresa_id, ...(incluir_inactivas ? {} : { activo: true }) },
      include: {
        sucursal: { select: { id: true, descripcion: true } },
        deposito: { select: { id: true, descripcion: true } },
        caja: { select: { id: true, descripcion: true } },
        // Con las bajas, también las salas dadas de baja (para reactivarlas).
        gym_salas: { where: incluir_inactivas ? {} : { activo: true }, orderBy: [{ activo: 'desc' }, { tipo: 'asc' }, { nombre: 'asc' }] },
      },
      orderBy: [{ activo: 'desc' }, { nombre: 'asc' }],
    });
  }

  /** Sucursales, depósitos y cajas de la empresa, para elegir al crear una sede. */
  async opciones(empresa_id: string) {
    const [sucursales, depositos, cajas] = await Promise.all([
      this.prisma.empresas_sucursales.findMany({
        where: { empresa_id, active: true },
        select: { id: true, descripcion: true },
        orderBy: { descripcion: 'asc' },
      }),
      this.prisma.depositos.findMany({
        where: { empresa_id, active: true },
        select: { id: true, descripcion: true, sucursal_id: true, es_principal: true },
        orderBy: { descripcion: 'asc' },
      }),
      this.prisma.cajas.findMany({
        where: { empresa_id, estado: true },
        select: { id: true, descripcion: true, sucursal_id: true },
        orderBy: { descripcion: 'asc' },
      }),
    ]);
    return { sucursales, depositos, cajas };
  }

  private async sedeDeEmpresa(id: string, empresa_id: string) {
    const sede = await this.prisma.gym_sedes.findFirst({ where: { id, empresa_id } });
    if (!sede) throw new NotFoundException('Sede no encontrada');
    return sede;
  }

  /** Sucursal, depósito y caja tienen que ser de la empresa y estar en la misma sucursal. */
  private async validarReferencias(
    empresa_id: string,
    sucursal_id: string,
    deposito_id: string | null | undefined,
    caja_id: string | null | undefined,
  ) {
    const sucursal = await this.prisma.empresas_sucursales.findFirst({
      where: { id: sucursal_id, empresa_id, active: true },
      select: { id: true },
    });
    if (!sucursal) throw new BadRequestException('La sucursal no existe en esta empresa o está inactiva');
    if (deposito_id) {
      const dep = await this.prisma.depositos.findFirst({
        where: { id: deposito_id, empresa_id, active: true },
        select: { sucursal_id: true },
      });
      if (!dep) throw new BadRequestException('El depósito no existe en esta empresa o está inactivo');
      if (dep.sucursal_id !== sucursal_id) throw new BadRequestException('El depósito tiene que ser de la sucursal de la sede');
    }
    if (caja_id) {
      const caja = await this.prisma.cajas.findFirst({
        where: { id: caja_id, empresa_id, estado: true },
        select: { sucursal_id: true },
      });
      if (!caja) throw new BadRequestException('La caja no existe en esta empresa o está inactiva');
      if (caja.sucursal_id !== sucursal_id) throw new BadRequestException('La caja tiene que ser de la sucursal de la sede');
    }
  }

  private async validarSucursalLibre(empresa_id: string, sucursal_id: string, excepto?: string) {
    const otra = await this.prisma.gym_sedes.findFirst({
      where: { empresa_id, sucursal_id, activo: true, ...(excepto && { id: { not: excepto } }) },
      select: { nombre: true },
    });
    if (otra) throw new ConflictException(`Esa sucursal ya es la sede "${otra.nombre}"`);
  }

  async crear(dto: CreateSedeGymDto, empresa_id: string, user_id?: string) {
    const errores = erroresHorario(dto.horario_apertura);
    if (errores.length) throw new BadRequestException(errores);
    await this.validarReferencias(empresa_id, dto.sucursal_id, dto.deposito_id, dto.caja_id);
    await this.validarSucursalLibre(empresa_id, dto.sucursal_id);

    const sede = await this.prisma.gym_sedes.create({
      data: {
        empresa_id,
        nombre: dto.nombre.trim(),
        sucursal_id: dto.sucursal_id,
        deposito_id: dto.deposito_id ?? null,
        caja_id: dto.caja_id ?? null,
        direccion: textoONull(dto.direccion),
        telefono: textoONull(dto.telefono),
        horario_apertura: (dto.horario_apertura ?? Prisma.JsonNull) as Prisma.InputJsonValue,
        capacidad_maxima: dto.capacidad_maxima ?? null,
        created_by: user_id ?? null,
      },
    });
    await this.audit.log({ empresa_id, user_id, action: 'CREAR', entity_type: 'gym_sede', entity_id: sede.id, new_value: sede });
    return sede;
  }

  async actualizar(id: string, dto: UpdateSedeGymDto, empresa_id: string, user_id?: string) {
    const anterior = await this.sedeDeEmpresa(id, empresa_id);
    if (!anterior.activo) throw new ConflictException('La sede está dada de baja');
    const errores = erroresHorario(dto.horario_apertura);
    if (errores.length) throw new BadRequestException(errores);

    const sucursal_id = dto.sucursal_id ?? anterior.sucursal_id;
    const deposito_id = dto.deposito_id !== undefined ? dto.deposito_id : anterior.deposito_id;
    const caja_id = dto.caja_id !== undefined ? dto.caja_id : anterior.caja_id;
    await this.validarReferencias(empresa_id, sucursal_id, deposito_id, caja_id);
    if (sucursal_id !== anterior.sucursal_id) await this.validarSucursalLibre(empresa_id, sucursal_id, id);

    const sede = await this.prisma.gym_sedes.update({
      where: { id },
      data: {
        ...(dto.nombre !== undefined && { nombre: dto.nombre.trim() }),
        sucursal_id,
        deposito_id,
        caja_id,
        ...(dto.direccion !== undefined && { direccion: textoONull(dto.direccion) }),
        ...(dto.telefono !== undefined && { telefono: textoONull(dto.telefono) }),
        ...(dto.horario_apertura !== undefined && {
          horario_apertura: (dto.horario_apertura ?? Prisma.JsonNull) as Prisma.InputJsonValue,
        }),
        ...(dto.capacidad_maxima !== undefined && { capacidad_maxima: dto.capacidad_maxima }),
        updated_at: new Date(),
      },
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'EDITAR',
      entity_type: 'gym_sede',
      entity_id: id,
      old_value: anterior,
      new_value: sede,
    });
    return sede;
  }

  /** Una sede con salas activas no se da de baja: primero sus salas. */
  async darDeBaja(id: string, empresa_id: string, user_id?: string) {
    const sede = await this.sedeDeEmpresa(id, empresa_id);
    if (!sede.activo) return sede;
    const salas = await this.prisma.gym_salas.count({ where: { empresa_id, sede_id: id, activo: true } });
    if (salas > 0) throw new ConflictException(`La sede tiene ${salas} sala(s) o cabina(s) activas: dalas de baja primero`);
    await exigirSinHorariosActivos(this.prisma, empresa_id, { sede_id: id }, 'dalos de baja primero');
    const baja = await this.prisma.gym_sedes.update({ where: { id }, data: { activo: false, updated_at: new Date() } });
    await this.audit.log({ empresa_id, user_id, action: 'ELIMINAR', entity_type: 'gym_sede', entity_id: id, old_value: sede });
    return baja;
  }

  // -------------------------------------------------------------- salas

  private async salaDeEmpresa(id: string, empresa_id: string) {
    const sala = await this.prisma.gym_salas.findFirst({ where: { id, empresa_id } });
    if (!sala) throw new NotFoundException('Sala no encontrada');
    return sala;
  }

  private async validarNombreSala(empresa_id: string, sede_id: string, nombre: string, excepto?: string) {
    const otra = await this.prisma.gym_salas.findFirst({
      where: {
        empresa_id,
        sede_id,
        activo: true,
        nombre: { equals: nombre, mode: 'insensitive' },
        ...(excepto && { id: { not: excepto } }),
      },
      select: { id: true },
    });
    if (otra) throw new ConflictException(`Ya hay una sala o cabina llamada "${nombre}" en la sede`);
  }

  async crearSala(sede_id: string, dto: CreateSalaGymDto, empresa_id: string, user_id?: string) {
    const sede = await this.sedeDeEmpresa(sede_id, empresa_id);
    if (!sede.activo) throw new ConflictException('La sede está dada de baja');
    const nombre = dto.nombre.trim();
    await this.validarNombreSala(empresa_id, sede_id, nombre);
    const sala = await this.prisma.gym_salas.create({
      data: {
        empresa_id,
        sede_id,
        nombre,
        tipo: dto.tipo,
        capacidad: dto.capacidad ?? null,
        created_by: user_id ?? null,
      },
    });
    await this.audit.log({ empresa_id, user_id, action: 'CREAR', entity_type: 'gym_sala', entity_id: sala.id, new_value: sala });
    return sala;
  }

  async actualizarSala(id: string, dto: UpdateSalaGymDto, empresa_id: string, user_id?: string) {
    const anterior = await this.salaDeEmpresa(id, empresa_id);
    if (!anterior.activo) throw new ConflictException('La sala está dada de baja');
    const nombre = dto.nombre?.trim();
    if (nombre && nombre.toLowerCase() !== anterior.nombre.toLowerCase()) {
      await this.validarNombreSala(empresa_id, anterior.sede_id, nombre, id);
    }
    // Cambiar el tipo (sala de clases ↔ cabina) deja colgados a quienes la usan con el tipo anterior (relevamiento C 1.6#8).
    if (dto.tipo && dto.tipo !== anterior.tipo) await this.exigirSalaSinUso(id, empresa_id, 'cambiar el tipo');
    const sala = await this.prisma.gym_salas.update({
      where: { id },
      data: {
        ...(nombre && { nombre }),
        ...(dto.tipo && { tipo: dto.tipo }),
        ...(dto.capacidad !== undefined && { capacidad: dto.capacidad }),
        updated_at: new Date(),
      },
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'EDITAR',
      entity_type: 'gym_sala',
      entity_id: id,
      old_value: anterior,
      new_value: sala,
    });
    return sala;
  }

  /** Servicios activos, turnos reservados y horarios de clases que usan la sala: con alguno no se le cambia el tipo. */
  private async exigirSalaSinUso(id: string, empresa_id: string, accion: string) {
    const servicio = await this.prisma.gym_servicios.findFirst({
      where: { empresa_id, activo: true, sala_ids: { has: id } },
      select: { nombre: true },
    });
    if (servicio) throw new ConflictException(`Para ${accion}, quitala primero del servicio "${servicio.nombre}"`);
    const turnos = await this.prisma.gym_turno_items.count({
      // Turnos que todavía no empezaron (reservado o llegó) y no terminaron.
      where: { empresa_id, sala_id: id, fin: { gte: new Date() }, turno: { estado: { in: [gym_turno_estado.RESERVADO, gym_turno_estado.LLEGO, gym_turno_estado.EN_CURSO] } } },
    });
    if (turnos) throw new ConflictException(`Para ${accion}, cancelá o reprogramá primero sus turnos reservados (${turnos})`);
    await exigirSinHorariosActivos(this.prisma, empresa_id, { sala_id: id }, `para ${accion}, pasalos a otra sala primero`);
  }

  /** Una sala que usa un servicio activo, o con turnos reservados, no se da de baja. */
  async darDeBajaSala(id: string, empresa_id: string, user_id?: string) {
    const sala = await this.salaDeEmpresa(id, empresa_id);
    if (!sala.activo) return sala;
    const servicio = await this.prisma.gym_servicios.findFirst({
      where: { empresa_id, activo: true, sala_ids: { has: id } },
      select: { nombre: true },
    });
    if (servicio) throw new ConflictException(`La usa el servicio "${servicio.nombre}": quitala de ese servicio primero`);
    await exigirSinHorariosActivos(this.prisma, empresa_id, { sala_id: id }, 'pasá esos horarios a otra sala o dalos de baja primero');
    const turnos = await this.prisma.gym_turno_items.count({
      // Turnos que todavía no empezaron (reservado o llegó) y no terminaron.
      where: { empresa_id, sala_id: id, fin: { gte: new Date() }, turno: { estado: { in: [gym_turno_estado.RESERVADO, gym_turno_estado.LLEGO, gym_turno_estado.EN_CURSO] } } },
    });
    if (turnos)
      throw new ConflictException(
        `Tiene ${turnos === 1 ? 'un turno reservado' : `${turnos} turnos reservados`}: cancelalos o reprogramalos primero (Turnos)`,
      );
    const baja = await this.prisma.gym_salas.update({ where: { id }, data: { activo: false, updated_at: new Date() } });
    await this.audit.log({ empresa_id, user_id, action: 'ELIMINAR', entity_type: 'gym_sala', entity_id: id, old_value: sala });
    return baja;
  }

  /** Vuelve a habilitar una sede dada de baja: su sucursal no puede ser otra sede activa y caja y depósito siguen valiendo. */
  async reactivar(id: string, empresa_id: string, user_id?: string) {
    const sede = await this.sedeDeEmpresa(id, empresa_id);
    if (sede.activo) return sede;
    await this.validarSucursalLibre(empresa_id, sede.sucursal_id, id);
    await this.validarReferencias(empresa_id, sede.sucursal_id, sede.deposito_id, sede.caja_id);
    const alta = await this.prisma.gym_sedes.update({ where: { id }, data: { activo: true, updated_at: new Date() } });
    await this.audit.log({ empresa_id, user_id, action: 'REACTIVAR', entity_type: 'gym_sede', entity_id: id, old_value: sede, new_value: alta });
    return alta;
  }

  /** Vuelve a habilitar una sala dada de baja: su sede tiene que estar activa y el nombre libre en la sede. */
  async reactivarSala(id: string, empresa_id: string, user_id?: string) {
    const sala = await this.salaDeEmpresa(id, empresa_id);
    if (sala.activo) return sala;
    const sede = await this.sedeDeEmpresa(sala.sede_id, empresa_id);
    if (!sede.activo) throw new ConflictException('La sede está dada de baja: reactivala primero');
    await this.validarNombreSala(empresa_id, sala.sede_id, sala.nombre, id);
    const alta = await this.prisma.gym_salas.update({ where: { id }, data: { activo: true, updated_at: new Date() } });
    await this.audit.log({ empresa_id, user_id, action: 'REACTIVAR', entity_type: 'gym_sala', entity_id: id, old_value: sala, new_value: alta });
    return alta;
  }
}
