import { BadRequestException, Injectable, Logger, Optional } from '@nestjs/common';
import { envs } from 'src/config/envs';
import { PrismaService } from 'src/prisma/prisma.service';
import { FirmaImagenService } from './firma-imagen.service';

/**
 * Firma digital de recibos con el certificado de la empresa (`docs/plan-firma-recibos.md`). La firma la hace el
 * microservicio `novasis-firmador-pdf`, en el mismo servidor; acá se decide si corresponde y se lo llama.
 *
 * Si la firma falla, el recibo sale igual SIN firma y se dice por qué: la cobranza no se frena por la firma.
 */

export type EstadoFirma = 'FIRMADO' | 'SIN_FIRMA';

export interface ResultadoFirma {
  estado: EstadoFirma;
  /** Por qué salió sin firma, para mostrarle al usuario. */
  motivo?: string;
}

export interface Firmante {
  ruc: string;
  dv: string;
}

/** Lo que el recibo A4 lleva de firma: el sello digital (con quién firmar) y/o la imagen de firma y sello (base64). */
export interface FirmasRecibo {
  firmante: Firmante | null;
  imagen: string | null;
}

/** Headers con el resultado (el panel los lee: van en `exposedHeaders` del CORS). */
export const HEADER_FIRMA = 'X-Firma-Digital';
export const HEADER_FIRMA_MOTIVO = 'X-Firma-Motivo';

/** Lo que responde el firmador cuando no puede firmar → lo que lee el usuario. */
const MOTIVOS: Record<string, string> = {
  SIN_CERTIFICADO: 'La empresa no tiene certificado digital cargado',
  CERTIFICADO_VENCIDO: 'El certificado digital de la empresa está vencido',
  CERTIFICADO_INVALIDO: 'El certificado digital de la empresa no se puede usar para firmar',
};
const MOTIVO_GENERICO = 'No se pudo firmar el recibo';
const MOTIVO_NO_RESPONDE = 'El servicio de firma digital no responde';
const TIMEOUT_MS = 15_000;

@Injectable()
export class FirmaReciboService {
  private readonly log = new Logger(FirmaReciboService.name);

  constructor(
    private readonly prisma: PrismaService,
    @Optional() private readonly imagenes?: FirmaImagenService,
  ) {}

  /** En este servidor hay firmador configurado (sin él, la opción no se puede activar). */
  static disponible(): boolean {
    return !!(envs.firmadorPdfUrl && envs.firmadorPdfKey);
  }

  /**
   * La empresa con la que se firma, o null si no corresponde: opción apagada, formato que no es A4 (el ticket se
   * imprime, no se manda) o firmador no configurado en este servidor.
   */
  async firmante(empresaId: string, formato = 'a4'): Promise<Firmante | null> {
    if (formato !== 'a4' || !FirmaReciboService.disponible()) return null;
    const e = await this.prisma.empresas.findUnique({
      where: { id: empresaId },
      select: { ruc: true, dv: true, recibo_firma_digital: true },
    });
    return e?.recibo_firma_digital ? { ruc: e.ruc, dv: e.dv } : null;
  }

  /**
   * Las dos firmas del recibo, independientes: la digital (opción + firmador) y la imagen de firma y sello. Solo A4:
   * el ticket se imprime en térmica y no lleva ninguna. Nunca lanza por la imagen.
   */
  async paraRecibo(empresaId: string, formato = 'a4'): Promise<FirmasRecibo> {
    if (formato !== 'a4') return { firmante: null, imagen: null };
    const e = await this.prisma.empresas.findUnique({
      where: { id: empresaId },
      select: { ruc: true, dv: true, recibo_firma_digital: true, recibo_firma_imagen_key: true },
    });
    if (!e) return { firmante: null, imagen: null };
    return {
      firmante: e.recibo_firma_digital && FirmaReciboService.disponible() ? { ruc: e.ruc, dv: e.dv } : null,
      imagen: (await this.imagenes?.paraRecibo(e.recibo_firma_imagen_key)) ?? null,
    };
  }

  /** Firma el PDF. Nunca lanza: si no se pudo, devuelve el PDF original con el motivo. */
  async firmar(pdf: Buffer, f: Firmante): Promise<ResultadoFirma & { pdf: Buffer }> {
    const base = (envs.firmadorPdfUrl ?? '').replace(/\/$/, '');
    const url = `${base}/api/v1/firmar?ruc=${encodeURIComponent(f.ruc)}&dv=${encodeURIComponent(f.dv)}`;
    try {
      const r = await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/pdf', 'x-firmador-key': envs.firmadorPdfKey ?? '' },
        body: new Uint8Array(pdf),
        signal: AbortSignal.timeout(TIMEOUT_MS),
      });
      if (r.ok) return { pdf: Buffer.from(await r.arrayBuffer()), estado: 'FIRMADO' };
      const cuerpo = (await r.json().catch(() => null)) as { codigo?: string } | null;
      const codigo = cuerpo?.codigo ?? `HTTP_${r.status}`;
      this.log.warn(`Recibo sin firma (RUC ${f.ruc}): ${codigo}`);
      return { pdf, estado: 'SIN_FIRMA', motivo: MOTIVOS[codigo] ?? MOTIVO_GENERICO };
    } catch (e) {
      this.log.warn(`Recibo sin firma (RUC ${f.ruc}): firmador no responde (${e instanceof Error ? e.name : 'error'})`);
      return { pdf, estado: 'SIN_FIRMA', motivo: MOTIVO_NO_RESPONDE };
    }
  }

  /** Igual que `firmar`, para los flujos que trabajan con el PDF en base64. */
  async firmarBase64(base64: string, f: Firmante): Promise<ResultadoFirma & { base64: string }> {
    const { pdf, ...resultado } = await this.firmar(Buffer.from(base64, 'base64'), f);
    return { ...resultado, base64: pdf.toString('base64') };
  }
}

/** Headers de la respuesta con el resultado de la firma (sólo si correspondía firmar). */
export function cabecerasFirma(firma?: ResultadoFirma): Record<string, string> {
  if (!firma) return {};
  return {
    [HEADER_FIRMA]: firma.estado,
    ...(firma.motivo ? { [HEADER_FIRMA_MOTIVO]: encodeURIComponent(firma.motivo) } : {}),
  };
}

/**
 * Activar la firma exige firmador en este servidor y un certificado vigente (el más nuevo; `certificados` viene del
 * más nuevo al más viejo): si no, los recibos saldrían siempre sin firma sin que nadie lo note.
 */
export function validarActivacionFirmaRecibos(
  certificados: Array<{ fecha_vencimiento: Date | string | null }> | undefined,
  disponible: boolean,
  ahora = new Date(),
) {
  if (!disponible) throw new BadRequestException('La firma digital de recibos todavía no está disponible en este servidor');
  const vence = certificados?.[0]?.fecha_vencimiento;
  if (!vence || new Date(vence) <= ahora) {
    throw new BadRequestException('Para firmar los recibos, primero cargá un certificado digital vigente');
  }
}
