import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { AuditService } from 'src/audit/audit.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { SuscripcionesService } from 'src/suscripciones/suscripciones.service';

/**
 * Reglas comunes a los tres caminos que cambian la empresa activa: `POST /auth/empresas/cambiar`,
 * `POST /auth/switch-empresa` y `POST /mobile/auth/switch-empresa` (review-t7 y review-cierre-back).
 * El acceso (qué empresas tiene asignadas el usuario) lo decide cada camino; esto agrega el privilegio, el destino
 * habilitado y la auditoría.
 */

/** Privilegio que habilita el cambio de empresa activa (Configuración › Empresas asociadas › Entrar). */
export const PRIVILEGIO_CAMBIAR_CONTEXTO = 'ADM_EMPASOC_CAMBIAR_CONTEXTO';

type Prismaish = Pick<PrismaService, 'privilegios' | 'perfiles_privilegios' | 'empresas'>;
type Suscripciones = Pick<SuscripcionesService, 'getSubmodulosActivos' | 'verificarEstadoSuscripcion'>;

/**
 * Como `PrivilegioGuard`, pero sobre la empresa PRINCIPAL (si se evaluara en la actual, sin el privilegio ahí no
 * podría salir): el submódulo del privilegio en el plan de la principal (holdings/resellers lo traen todo), y después
 * el privilegio en los perfiles de la principal o de sistema; el dueño (`is_superadmin`) de la principal saltea solo
 * esta última capa.
 */
export async function exigirPrivilegioEnLaPrincipal(
  prisma: Prismaish,
  suscripciones: Suscripciones,
  usuarioId: string,
  principalId: string,
  esDueno: boolean,
) {
  const privilegio = await prisma.privilegios.findFirst({
    where: { codigo: PRIVILEGIO_CAMBIAR_CONTEXTO, active: true },
    select: { submodulos: { select: { codigo: true } } },
  });
  const submodulo = privilegio?.submodulos?.codigo;
  const enPlan = submodulo
    ? (await suscripciones.getSubmodulosActivos(principalId)).some((s) => s.codigo === submodulo)
    : false;
  if (!enPlan) {
    throw new ForbiddenException('Empresas asociadas no está disponible en el plan de su empresa principal');
  }
  if (esDueno) return;

  const asignado = await prisma.perfiles_privilegios.findFirst({
    where: {
      active: true,
      privilegios: { codigo: PRIVILEGIO_CAMBIAR_CONTEXTO, active: true },
      perfiles: {
        OR: [{ empresa_id: principalId }, { empresa_id: null }],
        usuario_perfiles: { some: { user_id: usuarioId } },
      },
    },
    select: { id: true },
  });
  if (!asignado) {
    throw new ForbiddenException(`No tiene el privilegio "${PRIVILEGIO_CAMBIAR_CONTEXTO}" en su empresa principal`);
  }
}

/** La empresa destino tiene que estar activa y, si tiene suscripción propia, no bloqueada. */
export async function exigirDestinoHabilitado(prisma: Prismaish, suscripciones: Suscripciones, empresaId: string) {
  const destino = await prisma.empresas.findUnique({
    where: { id: empresaId },
    select: { active: true, type: true },
  });
  if (!destino?.active) throw new BadRequestException('La empresa destino no está activa');
  // Holdings/resellers no tienen suscripción propia: nunca quedan bloqueadas.
  if (destino.type === 'holding' || destino.type === 'reseller') return;
  const estado = await suscripciones.verificarEstadoSuscripcion(empresaId);
  if (estado.bloqueada) throw new BadRequestException('La empresa destino tiene la suscripción bloqueada');
}

/**
 * Reglas para entrar a `destinoId` (el acceso ya verificado por el llamador). Volver a la principal siempre se permite:
 * nunca deja al usuario encerrado.
 */
export async function exigirCambioDeEmpresaPermitido(
  prisma: Prismaish,
  suscripciones: Suscripciones,
  usuario: { id: string; empresa_id: string; is_superadmin: boolean | null },
  destinoId: string,
) {
  if (destinoId === usuario.empresa_id) return;
  await exigirPrivilegioEnLaPrincipal(prisma, suscripciones, usuario.id, usuario.empresa_id, !!usuario.is_superadmin);
  await exigirDestinoHabilitado(prisma, suscripciones, destinoId);
}

/**
 * Graba la empresa activa (`null` = la principal) y la auditoría `SWITCH_EMPRESA` en la misma transacción: no queda
 * un cambio sin constancia.
 */
export async function grabarCambioDeEmpresa(
  prisma: Pick<PrismaService, '$transaction'>,
  audit: Pick<AuditService, 'logEnTransaccion'>,
  datos: { usuarioId: string; principalId: string; anteriorId: string; destinoId: string; destinoNombre: string },
) {
  const nuevoValor = datos.destinoId === datos.principalId ? null : datos.destinoId;
  await prisma.$transaction(async (tx: Prisma.TransactionClient) => {
    await tx.usuario.update({ where: { id: datos.usuarioId }, data: { empresa_id_actual: nuevoValor } });
    await audit.logEnTransaccion(tx, {
      empresa_id: datos.destinoId,
      user_id: datos.usuarioId,
      action: 'SWITCH_EMPRESA',
      entity_type: 'empresa',
      entity_id: datos.destinoId,
      descripcion: `Cambio de contexto de empresa a: ${datos.destinoNombre}`,
      old_value: { empresa_id: datos.anteriorId },
      new_value: { empresa_id: datos.destinoId },
    });
  });
}
