import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import { gym_acceso_metodo, gym_acceso_resultado, gym_socio_estado, gym_turno_estado, Prisma } from '@prisma/client';
import { AuditService } from 'src/audit/audit.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { accesoPermitido, DecisionAcceso, decidirAcceso, RESULTADOS_PERMITIDOS, semaforoDe, situacionDeAcceso } from '../common/acceso-reglas';
import { endOfDayAsuncion, startOfDayAsuncion } from 'src/utils/utilidades';
import { aFecha, deFecha, diaPy, horaPy } from '../common/fechas-gym';
import { documentoDe } from '../common/socio-utils';
import { ReservasGymService } from '../clases/reservas-gym.service';
import { ArchivosGymService } from '../socios/archivos-gym.service';
import { QrGymService } from '../socios/qr-gym.service';
import { membresiaPlana, SociosGymService } from '../socios/socios-gym.service';
import { ESTADOS_MEMBRESIA_FUERA } from '../ventas/gym-ventas.service';
import { ForzarAccesoDto, ValidarAccesoDto } from './dto/acceso.dto';

const PERMITIDOS = [...RESULTADOS_PERMITIDOS];

/** Un turno del spa de hoy en estos estados habilita sauna y piscina a quien no es socio (decisión 26). */
const TURNO_HABILITA: gym_turno_estado[] = [gym_turno_estado.LLEGO, gym_turno_estado.EN_CURSO, gym_turno_estado.REALIZADO, gym_turno_estado.FACTURADO];
const TURNO_VIVO: gym_turno_estado[] = [gym_turno_estado.RESERVADO, ...TURNO_HABILITA];

/** Inicio y fin (UTC) del día calendario de Asunción, para filtrar timestamptz. */
export function limitesDelDia(dia: string): { gte: Date; lte: Date } {
  return { gte: startOfDayAsuncion(dia), lte: endOfDayAsuncion(dia) };
}

/**
 * Recepción: buscar al socio, validar el ingreso (semáforo), forzar un rechazo
 * con motivo y ver los ingresos del día. Cada validación queda registrada.
 */
