import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import { createHmac, timingSafeEqual } from 'crypto';
import { AuditService } from 'src/audit/audit.service';
import { envs } from 'src/config/envs';
import { PrismaService } from 'src/prisma/prisma.service';
import { situacionDeAcceso } from '../common/acceso-reglas';
import { diaPy } from '../common/fechas-gym';
import { submoduloPublicoHabilitado } from '../common/submodulo-publico';
import { ESTADOS_MEMBRESIA_FUERA } from '../ventas/gym-ventas.service';
import { membresiaPlana } from './socios-gym.service';

/** Prefijo del código del QR: recepción lo reconoce cuando el lector 2D lo "tipea". */
export const PREFIJO_QR = 'GYM1';
/** Tolerancia del código: ±60 s (plan §5.1), por relojes desfasados y la cola en recepción. */
const TOLERANCIA_MS = 60_000;

function iguales(a: string, b: string): boolean {
  const x = Buffer.from(a);
  const y = Buffer.from(b);
  return x.length === y.length && timingSafeEqual(x, y);
}

/**
 * QR de acceso del socio (plan §5.1, versión sin app). El socio abre un link
 * personal (`/gym/mi-acceso?t=`) que muestra un código que cambia cada
 * `qr_rotacion_seg`: una captura de pantalla compartida deja de servir enseguida.
 * Subir `qr_version` invalida el link anterior.
 *
 * - Link:   base64url(socio_id).version.HMAC("gym-qr-link:socio:version")
 * - Código: GYM1.socio_hex.ventana.HMAC("gym-qr:socio:version:ventana")[0..16]
 */
