import { ForbiddenException } from '@nestjs/common';
import type { LoginUserInfo } from 'src/auth/dto/login.dto';
import { esAdminPlataforma } from 'src/auth/admin-plataforma';
import type { PrismaService } from 'src/prisma/prisma.service';

/**
 * De quién es la empresa del `:id` en `/empresas`. Antes esas rutas solo miraban el permiso: un Administrador de una
 * empresa cambiaba el plan, el estado, el correo o los datos de cualquier otra, o se ponía `type: 'holding'` (que
 * saltea el plan). El permiso dice QUÉ puede hacer; esto dice SOBRE QUÉ empresa.
 *
 * - `propia_o_superior`: datos de la empresa (PUT, correo). La propia o una superior en la jerarquía (la holding o el
 *   reseller que la administra desde Empresas asociadas).
 * - `solo_superior`: plan, límites, estado y baja. Solo una superior: nadie se gestiona a sí mismo (mismo criterio que
 *   `SuscripcionesService.puedeGestionar`).
 * El administrador de la plataforma (`esAdminPlataforma`) alcanza todo. El `is_superadmin` de cualquier otra empresa (el
 * dueño que crea el registro público) es una empresa más: la suya y su red.
 */
type Db = Pick<PrismaService, 'usuario' | 'empresas'>;
export type ModoAlcance = 'propia_o_superior' | 'solo_superior';

const PROFUNDIDAD_MAX = 20;

const esSuperadmin = (prisma: Db, userId: string) => esAdminPlataforma(prisma, userId);

/** ¿`superiorId` está arriba de `empresaId` en la cadena de `parent_id`? (estricto: una empresa no es su superior) */
export async function esSuperiorDe(prisma: Db, empresaId: string, superiorId: string): Promise<boolean> {
  let actual: string | null = empresaId;
  for (let i = 0; actual && i < PROFUNDIDAD_MAX; i++) {
    const fila: { parent_id: string | null } | null = await prisma.empresas.findUnique({ where: { id: actual }, select: { parent_id: true } });
    if (!fila) return false;
    if (fila.parent_id === superiorId) return true;
    actual = fila.parent_id;
  }
  return false;
}

/** La empresa misma o una de su red (descendiente). */
const enLaRed = async (prisma: Db, empresaId: string, raizId: string) => empresaId === raizId || esSuperiorDe(prisma, empresaId, raizId);

export async function exigirAlcanceEmpresa(prisma: Db, user: LoginUserInfo, targetId: string, modo: ModoAlcance): Promise<void> {
  if (await esSuperadmin(prisma, user.id)) return;
  if (modo === 'propia_o_superior' && targetId === user.empresa_id) return;
  if (targetId !== user.empresa_id && (await esSuperiorDe(prisma, targetId, user.empresa_id))) return;
  throw new ForbiddenException(
    modo === 'solo_superior'
      ? 'Esta acción la hace la empresa que administra a esta (holding o reseller), no la propia ni otra.'
      : 'No podés modificar los datos de una empresa que no es la tuya ni de tu red.',
  );
}

/**
 * Cambiar `type`, `parent_id` o `estado_id` (PUT /empresas/:id) es mover la empresa en la jerarquía o activarla/bloquearla:
 * lo hace una superior, dentro de su red (el estado, igual que `PATCH :id/estado`, solo superior). Nunca la convierte
 * en holding (la holding no tiene plan) y solo la holding la convierte en reseller (el reseller también saltea plan y
 * addons; el front ya lo limita así). Tampoco la cuelga de su propia descendiente (ciclo: saldría de la red).
 * Reenviar los mismos valores no es un cambio.
 */