@Injectable()
export class AccesosGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
    private readonly socios: SociosGymService,
    private readonly archivos: ArchivosGymService,
    private readonly qr: QrGymService,
    private readonly reservas: ReservasGymService,
  ) {}

  /**
   * Búsqueda rápida (el lector 2D USB escribe la CI o el número como un teclado). Devuelve los socios y, aparte, los
   * turnos del spa de hoy de esa persona que habilitan sauna y piscina (aunque no sea socio, decisión 26). `exacto`
   * marca la coincidencia por CI o número: solo esa valida directo; una parcial se elige de la lista.
   */
  async buscar(empresa_id: string, q?: string) {
    const t = q?.trim();
    if (!t || this.qr.esCodigo(t)) return { socios: [], turnos_hoy: [] };
    const [socios, turnos] = await Promise.all([
      this.prisma.gym_socios.findMany({
        where: this.socios.whereBusqueda(empresa_id, t),
        include: {
          cliente: { select: { personas: { select: { razon_social: true, nro_documento: true, ruc: true, dv: true } } } },
        },
        orderBy: [{ estado: 'asc' }, { numero_socio: 'asc' }],
        take: 10,
      }),
      this.turnosQueHabilitan(empresa_id, t),
    ]);
    return {
      socios: socios.map((s) => ({
        id: s.id,
        numero_socio: s.numero_socio,
        nombre: s.cliente.personas?.razon_social ?? '',
        documento: documentoDe(s.cliente.personas),
        estado: s.estado,
        exacto: String(s.numero_socio) === t || s.cliente.personas?.nro_documento === t || s.cliente.personas?.ruc === t,
      })),
      turnos_hoy: turnos,
    };
  }

  /** Turnos de hoy (vivos) con algún servicio que habilita el acceso del día, de la persona buscada por nombre o CI. */
  private async turnosQueHabilitan(empresa_id: string, t: string) {
    const persona: Prisma.personasWhereInput = {
      OR: [{ razon_social: { contains: t, mode: 'insensitive' } }, { nro_documento: { startsWith: t } }, { ruc: { startsWith: t } }],
    };
    const filas = await this.prisma.gym_turnos.findMany({
      where: {
        empresa_id,
        dia: aFecha(diaPy()),
        estado: { in: TURNO_VIVO },
        cliente: { personas: persona },
        items: { some: { servicio: { habilita_acceso_dia: true } } },
      },
      include: {
        cliente: { select: { personas: { select: { razon_social: true, nro_documento: true, ruc: true, dv: true } } } },
        items: { select: { inicio: true, servicio: { select: { nombre: true, habilita_acceso_dia: true } } }, orderBy: { inicio: 'asc' } },
        sede: { select: { nombre: true } },
      },
      orderBy: { inicio: 'asc' },
      take: 10,
    });
    return filas.map((x) => ({
      id: x.id,
      nombre: x.cliente.personas?.razon_social ?? '',
      documento: documentoDe(x.cliente.personas),
      socio_id: x.socio_id,
      estado: x.estado,
      hora: horaPy(x.inicio),
      sede: x.sede.nombre,
      servicios: x.items.map((i) => i.servicio.nombre),
      // Habilita cuando ya llegó (o terminó): con el turno solo reservado, primero se marca «Llegó» en el spa.
      habilita: TURNO_HABILITA.includes(x.estado),
    }));
  }

  private async sede(empresa_id: string, sede_id: string | undefined, sedeBase: string | null) {
    if (sede_id) {
      const s = await this.prisma.gym_sedes.findFirst({
        where: { id: sede_id, empresa_id, activo: true },
        select: { id: true, nombre: true },
      });
      if (!s) throw new BadRequestException('La sede no existe o está dada de baja');
      return s;
    }
    const sedes = await this.prisma.gym_sedes.findMany({
      where: { empresa_id, activo: true },
      select: { id: true, nombre: true },
      take: 2,
    });
    if (sedes.length === 1) return sedes[0];
    const base = sedes.find((s) => s.id === sedeBase);
    if (base) return base;
    throw new BadRequestException(
      sedes.length ? 'Elegí la sede de recepción' : 'Primero cargá una sede en Configuración del gimnasio',
    );
  }

  private async evaluar(empresa_id: string, socio_id: string, sede_id: string | undefined) {
    const socio = await this.prisma.gym_socios.findFirst({
      where: { id: socio_id, empresa_id },
      include: {
        cliente: { select: { personas: { select: { razon_social: true, nro_documento: true, ruc: true, dv: true } } } },
      },
    });
    if (!socio) throw new NotFoundException('No se encontró el socio');
    const sede = await this.sede(empresa_id, sede_id, socio.sede_base_id);
    const [cfg, membresias, ultimo] = await Promise.all([
      this.prisma.gym_config.upsert({ where: { empresa_id }, create: { empresa_id }, update: {} }),
      this.prisma.gym_membresias.findMany({
        where: { empresa_id, socio_id, estado: { notIn: ESTADOS_MEMBRESIA_FUERA } },
        include: {
          plan: {
            select: {
              id: true,
              nombre: true,
              tipo: true,
              producto_id: true,
              alcance_sedes: true,
              sedes_permitidas: true,
              hora_desde: true,
              hora_hasta: true,
            },
          },
        },
      }),
      this.prisma.gym_accesos.findFirst({
        where: { empresa_id, socio_id, resultado: { in: PERMITIDOS } },
        orderBy: { fecha_hora: 'desc' },
        select: { fecha_hora: true },
      }),
    ]);
    const ahora = new Date();
    const planas = membresias.map(membresiaPlana);
    const reservasHoy = await this.reservas.delSocioHoy(empresa_id, socio_id, diaPy(ahora));
    let decision = decidirAcceso({
      socio: {
        estado: socio.estado,
        sede_base_id: socio.sede_base_id,
        apto_fisico_vence: socio.apto_fisico_vence ? deFecha(socio.apto_fisico_vence) : null,
      },
      membresias: planas,
      sedeId: sede.id,
      dia: diaPy(ahora),
      hora: horaPy(ahora),
      config: cfg,
      minutosDesdeUltimoIngreso: ultimo ? (ahora.getTime() - ultimo.fecha_hora.getTime()) / 60_000 : null,
    });
    // Viene a una clase reservada que ya descontó el crédito del paquete: no se descuenta otro al entrar.
    const pagada =
      decision.consumir_credito &&
      reservasHoy.find((r) => r.credito_consumido && r.membresia_id === decision.membresia_id);
    if (pagada) {
      decision = {
        ...decision,
        consumir_credito: false,
        mensaje: `${pagada.actividad} de las ${pagada.hora}: el crédito ya se descontó al reservar`,
      };
    }
    return { socio, sede, planas, decision, dia: diaPy(ahora), reservasHoy };
  }

  private async respuesta(
    e: Awaited<ReturnType<AccesosGymService['evaluar']>>,
    decision: DecisionAcceso,
    acceso: { id: string; fecha_hora: Date } | null,
  ) {
    const sit = situacionDeAcceso(e.planas, e.dia);
    // Lo que se cobra en la caja: el plan de la membresía de acceso actual (o la última).
    const renovar = sit.membresia
      ? { plan: sit.membresia.plan.nombre, producto_id: sit.membresia.plan.producto_id }
      : null;
    const m = decision.membresia_id ? e.planas.find((x) => x.id === decision.membresia_id) : null;
    return {
      ...decision,
      registrado: !!acceso,
      acceso_id: acceso?.id ?? null,
      fecha_hora: acceso?.fecha_hora ?? null,
      sede: e.sede,
      socio: {
        id: e.socio.id,
        numero_socio: e.socio.numero_socio,
        nombre: e.socio.cliente.personas?.razon_social ?? '',
        documento: documentoDe(e.socio.cliente.personas),
        estado: e.socio.estado,
        ficha_incompleta: e.socio.ficha_incompleta,
        ...(await this.archivos.imagen(e.socio.foto_key).then((f) => ({ foto_url: f.url, foto_error: f.error }))),
      },
      membresia: m
        ? {
            id: m.id,
            plan: m.plan.nombre,
            tipo: m.plan.tipo,
            fecha_inicio: m.fecha_inicio,
            fecha_fin: m.fecha_fin,
            creditos_totales: m.creditos_totales,
            creditos_usados: m.creditos_usados + (decision.consumir_credito ? 1 : 0),
          }
        : null,
      situacion: sit.situacion,
      dias: sit.dias,
      renovar,
      reservas_hoy: e.reservasHoy.map((r) => ({ ...r, membresia_id: undefined })),
    };
  }

  async validar(dto: ValidarAccesoDto, empresa_id: string, user_id?: string) {
    const socio_id = dto.qr
      ? await this.qr.socioDelCodigo(empresa_id, dto.qr)
      : (dto.socio_id ?? (dto.documento ? await this.socioPorDocumento(empresa_id, dto.documento) : undefined));
    if (!socio_id) throw new BadRequestException('Elegí el socio');
    const e = await this.evaluar(empresa_id, socio_id, dto.sede_id);
    let decision = e.decision;
    if (dto.registrar === false) return this.respuesta(e, decision, null);

    const acceso = await this.prisma.$transaction(async (tx) => {
      if (decision.consumir_credito && decision.membresia_id) {
        // Atómico: dos validaciones simultáneas no descuentan el último crédito dos veces.
        // El día va como texto ::date: un Date de JS llega como timestamptz y la base
        // (en hora de Asunción) lo guardaría como el día anterior.
        const n = await tx.$executeRaw`
          UPDATE gym_membresias SET creditos_usados = creditos_usados + 1, ultimo_credito_fecha = ${e.dia}::date, updated_at = now()
          WHERE id = ${decision.membresia_id}::uuid AND creditos_totales IS NOT NULL AND creditos_usados < creditos_totales
            AND (ultimo_credito_fecha IS NULL OR ultimo_credito_fecha <> ${e.dia}::date)`;
        if (!n) {
          decision = {
            ...decision,
            resultado: gym_acceso_resultado.RECHAZADO_SIN_CREDITOS,
            semaforo: 'ROJO',
            mensaje: 'No le quedan créditos',
            consumir_credito: false,
          };
        }
      }
      return tx.gym_accesos.create({
        data: {
          empresa_id,
          socio_id: e.socio.id,
          membresia_id: decision.membresia_id,
          sede_id: e.sede.id,
          metodo: dto.qr ? gym_acceso_metodo.QR : gym_acceso_metodo.MANUAL,
          resultado: decision.resultado,
          dias_vencida: decision.dias_vencida,
          credito_consumido: decision.consumir_credito,
          usuario_id: user_id ?? null,
          dispositivo: dto.dispositivo ?? null,
        },
        select: { id: true, fecha_hora: true },
      });
    });
    if (accesoPermitido(decision.resultado)) await this.marcarAsistencia(empresa_id, e);
    return this.respuesta(e, decision, acceso);
  }

  /** Entró: sus clases reservadas de la próxima hora y media quedan como asistidas. Nunca frena el ingreso. */
  private async marcarAsistencia(empresa_id: string, e: Awaited<ReturnType<AccesosGymService['evaluar']>>) {
    if (!e.reservasHoy.length) return;
    try {
      await this.reservas.marcarPorIngreso(empresa_id, e.socio.id);
      e.reservasHoy = await this.reservas.delSocioHoy(empresa_id, e.socio.id, e.dia);
    } catch {
      // La asistencia se puede marcar a mano desde la agenda.
    }
  }

  /**
   * Socio por la CI exacta (tablet de ingreso: la escribe el socio). Sin
   * coincidencias parciales, para no mostrar el nombre de otro. Sin puntos ni
   * espacios; si la persona tiene RUC, también vale el número sin el DV.
   */
  private async socioPorDocumento(empresa_id: string, documento: string): Promise<string> {
    const ci = documento.replace(/[.\s]/g, '').replace(/-\d$/, '');
    const socios = await this.prisma.gym_socios.findMany({
      where: {
        empresa_id,
        cliente: { personas: { OR: [{ nro_documento: ci }, { ruc: ci }] } },
      },
      select: { id: true, estado: true },
    });
    // Si un mismo documento quedó en dos fichas (un cliente duplicado), manda la activa.
    const socio = socios.find((s) => s.estado === gym_socio_estado.ACTIVO) ?? socios[0];
    if (!socio) throw new NotFoundException('No encontramos un socio con esa cédula. Pasá por recepción.');
    return socio.id;
  }

  /** Deja entrar a un socio rechazado, con motivo (privilegio aparte, queda auditado). */
  async forzar(dto: ForzarAccesoDto, empresa_id: string, user_id?: string) {
    const e = await this.evaluar(empresa_id, dto.socio_id, dto.sede_id);
    if (e.socio.estado === gym_socio_estado.BAJA)
      throw new BadRequestException('El socio está dado de baja: reactivalo desde su ficha');
    if (accesoPermitido(e.decision.resultado)) {
      throw new BadRequestException('El socio puede entrar sin forzar: validalo con «Validar»');
    }
    const motivo = `${dto.motivo.trim()} (rechazo: ${e.decision.mensaje})`.slice(0, 500);
    const acceso = await this.prisma.gym_accesos.create({
      data: {
        empresa_id,
        socio_id: e.socio.id,
        membresia_id: e.decision.membresia_id,
        sede_id: e.sede.id,
        metodo: gym_acceso_metodo.MANUAL,
        resultado: gym_acceso_resultado.PERMITIDO_FORZADO,
        dias_vencida: e.decision.dias_vencida,
        motivo,
        usuario_id: user_id ?? null,
        dispositivo: dto.dispositivo ?? null,
      },
      select: { id: true, fecha_hora: true },
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'CREAR',
      entity_type: 'gym_accesos',
      entity_id: acceso.id,
      descripcion: `Ingreso forzado del socio N° ${e.socio.numero_socio}: ${motivo}`.slice(0, 255),
      new_value: { resultado: gym_acceso_resultado.PERMITIDO_FORZADO, rechazo: e.decision.resultado, motivo },
    });
    await this.marcarAsistencia(empresa_id, e);
    const decision: DecisionAcceso = {
      ...e.decision,
      resultado: gym_acceso_resultado.PERMITIDO_FORZADO,
      semaforo: semaforoDe(gym_acceso_resultado.PERMITIDO_FORZADO),
      mensaje: `Ingreso forzado: ${dto.motivo.trim()}`,
      consumir_credito: false,
    };
    return this.respuesta(e, decision, acceso);
  }

  /**
   * Ingresos del día (por defecto hoy) de una sede, o de todas, paginados (sin cortes en silencio), con el resumen del
   * semáforo de todo el día.
   */
  async delDia(empresa_id: string, f: { sede_id?: string; dia?: string; page?: number; limit?: number } = {}) {
    const dia = f.dia && /^\d{4}-\d{2}-\d{2}$/.test(f.dia) ? f.dia : diaPy();
    const page = Math.max(1, Math.floor(f.page ?? 1));
    const limit = Math.min(200, Math.max(1, Math.floor(f.limit ?? 50)));
    const where: Prisma.gym_accesosWhereInput = { empresa_id, fecha_hora: limitesDelDia(dia), ...(f.sede_id && { sede_id: f.sede_id }) };
    const [total, porResultado, filas] = await Promise.all([
      this.prisma.gym_accesos.count({ where: { ...where, empresa_id } }),
      this.prisma.gym_accesos.groupBy({ by: ['resultado'], where: { ...where, empresa_id }, _count: { _all: true } }),
      this.prisma.gym_accesos.findMany({
        where: { ...where, empresa_id },
        include: {
          socio: {
            select: {
              id: true,
              numero_socio: true,
              cliente: { select: { personas: { select: { razon_social: true } } } },
            },
          },
          membresia: { select: { plan: { select: { nombre: true } } } },
          sede: { select: { nombre: true } },
        },
        orderBy: { fecha_hora: 'desc' },
        skip: (page - 1) * limit,
        take: limit,
      }),
    ]);
    const resumen = { VERDE: 0, AMARILLO: 0, ROJO: 0 };
    for (const r of porResultado) resumen[semaforoDe(r.resultado)] += r._count._all;
    return {
      dia,
      total,
      page,
      limit,
      resumen,
      items: filas.map((a) => ({
        id: a.id,
        fecha_hora: a.fecha_hora,
        resultado: a.resultado,
        semaforo: semaforoDe(a.resultado),
        dias_vencida: a.dias_vencida,
        credito_consumido: a.credito_consumido,
        motivo: a.motivo,
        sede: a.sede.nombre,
        plan: a.membresia?.plan.nombre ?? null,
        socio: {
          id: a.socio.id,
          numero_socio: a.socio.numero_socio,
          nombre: a.socio.cliente.personas?.razon_social ?? '',
        },
      })),
    };
  }

}
