import { User } from "@prisma/client";

// Define all possible generic permissions
export const Permissions = {
    // Job Management
    JOB_READ: "jobs.read",
    JOB_APPROVE: "jobs.approve",
    JOB_REJECT: "jobs.reject",
    JOB_EDIT: "jobs.edit",
    JOB_DELETE: "jobs.delete",

    // User Management
    USER_READ: "users.read",
    USER_EDIT: "users.edit",
    USER_SUSPEND: "users.suspend",
    USER_DELETE: "users.delete",
    USER_IMPERSONATE: "users.impersonate",

    // Content Moderation
    MODERATE_REVIEWS: "reviews.moderate",
    MODERATE_PROFILES: "profiles.moderate",

    // Analytics
    ANALYTICS_VIEW: "analytics.view",
    ANALYTICS_EXPORT: "analytics.export",

    // System Settings
    SETTINGS_VIEW: "settings.view",
    SETTINGS_EDIT: "settings.edit",

    // Admin Management
    ADMIN_READ: "admins.read",
    ADMIN_CREATE: "admins.create",
    ADMIN_EDIT: "admins.edit",
    ADMIN_DELETE: "admins.delete",
} as const;

export type Permission = (typeof Permissions)[keyof typeof Permissions];

// Define Role types
export type AdminRole = "super_admin" | "admin" | "moderator" | "analyst" | "support";
export type UserRole = AdminRole | "employer" | "candidate";

// Define role hierarchies and default permissions
export const ROLE_PERMISSIONS: Record<string, Permission[]> = {
    super_admin: Object.values(Permissions), // Has everything

    admin: [
        Permissions.JOB_READ, Permissions.JOB_APPROVE, Permissions.JOB_REJECT, Permissions.JOB_EDIT,
        Permissions.USER_READ, Permissions.USER_EDIT, Permissions.USER_SUSPEND,
        Permissions.MODERATE_REVIEWS, Permissions.MODERATE_PROFILES,
        Permissions.ANALYTICS_VIEW, Permissions.ANALYTICS_EXPORT,
        Permissions.SETTINGS_VIEW,
        Permissions.ADMIN_READ,
    ],

    moderator: [
        Permissions.JOB_READ, Permissions.JOB_APPROVE, Permissions.JOB_REJECT,
        Permissions.USER_READ,
        Permissions.MODERATE_REVIEWS, Permissions.MODERATE_PROFILES,
    ],

    analyst: [
        Permissions.JOB_READ,
        Permissions.USER_READ,
        Permissions.ANALYTICS_VIEW, Permissions.ANALYTICS_EXPORT,
    ],

    support: [
        Permissions.USER_READ, Permissions.USER_EDIT, // Can help users reset things
        Permissions.JOB_READ,
    ],
};

/**
 * Core RBAC Engine: Checks if a user has a specific permission.
 */
export function hasPermission(
    user: Pick<User, "role" | "custom_permissions"> | null | undefined,
    requiredPermission: Permission
): boolean {
    if (!user) return false;

    // 1. Super Admin bypass (always true)
    if (user.role === "super_admin") return true;

    // 2. Check Custom Permissions overrides
    // (Assuming custom_permissions can contain things like "-jobs.delete" to explicitly deny, 
    // or "jobs.approve" to explicitly allow outside of role defaults).
    const explicitlyDenied = user.custom_permissions.includes(`-${requiredPermission}`);
    if (explicitlyDenied) return false;

    const explicitlyAllowed = user.custom_permissions.includes(requiredPermission);
    if (explicitlyAllowed) return true;

    // 3. Fallback to Role Defaults
    const roleDefaults = ROLE_PERMISSIONS[user.role] || [];
    return roleDefaults.includes(requiredPermission);
}

/**
 * Checks if a user has ALL of the required permissions.
 */
export function hasAllPermissions(
    user: Pick<User, "role" | "custom_permissions"> | null | undefined,
    requiredPermissions: Permission[]
): boolean {
    return requiredPermissions.every(p => hasPermission(user, p));
}

/**
 * Checks if a user has ANY of the required permissions.
 */
export function hasAnyPermission(
    user: Pick<User, "role" | "custom_permissions"> | null | undefined,
    requiredPermissions: Permission[]
): boolean {
    return requiredPermissions.some(p => hasPermission(user, p));
}
