import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
import { gym_aviso_estado, gym_aviso_tipo, gym_canal_aviso, gym_plan_tipo, gym_renovacion_desde, gym_socio_estado, Prisma } from '@prisma/client';
import { createHmac, timingSafeEqual } from 'crypto';
import * as nodemailer from 'nodemailer';
import { AuditService } from 'src/audit/audit.service';
import { AlertasEmpresaService } from 'src/alertas-empresa/alertas-empresa.service';
import { alertaAvisosFallo, claveAvisosFallo } from '../common/alertas-gym';
import { envs } from 'src/config';
import { EmpresasService } from 'src/empresas/empresas.service';
import { ListaPreciosService } from 'src/lista-precios/lista-precios.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { situacionDeAcceso } from '../common/acceso-reglas';
import { aFecha, deFecha, diaPy, horaPy, sumarDias } from '../common/fechas-gym';
import { membresiaPlana } from '../socios/socios-gym.service';
import { ESTADOS_MEMBRESIA_FUERA } from '../ventas/gym-ventas.service';
import {
  asuntoDesdePlantilla,
  errorPlantilla,
  htmlDesdePlantilla,
  type PlantillaAviso,
  plantillasEfectivas,
  PLANTILLAS_POR_DEFECTO,
  TEXTO_RENOVACION,
  textoSede,
  TIPOS_AVISO,
  type ValoresAviso,
  VARIABLES_AVISO,
} from './avisos-plantillas';
import { avisoQueCorresponde, fmtDiaAviso, fmtMontoAviso, MARGEN_RECUPERACION_DIAS, MAX_INTENTOS } from './avisos-reglas';
import { monedaBaseOpcional } from 'src/utils/montos-moneda';

/** Estados del log que cierran el aviso (no se reintenta). */
const CERRADOS = [gym_aviso_estado.ENVIADO, gym_aviso_estado.SIN_EMAIL, gym_aviso_estado.REBOTADO, gym_aviso_estado.BAJA];

type Correo = NonNullable<Awaited<ReturnType<EmpresasService['getCorreoEfectivo']>>>;

interface Candidato {
  membresia_id: string;
  socio_id: string;
  fecha_fin: string;
  plan: string;
  producto_id: string;
  cliente_id: string;
  nombre: string;
  email: string | null;
  sede: { nombre: string; direccion: string | null; telefono: string | null } | null;
  tipo: gym_aviso_tipo;
  dias_referencia: number;
}

/**
 * Avisos de vencimiento de la cuota por email (docs/plan-gimnasio.md §7.1 y
 * §15.8). Un aviso por membresía, tipo, canal y umbral (índice único del log).
 */
@Injectable()
export class AvisosGymService {
  private readonly logger = new Logger(AvisosGymService.name);

  constructor(
    private readonly prisma: PrismaService,
    private readonly audit: AuditService,
    private readonly empresas: EmpresasService,
    private readonly precios: ListaPreciosService,
    private readonly alertas: AlertasEmpresaService,
  ) {}

  // ── Baja de avisos (link público del email) ─────────────────────────────

  private firma(socioId: string): string {
    return createHmac('sha256', envs.jwtSecret).update(`gym-baja-avisos:${socioId}`).digest('base64url');
  }

  tokenBaja(socioId: string): string {
    return `${Buffer.from(socioId).toString('base64url')}.${this.firma(socioId)}`;
  }

  private socioDelToken(token: string): string | null {
    const [a, b] = (token ?? '').split('.');
    if (!a || !b) return null;
    const socioId = Buffer.from(a, 'base64url').toString();
    if (!/^[0-9a-f-]{36}$/i.test(socioId)) return null;
    const esperada = Buffer.from(this.firma(socioId));
    const recibida = Buffer.from(b);
    return esperada.length === recibida.length && timingSafeEqual(esperada, recibida) ? socioId : null;
  }

  linkBaja(socioId: string): string {
    return `${envs.urlPanelFrontend.replace(/\/$/, '')}/gym/baja-avisos?t=${this.tokenBaja(socioId)}`;
  }

