import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
import { gym_sala_tipo, gym_servicio_modalidad, gym_turno_estado, Prisma } from '@prisma/client';
import { AuditService } from 'src/audit/audit.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { monedaBaseOpcional } from 'src/utils/montos-moneda';
import { exigirIds, idsUnicos, lanzarSiHayErrores } from '../common/gym-utils';
import { ProductoGymService } from '../common/producto-gym.service';
import { erroresServicio } from '../common/reglas';
import { CreateServicioGymDto, UpdateServicioGymDto } from './dto/catalogo.dto';

const INCLUDE = {
  producto: { select: { id: true, descripcion: true, cod_producto: true, precio: true } },
  actividad: { select: { id: true, nombre: true, tipo: true } },
} satisfies Prisma.gym_serviciosInclude;

/** Lo que no aplica a la modalidad se guarda vacío. */
function normalizarPorModalidad(s: {
  modalidad: gym_servicio_modalidad;
  duracion_min: number | null;
  unidad_tiempo_min: number | null;
  capacidad_simultanea: number | null;
  requiere_profesional: boolean;
  fraccion_minima: number;
  paga_profesional: boolean;
  habilita_acceso_dia: boolean;
  sala_ids: string[];
}) {
  const conAgenda = s.modalidad === gym_servicio_modalidad.TURNO || s.modalidad === gym_servicio_modalidad.CLASE;
  const porTiempo = s.modalidad === gym_servicio_modalidad.POR_TIEMPO;
  return {
    duracion_min: conAgenda ? s.duracion_min : null,
    unidad_tiempo_min: porTiempo ? s.unidad_tiempo_min : null,
    capacidad_simultanea: porTiempo ? s.capacidad_simultanea : null,
    requiere_profesional: s.modalidad === gym_servicio_modalidad.TURNO ? s.requiere_profesional : false,
    // Cantidad fraccionada, pago a la profesional y acceso del día son del spa (turnos).
    fraccion_minima: s.modalidad === gym_servicio_modalidad.TURNO ? s.fraccion_minima : 1,
    paga_profesional: s.modalidad === gym_servicio_modalidad.TURNO ? s.paga_profesional : false,
    habilita_acceso_dia: s.modalidad === gym_servicio_modalidad.TURNO ? s.habilita_acceso_dia : false,
    sala_ids: conAgenda ? s.sala_ids : [],
  };
}

/**
 * Servicios adicionales (masajes, sauna por hora, clase suelta), vendidos en el POS
 * como su producto. Los paquetes de clases son planes de tipo CREDITOS.
 */
