import { ForbiddenException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import type { Prisma } from '@prisma/client';
import { EstadoAutorizacionCaja } from './dto/crear-autorizacion.dto';
import { tieneAlgunPrivilegio } from 'src/auth/guards/algun-privilegio.guard';
import { PRIVILEGIO_PIN_SUPERVISOR } from 'src/seguridad/privilegio-pin-supervisor';
import type { PrismaService } from 'src/prisma/prisma.service';

/**
 * Autorización de supervisor (PIN presencial o aprobada en remoto) que viaja
 * como token: una sola regla para todas las operaciones que la exigen (caja,
 * anulación de ventas, depósitos). El token se verifica (tipo, empresa y
 * operación) y, cuando la operación ya pasó sus validaciones, la fila de
 * `autorizaciones_caja` que nombra se marca «utilizada»: no sirve dos veces.
 */
export type PayloadAutorizacion = {
  sub: string;
  tipo: string;
  empresa_id: string;
  operacion: string;
  autorizacion_id?: string;
  contexto?: Record<string, unknown>;
};

/** Vigencia del token de autorización (segundos). */
export const TOKEN_AUTORIZACION_TTL_SEG = 30;

/**
 * Operación que lleva el token según el TIPO de la solicitud de autorización,
 * cuando no coinciden. La autorización remota de una anulación se pide como
 * `anulacion_venta`, pero quien la consume (y el PIN presencial) usa la
 * operación `anulacion`. Un solo lugar: todo tipo que no figure acá firma su
 * propio nombre.
 */
export const OPERACION_POR_TIPO: Record<string, string> = {
  anulacion_venta: 'anulacion',
};

export const operacionDeTipo = (tipo: string): string => OPERACION_POR_TIPO[tipo] ?? tipo;

/** Firma el token de 30 s que habilita la operación autorizada (una sola definición para aprobar y para el polling). */
export function firmarTokenAutorizacion(
  jwt: Pick<JwtService, 'signAsync'>,
  args: { autorizador_id: string; autorizacion_id: string; operacion: string; empresa_id: string },
): Promise<string> {
  return jwt.signAsync(
    {
      sub: args.autorizador_id,
      tipo: 'autorizacion_caja',
      autorizacion_id: args.autorizacion_id,
      operacion: operacionDeTipo(args.operacion),
      empresa_id: args.empresa_id,
    },
    { expiresIn: `${TOKEN_AUTORIZACION_TTL_SEG}s`, secret: process.env.JWT_SECRET },
  );
}

type Verificador = Pick<JwtService, 'verifyAsync'>;

export async function verificarTokenAutorizacion(
  token: string,
  operacionEsperada: string,
  empresa_id: string,
  jwt: Verificador = new JwtService({}),
): Promise<PayloadAutorizacion> {
  try {
    const payload = await jwt.verifyAsync<PayloadAutorizacion>(token, { secret: process.env.JWT_SECRET });
    if (payload.tipo !== 'autorizacion_caja') throw new ForbiddenException('Token no es de autorización');
    if (payload.empresa_id !== empresa_id) throw new ForbiddenException('Token no corresponde a esta empresa');
    // Sin esto, un PIN dado para un descuento servía para abrir o cerrar una caja.
    if (payload.operacion !== operacionEsperada) {
      throw new ForbiddenException('La autorización del supervisor fue para otra operación: pedila de nuevo.');
    }
    return payload;
  } catch (error) {
    if (error instanceof ForbiddenException) throw error;
    throw new ForbiddenException('Token de autorización inválido o expirado');
  }
}

/**
 * Marca «utilizada» la autorización del token. Con `tx`, dentro de la misma
 * transacción que la operación: si la operación falla, la autorización no se
 * gasta. Un token ya usado da 403.
 */
export async function consumirAutorizacion(
  tx: Pick<Prisma.TransactionClient, 'autorizaciones_caja'>,
  payload: { autorizacion_id?: string } | null | undefined,
  empresa_id: string,
): Promise<void> {
  if (!payload?.autorizacion_id) {
    throw new ForbiddenException('La autorización del supervisor no quedó registrada: pedila de nuevo.');
  }
  const consumo = await tx.autorizaciones_caja.updateMany({
    where: { id: payload.autorizacion_id, empresa_id, estado: EstadoAutorizacionCaja.APROBADA },
    data: { estado: EstadoAutorizacionCaja.UTILIZADA },
  });
  if (consumo.count === 0) {
    throw new ForbiddenException('Esta autorización ya se usó: pedile al supervisor una nueva.');
  }
}

/**
 * Lo que el supervisor autorizó: el PIN presencial lo lleva en el token; la
 * autorización remota, en la fila de autorizaciones_caja que aprobó.
 */
export async function contextoDeAutorizacion(
  prisma: Pick<Prisma.TransactionClient, 'autorizaciones_caja'>,
  payload: PayloadAutorizacion | null | undefined,
  empresa_id: string,
): Promise<Record<string, unknown> | null> {
  if (payload?.contexto && typeof payload.contexto === 'object' && Object.keys(payload.contexto).length > 0) {
    return payload.contexto;
  }
  if (!payload?.autorizacion_id) return null;
  const autorizacion = await prisma.autorizaciones_caja.findFirst({
    where: { id: payload.autorizacion_id, empresa_id },
    select: { contexto: true },
  });
  return (autorizacion?.contexto as Record<string, unknown> | null) ?? null;
}

/** Código con el que el servidor pide el PIN de un supervisor para anular una venta de caja. */
export const CODIGO_ANULACION_REQUIERE_AUTORIZACION = 'ANULACION_REQUIERE_AUTORIZACION';

/**
 * Anular una venta cobrada en caja (anulación local, cancelación o
 * inutilización por evento SIFEN) exige la autorización de un supervisor,
 * salvo que quien anula sea supervisor (privilegio de PIN). Si llega una
 * autorización, siempre se verifica: operación «anulacion» y ESA factura.
 * Devuelve el payload a consumir, o null si no hace falta ni vino.
 */
export async function exigirAutorizacionAnulacionVenta(
  prisma: Pick<PrismaService, 'usuario' | 'perfiles_privilegios' | 'autorizaciones_caja'>,
  args: { facturaId: string; empresa_id: string; user_id?: string; ventaDeCaja: boolean; token?: string },
  jwt?: Verificador,
): Promise<PayloadAutorizacion | null> {
  const { facturaId, empresa_id, user_id, ventaDeCaja, token } = args;
  if (!token) {
    if (!ventaDeCaja || (await tieneAlgunPrivilegio(prisma, user_id, [PRIVILEGIO_PIN_SUPERVISOR]))) return null;
    throw new ForbiddenException({
      statusCode: 403,
      codigo: CODIGO_ANULACION_REQUIERE_AUTORIZACION,
      message: 'Anular una venta cobrada en caja requiere la autorización de un supervisor: pedile su PIN.',
    });
  }
  const payload = await verificarTokenAutorizacion(token, 'anulacion', empresa_id, jwt);
  const contexto = await contextoDeAutorizacion(prisma, payload, empresa_id);
  if (contexto?.factura_id !== facturaId) {
    throw new ForbiddenException('La autorización del supervisor fue para otra factura: pedila de nuevo.');
  }
  return payload;
}