  /** Lo llama la página pública: no devuelve ids ni datos del socio, sólo el nombre del gimnasio. */
  async bajaPublica(token: string) {
    const socioId = this.socioDelToken(token);
    if (!socioId) throw new BadRequestException('El link no es válido');
    const socio = await this.prisma.gym_socios.findUnique({
      where: { id: socioId },
      select: { id: true, empresa_id: true, acepta_avisos_email: true, empresas: { select: { razon_social: true, nombre_fantasia: true } } },
    });
    if (!socio) throw new NotFoundException('El link no es válido');
    if (socio.acepta_avisos_email) {
      await this.prisma.gym_socios.update({ where: { id: socio.id }, data: { acepta_avisos_email: false, updated_at: new Date() } });
      await this.audit.log({
        empresa_id: socio.empresa_id,
        action: 'EDITAR',
        entity_type: 'gym_socios',
        entity_id: socio.id,
        descripcion: 'El socio pidió no recibir más avisos de vencimiento (link del email)',
        old_value: { acepta_avisos_email: true },
        new_value: { acepta_avisos_email: false },
      });
    }
    return { gimnasio: socio.empresas.nombre_fantasia || socio.empresas.razon_social };
  }

  // ── Corrida del cron ────────────────────────────────────────────────────

  /** Empresas con avisos por email cuya hora de envío ya pasó hoy. */
  async procesarTodas(ahora = new Date()): Promise<number> {
    const hora = horaPy(ahora);
    const configs = await this.prisma.gym_config.findMany({
      where: { canales_aviso_vencimiento: { has: gym_canal_aviso.EMAIL }, hora_envio_avisos: { lte: hora } },
      select: { empresa_id: true },
    });
    let total = 0;
    for (const c of configs) {
      try {
        total += (await this.procesarEmpresa(c.empresa_id, diaPy(ahora))).enviados;
        await this.alertas.resolver(c.empresa_id, claveAvisosFallo, 'auto');
      } catch (err) {
        const error = (err as Error)?.message ?? String(err);
        this.logger.error(`Avisos de la empresa ${c.empresa_id}: ${error}`);
        // Una empresa que falla no frena a las demás, pero se entera por la bandeja de alertas.
        await this.alertas.registrar(alertaAvisosFallo(c.empresa_id, error));
      }
    }
    return total;
  }

  /** Procesa los avisos de hoy de una empresa. Lo usa el cron y el botón «Procesar avisos ahora». */
  async procesarEmpresa(empresa_id: string, dia: string = diaPy()) {
    const resumen = { pendientes: 0, enviados: 0, sin_email: 0, errores: 0 };
    const cfg = await this.prisma.gym_config.findUnique({ where: { empresa_id } });
    if (!cfg) return resumen;
    const pendientes = await this.candidatos(empresa_id, dia, cfg);
    resumen.pendientes = pendientes.length;
    let correo: Correo | null | undefined;
    for (const c of pendientes.slice(0, cfg.avisos_max_por_hora)) {
      if (c.email && correo === undefined) correo = await this.empresas.getCorreoEfectivo(empresa_id);
      const estado = await this.enviar(empresa_id, c, cfg, correo ?? null);
      if (estado === gym_aviso_estado.ENVIADO) resumen.enviados++;
      else if (estado === gym_aviso_estado.SIN_EMAIL) resumen.sin_email++;
      else resumen.errores++;
    }
    return resumen;
  }