@Injectable()
export class QrGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
  ) {}

  private hmac(texto: string): string {
    return createHmac('sha256', envs.jwtSecret).update(texto).digest('base64url');
  }

  private tokenLink(socioId: string, version: number): string {
    return `${Buffer.from(socioId).toString('base64url')}.${version}.${this.hmac(`gym-qr-link:${socioId}:${version}`)}`;
  }

  private delToken(token: string): { socioId: string; version: number } | null {
    const [a, v, firma] = (token ?? '').split('.');
    if (!a || !v || !firma) return null;
    const socioId = Buffer.from(a, 'base64url').toString();
    const version = Number(v);
    if (!/^[0-9a-f-]{36}$/i.test(socioId) || !Number.isInteger(version)) return null;
    return iguales(this.hmac(`gym-qr-link:${socioId}:${version}`), firma) ? { socioId, version } : null;
  }

  private codigo(socioId: string, version: number, ventana: number): string {
    const firma = this.hmac(`gym-qr:${socioId}:${version}:${ventana}`).slice(0, 16);
    return `${PREFIJO_QR}.${socioId.replace(/-/g, '')}.${ventana}.${firma}`;
  }

  private async socioDeEmpresa(empresa_id: string, socio_id: string) {
    const s = await this.prisma.gym_socios.findFirst({
      where: { id: socio_id, empresa_id },
      select: { id: true, numero_socio: true, qr_version: true },
    });
    if (!s) throw new NotFoundException('No se encontró el socio');
    return s;
  }

  async link(empresa_id: string, socio_id: string) {
    const s = await this.socioDeEmpresa(empresa_id, socio_id);
    return { url: `${envs.urlPanelFrontend.replace(/\/$/, '')}/gym/mi-acceso?t=${this.tokenLink(s.id, s.qr_version)}` };
  }

  /** El link anterior deja de funcionar (si el socio lo compartió o perdió el celular). */
  async regenerar(empresa_id: string, socio_id: string, user_id?: string) {
    const s = await this.socioDeEmpresa(empresa_id, socio_id);
    await this.prisma.gym_socios.update({
      where: { id: s.id },
      data: { qr_version: { increment: 1 }, updated_at: new Date() },
    });
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'EDITAR',
      entity_type: 'gym_socios',
      entity_id: s.id,
      descripcion: `Nuevo link del QR del socio N° ${s.numero_socio} (el anterior dejó de valer)`,
    });
    return this.link(empresa_id, socio_id);
  }

  /**
   * Página pública del socio. No devuelve ids ni documento: nombre, número, la
   * situación de su cuota y el código vigente.
   */
  async miAcceso(token: string, ahora = new Date()) {
    const t = this.delToken(token);
    if (!t) throw new BadRequestException('El link no es válido');
    const socio = await this.prisma.gym_socios.findUnique({
      where: { id: t.socioId },
      select: {
        id: true,
        empresa_id: true,
        numero_socio: true,
        estado: true,
        qr_version: true,
        cliente: { select: { personas: { select: { razon_social: true } } } },
        empresas: { select: { razon_social: true, nombre_fantasia: true } },
      },
    });
    if (!socio || socio.qr_version !== t.version || !(await submoduloPublicoHabilitado(this.prisma, socio.empresa_id, 'GYM_SOCIOS')))
      throw new NotFoundException('El link ya no es válido: pedile uno nuevo al gimnasio');
    const [cfg, membresias] = await Promise.all([
      this.prisma.gym_config.findUnique({ where: { empresa_id: socio.empresa_id }, select: { qr_rotacion_seg: true } }),
      this.prisma.gym_membresias.findMany({
        where: { empresa_id: socio.empresa_id, socio_id: socio.id, estado: { notIn: ESTADOS_MEMBRESIA_FUERA } },
        include: { plan: { select: { nombre: true, tipo: true } } },
      }),
    ]);
    const rota = Math.max(10, cfg?.qr_rotacion_seg ?? 30);
    const ventana = Math.floor(ahora.getTime() / (rota * 1000));
    const dia = diaPy(ahora);
    const planas = membresias.map(membresiaPlana);
    const sit = situacionDeAcceso(planas, dia);
    // Los paquetes de clases no cuentan para la cuota, pero el socio quiere ver cuántas le quedan.
    const paquetes = planas
      .filter((m) => m.creditos_totales != null && m.fecha_inicio <= dia && m.fecha_fin >= dia && m.creditos_totales > m.creditos_usados)
      .map((m) => ({ plan: m.plan.nombre, quedan: (m.creditos_totales ?? 0) - m.creditos_usados, fecha_fin: m.fecha_fin }));
    return {
      gimnasio: socio.empresas.nombre_fantasia || socio.empresas.razon_social,
      nombre: socio.cliente.personas?.razon_social ?? '',
      numero_socio: socio.numero_socio,
      estado: socio.estado,
      situacion: sit.situacion,
      dias: sit.dias,
      plan: sit.membresia?.plan.nombre ?? null,
      fecha_fin: sit.membresia?.fecha_fin ?? null,
      paquetes,
      codigo: this.codigo(socio.id, socio.qr_version, ventana),
      rota_cada_seg: rota,
      valido_hasta: new Date((ventana + 1) * rota * 1000),
    };
  }

  /** ¿El texto leído por el lector es un código de QR del gimnasio? */
  esCodigo(texto: string): boolean {
    return texto.trim().toUpperCase().startsWith(`${PREFIJO_QR}.`);
  }

  /** Socio del código leído en recepción, dentro de la empresa de quien valida. */
  async socioDelCodigo(empresa_id: string, texto: string, ahora = new Date()): Promise<string> {
    const [prefijo, hex, v, firma] = texto.trim().split('.');
    const invalido = new BadRequestException('El QR no es válido o ya venció: pedile al socio que lo abra de nuevo');
    if (prefijo?.toUpperCase() !== PREFIJO_QR || !/^[0-9a-f]{32}$/i.test(hex ?? '') || !/^\d+$/.test(v ?? '') || !firma)
      throw invalido;
    const socioId =
      `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`.toLowerCase();
    const [socio, cfg] = await Promise.all([
      this.prisma.gym_socios.findFirst({ where: { id: socioId, empresa_id }, select: { id: true, qr_version: true } }),
      this.prisma.gym_config.findUnique({ where: { empresa_id }, select: { qr_rotacion_seg: true } }),
    ]);
    if (!socio) throw invalido;
    const rota = Math.max(10, cfg?.qr_rotacion_seg ?? 30) * 1000;
    const ventana = Number(v);
    const min = Math.floor((ahora.getTime() - TOLERANCIA_MS) / rota);
    const max = Math.floor((ahora.getTime() + TOLERANCIA_MS) / rota);
    if (ventana < min || ventana > max) throw invalido;
    const esperado = this.codigo(socio.id, socio.qr_version, ventana);
    if (!iguales(esperado.split('.')[3], firma)) throw invalido;
    return socio.id;
  }
}