@Injectable()
export class ServiciosGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
    private readonly productoGym: ProductoGymService,
  ) {}

  /** El precio es el del producto, en la moneda base de la empresa: cada servicio la trae para rotularlo. */
  async listar(empresa_id: string, incluir_inactivos = false) {
    const [servicios, moneda] = await Promise.all([
      this.prisma.gym_servicios.findMany({
        where: { empresa_id, ...(incluir_inactivos ? {} : { activo: true }) },
        include: INCLUDE,
        orderBy: [{ activo: 'desc' }, { nombre: 'asc' }],
      }),
      monedaBaseOpcional(this.prisma, empresa_id),
    ]);
    return servicios.map((s) => ({ ...s, moneda }));
  }

  private async deEmpresa(id: string, empresa_id: string) {
    const s = await this.prisma.gym_servicios.findFirst({ where: { id, empresa_id }, include: INCLUDE });
    if (!s) throw new NotFoundException('Servicio no encontrado');
    return s;
  }

  private async validarReferencias(empresa_id: string, s: { actividad_id: string | null; sala_ids: string[]; modalidad: gym_servicio_modalidad }) {
    if (s.actividad_id) {
      const a = await this.prisma.gym_actividades.findFirst({
        where: { id: s.actividad_id, empresa_id, activo: true },
        select: { id: true },
      });
      if (!a) throw new BadRequestException('La actividad no existe o está dada de baja');
    }
    await exigirIds(
      s.sala_ids,
      (ids) => this.prisma.gym_salas.findMany({ where: { empresa_id, activo: true, id: { in: ids } }, select: { id: true } }),
      'Alguna de las salas o cabinas elegidas no existe o está dada de baja',
    );
    // Un turno ocupa una cabina (o un recurso de una persona); una clase, una sala con cupo (relevamiento C 2.6#11).
    if (s.sala_ids.length && (s.modalidad === gym_servicio_modalidad.TURNO || s.modalidad === gym_servicio_modalidad.CLASE)) {
      const salas = await this.prisma.gym_salas.findMany({ where: { empresa_id, id: { in: s.sala_ids } }, select: { nombre: true, tipo: true } });
      const mal = salas.filter((x) => (s.modalidad === gym_servicio_modalidad.CLASE) !== (x.tipo === gym_sala_tipo.SALA));
      if (mal.length)
        throw new BadRequestException(
          s.modalidad === gym_servicio_modalidad.CLASE
            ? `Una clase va en una sala de clases: ${mal.map((x) => x.nombre).join(', ')} no lo es`
            : `Un turno va en una cabina: ${mal.map((x) => x.nombre).join(', ')} es una sala de clases`,
        );
    }
  }

  private async validarNombre(empresa_id: string, nombre: string, excepto?: string) {
    const otro = await this.prisma.gym_servicios.findFirst({
      where: {
        empresa_id,
        activo: true,
        nombre: { equals: nombre, mode: 'insensitive' },
        ...(excepto && { id: { not: excepto } }),
      },
      select: { id: true },
    });
    if (otro) throw new ConflictException(`Ya existe el servicio "${nombre}"`);
  }

  async crear(dto: CreateServicioGymDto, empresa_id: string, user_id?: string) {
    const nombre = dto.nombre.trim();
    const base = {
      modalidad: dto.modalidad,
      actividad_id: dto.actividad_id ?? null,
      duracion_min: dto.duracion_min ?? null,
      unidad_tiempo_min: dto.unidad_tiempo_min ?? null,
      capacidad_simultanea: dto.capacidad_simultanea ?? null,
      requiere_profesional: dto.requiere_profesional ?? false,
      fraccion_minima: dto.fraccion_minima ?? 1,
      paga_profesional: dto.paga_profesional ?? false,
      habilita_acceso_dia: dto.habilita_acceso_dia ?? false,
      sala_ids: idsUnicos(dto.sala_ids),
    };
    lanzarSiHayErrores(erroresServicio(base));
    await this.validarNombre(empresa_id, nombre);
    await this.validarReferencias(empresa_id, base);

    let producto_id = dto.producto_id;
    if (producto_id) {
      await this.productoGym.validarExistente(producto_id, empresa_id);
      await this.productoGym.validarLibre(producto_id, empresa_id);
    } else {
      if (dto.precio == null) throw new BadRequestException('Indicá el precio del servicio (o elegí un producto existente)');
      producto_id = await this.productoGym.crear(nombre, dto.precio, empresa_id, user_id);
    }

    const servicio = await this.prisma.gym_servicios.create({
      data: { empresa_id, producto_id, nombre, ...base, ...normalizarPorModalidad(base), created_by: user_id ?? null },
      include: INCLUDE,
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'CREAR',
      entity_type: 'gym_servicio',
      entity_id: servicio.id,
      new_value: servicio,
    });
    return servicio;
  }

  async actualizar(id: string, dto: UpdateServicioGymDto, empresa_id: string, user_id?: string) {
    const anterior = await this.deEmpresa(id, empresa_id);
    if (!anterior.activo) throw new ConflictException('El servicio está dado de baja');
    const nombre = dto.nombre?.trim();
    if (nombre && nombre.toLowerCase() !== anterior.nombre.toLowerCase()) await this.validarNombre(empresa_id, nombre, id);

    const merged = {
      modalidad: dto.modalidad ?? anterior.modalidad,
      actividad_id: dto.actividad_id !== undefined ? dto.actividad_id : anterior.actividad_id,
      duracion_min: dto.duracion_min !== undefined ? dto.duracion_min : anterior.duracion_min,
      unidad_tiempo_min: dto.unidad_tiempo_min !== undefined ? dto.unidad_tiempo_min : anterior.unidad_tiempo_min,
      capacidad_simultanea: dto.capacidad_simultanea !== undefined ? dto.capacidad_simultanea : anterior.capacidad_simultanea,
      requiere_profesional: dto.requiere_profesional ?? anterior.requiere_profesional,
      fraccion_minima: dto.fraccion_minima ?? Number(anterior.fraccion_minima),
      paga_profesional: dto.paga_profesional ?? anterior.paga_profesional,
      habilita_acceso_dia: dto.habilita_acceso_dia ?? anterior.habilita_acceso_dia,
      sala_ids: dto.sala_ids ? idsUnicos(dto.sala_ids) : anterior.sala_ids,
    };
    lanzarSiHayErrores(erroresServicio(merged));
    await this.validarReferencias(empresa_id, merged);

    if (dto.precio != null && Number(dto.precio) !== Number(anterior.producto.precio ?? 0)) {
      await this.productoGym.actualizarPrecio(anterior.producto_id, dto.precio, empresa_id, user_id);
    }
    if (nombre && nombre !== anterior.nombre && anterior.producto.descripcion === anterior.nombre) {
      await this.productoGym.renombrar(anterior.producto_id, nombre, empresa_id, user_id);
    }

    const servicio = await this.prisma.gym_servicios.update({
      where: { id },
      data: { ...(nombre && { nombre }), ...merged, ...normalizarPorModalidad(merged), updated_at: new Date() },
      include: INCLUDE,
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'EDITAR',
      entity_type: 'gym_servicio',
      entity_id: id,
      old_value: anterior,
      new_value: servicio,
    });
    return servicio;
  }

  /** Un servicio que atiende un profesional activo, o con turnos reservados, no se da de baja. */
  async darDeBaja(id: string, empresa_id: string, user_id?: string) {
    const servicio = await this.deEmpresa(id, empresa_id);
    if (!servicio.activo) return servicio;
    const staff = await this.prisma.gym_staff.findFirst({
      where: { empresa_id, activo: true, servicio_ids: { has: id } },
      select: { nombre: true },
    });
    if (staff) throw new ConflictException(`Lo atiende ${staff.nombre}: quitalo de su ficha 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, servicio_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_servicios.update({
      where: { id },
      data: { activo: false, updated_at: new Date() },
      include: INCLUDE,
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'ELIMINAR',
      entity_type: 'gym_servicio',
      entity_id: id,
      old_value: servicio,
    });
    return baja;
  }

  /** Vuelve a ofrecer un servicio dado de baja: su actividad y sus salas tienen que seguir activas. */
  async reactivar(id: string, empresa_id: string, user_id?: string) {
    const servicio = await this.deEmpresa(id, empresa_id);
    if (servicio.activo) return servicio;
    await this.validarNombre(empresa_id, servicio.nombre, id);
    await this.validarReferencias(empresa_id, servicio);
    const alta = await this.prisma.gym_servicios.update({ where: { id }, data: { activo: true, updated_at: new Date() }, include: INCLUDE });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'REACTIVAR',
      entity_type: 'gym_servicio',
      entity_id: id,
      old_value: servicio,
      new_value: alta,
    });
    return alta;
  }
}