  /** Membresías de acceso a las que hoy les toca un aviso que todavía no salió. */
  async candidatos(
    empresa_id: string,
    dia: string,
    cfg: { avisos_dias_antes: number[]; aviso_el_dia: boolean; avisos_dias_despues: number[] },
  ): Promise<Candidato[]> {
    const maxAntes = Math.max(0, ...cfg.avisos_dias_antes);
    const maxDespues = Math.max(0, ...cfg.avisos_dias_despues);
    const membresias = await this.prisma.gym_membresias.findMany({
      where: {
        empresa_id,
        estado: { notIn: ESTADOS_MEMBRESIA_FUERA },
        // Los pases (1 a 7 días) nacen por vencer: avisarle a quien compró un pase diario no es una renovación que buscar.
        plan: { tipo: { notIn: [gym_plan_tipo.CREDITOS, gym_plan_tipo.PASE] } },
        fecha_fin: { gte: aFecha(sumarDias(dia, -(maxDespues + MARGEN_RECUPERACION_DIAS))), lte: aFecha(sumarDias(dia, maxAntes)) },
        socio: { estado: gym_socio_estado.ACTIVO, acepta_avisos_email: true },
      },
      include: {
        plan: { select: { nombre: true, tipo: true, producto_id: true } },
        socio: {
          select: {
            id: true,
            cliente_id: true,
            email: true,
            cliente: { select: { personas: { select: { razon_social: true } } } },
            sede_base: { select: { nombre: true, direccion: true, telefono: true } },
          },
        },
        gym_avisos_log: { where: { canal: gym_canal_aviso.EMAIL }, select: { tipo: true, dias_referencia: true, estado: true, intentos: true } },
      },
    });
    if (!membresias.length) return [];
    // «Ya renovó»: tiene otra membresía de acceso que empieza después de esta.
    const otras = await this.prisma.gym_membresias.findMany({
      where: {
        empresa_id,
        socio_id: { in: [...new Set(membresias.map((m) => m.socio_id))] },
        estado: { notIn: ESTADOS_MEMBRESIA_FUERA },
        plan: { tipo: { not: gym_plan_tipo.CREDITOS } },
      },
      select: { socio_id: true, fecha_inicio: true },
    });
    const salida: Candidato[] = [];
    for (const m of membresias) {
      const renovo = otras.some((o) => o.socio_id === m.socio_id && o.fecha_inicio > m.fecha_inicio);
      if (renovo) continue;
      const aviso = avisoQueCorresponde(deFecha(m.fecha_fin), dia, cfg);
      if (!aviso) continue;
      const log = m.gym_avisos_log.find((l) => l.tipo === aviso.tipo && l.dias_referencia === aviso.dias_referencia);
      if (log && (CERRADOS.includes(log.estado as (typeof CERRADOS)[number]) || log.intentos >= MAX_INTENTOS)) continue;
      salida.push({
        membresia_id: m.id,
        socio_id: m.socio_id,
        fecha_fin: deFecha(m.fecha_fin),
        plan: m.plan.nombre,
        producto_id: m.plan.producto_id,
        cliente_id: m.socio.cliente_id,
        nombre: m.socio.cliente.personas?.razon_social ?? '',
        email: m.socio.email,
        sede: m.socio.sede_base,
        ...aviso,
      });
    }
    return salida;
  }

  /** Manda (o registra que no se pudo) un aviso. Devuelve el estado con que quedó en el log. */
  private async enviar(empresa_id: string, c: Candidato, cfg: ConfigAviso, correo: Correo | null, usuario_id?: string) {
    let estado: gym_aviso_estado = gym_aviso_estado.ENVIADO;
    let error: string | null = null;
    if (!c.email) {
      estado = gym_aviso_estado.SIN_EMAIL;
    } else if (!correo) {
      estado = gym_aviso_estado.ERROR;
      error = 'La empresa no tiene un correo configurado';
    } else {
      try {
        await this.mandar(empresa_id, c, cfg, correo);
      } catch (err) {
        estado = gym_aviso_estado.ERROR;
        error = ((err as Error)?.message ?? String(err)).slice(0, 1000);
      }
    }
    const clave = { membresia_id: c.membresia_id, tipo: c.tipo, canal: gym_canal_aviso.EMAIL, dias_referencia: c.dias_referencia };
    await this.prisma.gym_avisos_log.upsert({
      where: { membresia_id_tipo_canal_dias_referencia: clave },
      create: {
        empresa_id,
        socio_id: c.socio_id,
        ...clave,
        destino: c.email,
        estado,
        error,
        enviado_at: estado === gym_aviso_estado.ENVIADO ? new Date() : null,
        usuario_id: usuario_id ?? null,
      },
      update: {
        destino: c.email,
        estado,
        error,
        intentos: { increment: 1 },
        enviado_at: estado === gym_aviso_estado.ENVIADO ? new Date() : undefined,
        updated_at: new Date(),
        usuario_id: usuario_id ?? undefined,
      },
    });
    return estado;
  }