export async function exigirCambioDeJerarquia(
  prisma: Db,
  user: LoginUserInfo,
  actual: { id: string; type: string | null; parent_id: string | null; estado_id?: string | null },
  dto: { type?: string | null; parent_id?: string | null; estado_id?: string | null },
): Promise<void> {
  const cambiaTipo = dto.type !== undefined && dto.type !== actual.type;
  const cambiaPadre = dto.parent_id !== undefined && (dto.parent_id || null) !== actual.parent_id;
  const cambiaEstado = dto.estado_id !== undefined && (dto.estado_id ?? null) !== (actual.estado_id ?? null);
  if (!cambiaTipo && !cambiaPadre && !cambiaEstado) return;
  if (await esSuperadmin(prisma, user.id)) return;
  if (actual.id === user.empresa_id || !(await esSuperiorDe(prisma, actual.id, user.empresa_id))) {
    throw new ForbiddenException('El tipo, el estado y la empresa superior los cambia la empresa que administra a esta, no la propia.');
  }
  if (cambiaTipo && dto.type === 'holding') {
    throw new ForbiddenException('Solo un administrador de la plataforma puede convertir una empresa en holding.');
  }
  if (cambiaTipo && dto.type === 'reseller' && !(await esHolding(prisma, user.empresa_id))) {
    throw new ForbiddenException('Solo la holding convierte una empresa en reseller.');
  }
  if (cambiaPadre && (!dto.parent_id || !(await enLaRed(prisma, dto.parent_id, user.empresa_id)))) {
    throw new ForbiddenException('La empresa superior tiene que ser la tuya o una de tu red.');
  }
  if (cambiaPadre && dto.parent_id && (await enLaRed(prisma, dto.parent_id, actual.id))) {
    throw new ForbiddenException('Una empresa no puede quedar debajo de sí misma ni de una de sus empresas asociadas.');
  }
}

export const MENSAJE_IDENTIDAD_FISCAL =
  'Solo el dueño de la empresa puede cambiar el RUC, el DV, el tipo de contribuyente o la facturación electrónica.';

/**
 * La identidad fiscal (RUC, DV, tipo de contribuyente y `sifen_activo`, PUT /empresas/:id) la cambia el dueño de ESA
 * empresa (`is_superadmin` con ella como empresa principal, no la activa), una superior (Empresas asociadas) o la
 * plataforma. Un Administrador con ADM_EMP_EMPRESA_EDITAR edita el resto de los datos. Reenviar el mismo valor no es
 * un cambio. `tipo_contribuyente` viaja como código y se compara con el código del guardado.
 */
export async function exigirCambioDeIdentidadFiscal(
  prisma: Db,
  user: LoginUserInfo,
  actual: { id: string; ruc: string | null; dv: string | null; sifen_activo: boolean | null; tipo_contribuyente_codigo: number | null },
  dto: { ruc?: string | null; dv?: string | null; tipo_contribuyente?: number | null; sifen_activo?: boolean | null },
): Promise<void> {
  const cambia =
    (dto.ruc !== undefined && dto.ruc !== actual.ruc) ||
    (dto.dv !== undefined && dto.dv !== actual.dv) ||
    (dto.tipo_contribuyente !== undefined && dto.tipo_contribuyente !== null && Number(dto.tipo_contribuyente) !== actual.tipo_contribuyente_codigo) ||
    (dto.sifen_activo !== undefined && dto.sifen_activo !== null && dto.sifen_activo !== actual.sifen_activo);
  if (!cambia) return;
  if (await esSuperadmin(prisma, user.id)) return;
  const usuario = await prisma.usuario.findUnique({ where: { id: user.id }, select: { is_superadmin: true, empresa_id: true } });
  if (usuario?.is_superadmin === true && usuario.empresa_id === actual.id) return;
  if (actual.id !== user.empresa_id && (await esSuperiorDe(prisma, actual.id, user.empresa_id))) return;
  throw new ForbiddenException(MENSAJE_IDENTIDAD_FISCAL);
}

async function esHolding(prisma: Db, empresaId: string): Promise<boolean> {
  const e = await prisma.empresas.findUnique({ where: { id: empresaId }, select: { type: true } });
  return e?.type === 'holding';
}

/**
 * Alta desde Empresas asociadas: la hace una holding o un reseller, colgando la nueva de su red; nunca otra holding, y
 * un reseller solo da de alta subsidiarias (no otro reseller).
 */
export async function exigirAltaEnLaRed(prisma: Db, user: LoginUserInfo, dto: { parent_id?: string | null; type?: string | null }): Promise<void> {
  if (await esSuperadmin(prisma, user.id)) return;
  const propia = await prisma.empresas.findUnique({ where: { id: user.empresa_id }, select: { type: true } });
  if (propia?.type !== 'holding' && propia?.type !== 'reseller') {
    throw new ForbiddenException('Solo una holding o un reseller dan de alta empresas.');
  }
  if (dto.type === 'holding') {
    throw new ForbiddenException('Solo un administrador de la plataforma puede dar de alta una holding.');
  }
  if (dto.type === 'reseller' && propia.type !== 'holding') {
    throw new ForbiddenException('Solo la holding da de alta un reseller.');
  }
  if (!dto.parent_id || !(await enLaRed(prisma, dto.parent_id, user.empresa_id))) {
    throw new ForbiddenException('La empresa nueva tiene que colgar de la tuya o de una de tu red.');
  }
}