  private async mandar(empresa_id: string, c: Candidato, cfg: ConfigAviso, correo: Correo) {
    const [empresa, precio] = await Promise.all([
      this.nombreGimnasio(empresa_id),
      // El importe sale de la lista de precios del cliente, nunca de un monto fijo. Si no se puede leer, el envío falla
      // (queda ERROR y se reintenta) en vez de salir sin importe.
      this.precios.obtenerPrecioProducto({ productoId: c.producto_id, clienteId: c.cliente_id, empresaId: empresa_id }),
    ]);
    const moneda = precio?.moneda ?? (await monedaBaseOpcional(this.prisma, empresa_id))?.codigo ?? null;
    const monto = Number(precio?.precioFinal ?? 0);
    const valores = valoresAviso({
      tipo: c.tipo,
      nombre: c.nombre,
      plan: c.plan,
      fechaFin: c.fecha_fin,
      dias: c.dias_referencia,
      importe: monto > 0 && moneda ? fmtMontoAviso(monto, moneda) : '',
      gimnasio: empresa,
      sede: c.sede,
      renovacion: cfg.renovacion_desde,
    });
    const plantilla = plantillasEfectivas(cfg.avisos_plantillas)[c.tipo as (typeof TIPOS_AVISO)[number]];
    await this.transporte(correo).sendMail({
      from: remitente(empresa, correo),
      to: c.email,
      subject: asuntoDesdePlantilla(plantilla, valores),
      html: htmlDesdePlantilla(plantilla, valores, this.linkBaja(c.socio_id)),
    });
  }

  private transporte(correo: Correo) {
    const puerto = Number(correo.puerto) || 465;
    return nodemailer.createTransport({
      host: correo.host,
      port: puerto,
      secure: puerto === 465,
      auth: { user: correo.username, pass: correo.password },
      ...(puerto !== 465 && correo.envio_ssl ? { requireTLS: true } : {}),
      tls: { rejectUnauthorized: false },
    });
  }

  private async nombreGimnasio(empresa_id: string) {
    const e = await this.prisma.empresas.findUnique({ where: { id: empresa_id }, select: { razon_social: true, nombre_fantasia: true } });
    return e?.nombre_fantasia || e?.razon_social || 'Gimnasio';
  }

  // ── Textos editables (Configuración › Gimnasio › Reglas) ────────────────

  /** Lo que la pantalla necesita para editar los textos: los vigentes, los originales, las variables y desde qué casilla salen. */
  async textos(empresa_id: string) {
    const [cfg, empresa] = await Promise.all([
      this.prisma.gym_config.upsert({ where: { empresa_id }, create: { empresa_id }, update: {}, select: { avisos_plantillas: true } }),
      this.prisma.empresas.findUnique({ where: { id: empresa_id }, select: { usar_correo_propio: true } }),
    ]);
    const correo = await this.empresas.getCorreoEfectivo(empresa_id);
    const propia = !!(empresa?.usar_correo_propio && correo && !correo.system);
    const editadas = (cfg.avisos_plantillas && typeof cfg.avisos_plantillas === 'object' ? Object.keys(cfg.avisos_plantillas) : []).filter((t) =>
      (TIPOS_AVISO as readonly string[]).includes(t),
    );
    return {
      plantillas: plantillasEfectivas(cfg.avisos_plantillas),
      por_defecto: PLANTILLAS_POR_DEFECTO,
      editadas,
      variables: Object.entries(VARIABLES_AVISO).map(([nombre, descripcion]) => ({ nombre, descripcion })),
      // La casilla desde la que salen: la propia (se muestra) o la del sistema (no se muestra: es de Novasis). Nunca la contraseña.
      correo: propia ? { propio: true, remitente: correo!.email } : { propio: false, remitente: null },
    };
  }

  /** Con datos de ejemplo (un plan y la sede de la empresa): lo que vería el socio con este texto. */
  private async ejemplo(empresa_id: string, tipo: (typeof TIPOS_AVISO)[number]) {
    const [cfg, gimnasio, plan, sede] = await Promise.all([
      this.prisma.gym_config.upsert({ where: { empresa_id }, create: { empresa_id }, update: {}, select: { renovacion_desde: true } }),
      this.nombreGimnasio(empresa_id),
      this.prisma.gym_planes.findFirst({
        where: { empresa_id, activo: true, tipo: { in: [gym_plan_tipo.PERIODO, gym_plan_tipo.MIXTO] } },
        select: { nombre: true, producto_id: true },
        orderBy: { nombre: 'asc' },
      }),
      this.prisma.gym_sedes.findFirst({ where: { empresa_id, activo: true }, select: { nombre: true, direccion: true, telefono: true }, orderBy: { nombre: 'asc' } }),
    ]);
    let importe = '';
    if (plan) {
      try {
        const precio = await this.precios.obtenerPrecioProducto({ productoId: plan.producto_id, empresaId: empresa_id });
        const moneda = precio?.moneda ?? (await monedaBaseOpcional(this.prisma, empresa_id))?.codigo ?? null;
        const monto = Number(precio?.precioFinal ?? 0);
        if (monto > 0 && moneda) importe = fmtMontoAviso(monto, moneda);
      } catch {
        // Sin precio, la vista previa sale sin el párrafo del importe (como saldría el aviso).
      }
    }
    const dias = tipo === gym_aviso_tipo.VENCE_HOY ? 0 : 3;
    const hoy = diaPy();
    return valoresAviso({
      tipo,
      nombre: 'Juan Pérez',
      plan: plan?.nombre ?? 'Mensual',
      fechaFin: tipo === gym_aviso_tipo.POR_VENCER ? sumarDias(hoy, 3) : tipo === gym_aviso_tipo.VENCIDA ? sumarDias(hoy, -3) : hoy,
      dias,
      importe,
      gimnasio,
      sede,
      renovacion: cfg.renovacion_desde,
    });
  }

  private plantillaValida(tipo: string, p: PlantillaAviso): (typeof TIPOS_AVISO)[number] {
    if (!(TIPOS_AVISO as readonly string[]).includes(tipo)) throw new BadRequestException('Tipo de aviso inválido');
    const error = errorPlantilla(p, 'El aviso');
    if (error) throw new BadRequestException(error);
    return tipo as (typeof TIPOS_AVISO)[number];
  }

  async vistaPrevia(empresa_id: string, tipo: string, p: PlantillaAviso) {
    const t = this.plantillaValida(tipo, p);
    const valores = await this.ejemplo(empresa_id, t);
    return { asunto: asuntoDesdePlantilla(p, valores), html: htmlDesdePlantilla(p, valores, '#') };
  }

  /** Manda el aviso con datos de ejemplo a una casilla (la del usuario), desde la casilla real de la empresa. */
  async prueba(empresa_id: string, tipo: string, p: PlantillaAviso, destino: string, user_id?: string) {
    const t = this.plantillaValida(tipo, p);
    const correo = await this.empresas.getCorreoEfectivo(empresa_id);
    if (!correo) throw new BadRequestException('No hay una casilla de correo para enviar: configurala en Configuración › Correo');
    const valores = await this.ejemplo(empresa_id, t);
    try {
      await this.transporte(correo).sendMail({
        from: remitente(valores.gimnasio, correo),
        to: destino,
        subject: `[Prueba] ${asuntoDesdePlantilla(p, valores)}`,
        html: htmlDesdePlantilla(p, valores, envs.urlPanelFrontend),
      });
    } catch (err) {
      throw new BadRequestException(`No se pudo enviar la prueba: ${((err as Error)?.message ?? String(err)).slice(0, 300)}`);
    }
    await this.audit.log({
      empresa_id,
      user_id,
      action: 'EDITAR',
      entity_type: 'gym_config',
      entity_id: empresa_id,
      descripcion: `Prueba del aviso de vencimiento (${t}) enviada a ${destino}`,
    });
    return { destino, remitente: correo.system ? null : correo.email };
  }

  /** «Reenviar aviso» desde la ficha: el de la membresía de acceso actual, según su situación de hoy. */
  async reenviar(socio_id: string, empresa_id: string, usuario_id?: string) {
    const socio = await this.prisma.gym_socios.findFirst({
      where: { id: socio_id, empresa_id },
      include: {
        cliente: { select: { personas: { select: { razon_social: true } } } },
        sede_base: { select: { nombre: true, direccion: true, telefono: true } },
      },
    });
    if (!socio) throw new NotFoundException('No se encontró el socio');
    // Las mismas reglas que el envío automático (relevamiento B-1): a quien pidió no recibir avisos o está de baja no
    // se le escribe, ni a mano.
    if (!socio.acepta_avisos_email)
      throw new BadRequestException('El socio pidió no recibir avisos por email (link del aviso). Si quiere volver a recibirlos, activalo en su ficha.');
    if (socio.estado !== gym_socio_estado.ACTIVO)
      throw new BadRequestException(
        socio.estado === gym_socio_estado.BAJA ? 'El socio está dado de baja: no se le envían avisos' : 'El socio está suspendido: no se le envían avisos',
      );
    if (!socio.email) throw new BadRequestException('El socio no tiene email: cargalo en su ficha');
    const dia = diaPy();
    const membresias = (
      await this.prisma.gym_membresias.findMany({
        where: { empresa_id, socio_id, estado: { notIn: ESTADOS_MEMBRESIA_FUERA } },
        include: { plan: { select: { nombre: true, tipo: true, producto_id: true } } },
      })
    ).map(membresiaPlana);
    const sit = situacionDeAcceso(membresias, dia);
    if (!sit.membresia || sit.situacion === 'FUTURA') throw new BadRequestException(
        sit.situacion === 'FUTURA'
          ? 'El plan del socio todavía no empezó: no hay una cuota para avisar'
          : 'El socio no tiene una cuota para avisar',
      );
    const faltan = sit.situacion === 'VIGENTE' ? (sit.dias ?? 0) : -(sit.dias ?? 0);
    const tipo = faltan > 0 ? gym_aviso_tipo.POR_VENCER : faltan === 0 ? gym_aviso_tipo.VENCE_HOY : gym_aviso_tipo.VENCIDA;
    const cfg = await this.prisma.gym_config.upsert({ where: { empresa_id }, create: { empresa_id }, update: {} });
    const correo = await this.empresas.getCorreoEfectivo(empresa_id);
    const estado = await this.enviar(
      empresa_id,
      {
        membresia_id: sit.membresia.id,
        socio_id,
        fecha_fin: sit.membresia.fecha_fin,
        plan: sit.membresia.plan.nombre,
        producto_id: sit.membresia.plan.producto_id,
        cliente_id: socio.cliente_id,
        nombre: socio.cliente.personas?.razon_social ?? '',
        email: socio.email,
        sede: socio.sede_base,
        tipo,
        dias_referencia: Math.abs(faltan),
      },
      cfg,
      correo,
      usuario_id,
    );
    if (estado !== gym_aviso_estado.ENVIADO) throw new BadRequestException('No se pudo enviar el aviso: revisá el correo de la empresa en Configuración');
    return { enviado: true, destino: socio.email };
  }
}

type ConfigAviso = { renovacion_desde: gym_renovacion_desde; avisos_plantillas: Prisma.JsonValue | null };

function remitente(gimnasio: string, correo: Correo) {
  return `"${gimnasio.replace(/"/g, '')}" <${correo.email}>`;
}

/** Los valores de las variables del texto, como los lee el socio. */
export function valoresAviso(p: {
  tipo: gym_aviso_tipo;
  nombre: string;
  plan: string;
  fechaFin: string;
  dias: number;
  importe: string;
  gimnasio: string;
  sede: { nombre: string; direccion: string | null; telefono: string | null } | null;
  renovacion: gym_renovacion_desde;
}): ValoresAviso {
  return {
    nombre: p.nombre,
    plan: p.plan,
    vence: fmtDiaAviso(p.fechaFin),
    dias: String(p.dias),
    importe: p.importe,
    gimnasio: p.gimnasio,
    sede: textoSede(p.sede, p.gimnasio),
    // Solo cuando la renovación cuenta desde el vencimiento (como el texto de antes).
    renovacion: p.renovacion === gym_renovacion_desde.FIN_ANTERIOR ? TEXTO_RENOVACION : '',
  };
}
