"use server";

import { revalidatePath } from "next/cache";
import { requireAuth } from "@/lib/auth/guard";
import {
  createUserSchema,
  createEmployeeSchema,
  updateEmployeeSchema,
  grantOverrideSchema,
  revokeOverrideSchema,
  CreateUserInput,
  CreateEmployeeInput,
  UpdateEmployeeInput,
  GrantOverrideInput,
  RevokeOverrideInput,
} from "@/lib/validation/admin.schema";
import {
  createUser,
  listAgenciesForSelection,
  toggleUserStatus,
  createEmployee,
  updateEmployee,
  grantEntitlementOverride,
  revokeEntitlementOverride,
} from "@/lib/services/admin.service";

export async function createUserAction(input: CreateUserInput) {
  try {
    const user = await requireAuth();
    const isAuthorized =
      user.roles.includes("SUPER_ADMIN") ||
      user.permissions.includes("employee:manage") ||
      user.permissions.includes("settings:manage");

    if (!isAuthorized) {
      return { success: false, error: "Unauthorized: Super Administrator privileges required to create platform users" };
    }

    const validated = createUserSchema.parse(input);
    const result = await createUser(user, validated);

    if (!result.success) {
      return { success: false, error: result.error };
    }

    revalidatePath("/admin/users");
    revalidatePath("/admin/employees");
    revalidatePath("/admin");
    return { success: true, user: result.user };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to create user";
    return { success: false, error: message };
  }
}

export async function toggleUserStatusAction(userId: string, isActive: boolean) {
  try {
    const user = await requireAuth();
    const isAuthorized = user.roles.includes("SUPER_ADMIN") || user.permissions.includes("employee:manage");

    if (!isAuthorized) {
      return { success: false, error: "Unauthorized: Super Admin permissions required" };
    }

    const result = await toggleUserStatus(user, userId, isActive);

    if (!result.success) {
      return { success: false, error: result.error };
    }

    revalidatePath("/admin/users");
    revalidatePath("/admin/employees");
    return { success: true };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to update user status";
    return { success: false, error: message };
  }
}

export async function fetchAgenciesListAction() {
  try {
    const user = await requireAuth();
    const agencies = await listAgenciesForSelection(user);
    return { success: true, agencies };
  } catch (err: unknown) {
    return { success: false, agencies: [] };
  }
}


export async function createEmployeeAction(input: CreateEmployeeInput) {
  try {
    const user = await requireAuth();
    const isAuthorized =
      user.roles.includes("SUPER_ADMIN") ||
      user.permissions.includes("employee:manage");

    if (!isAuthorized) {
      return { success: false, error: "Unauthorized: Super Admin or Staff Manager rights required" };
    }

    const validated = createEmployeeSchema.parse(input);
    const result = await createEmployee(user, validated);

    if (!result.success) {
      return { success: false, error: result.error };
    }

    revalidatePath("/admin/employees");
    revalidatePath("/admin/users");
    return { success: true, employee: result.employee };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to provision employee";
    return { success: false, error: message };
  }
}

export async function updateEmployeePermissionsAction(input: UpdateEmployeeInput) {
  try {
    const user = await requireAuth();
    const isAuthorized =
      user.roles.includes("SUPER_ADMIN") ||
      user.permissions.includes("employee:manage");

    if (!isAuthorized) {
      return { success: false, error: "Unauthorized: Super Admin or Staff Manager rights required" };
    }

    const validated = updateEmployeeSchema.parse(input);
    const result = await updateEmployee(user, validated);

    if (!result.success) {
      return { success: false, error: result.error };
    }

    revalidatePath("/admin/employees");
    return { success: true };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to update employee";
    return { success: false, error: message };
  }
}

export async function grantOverrideAction(input: GrantOverrideInput) {
  try {
    const user = await requireAuth();
    const isAuthorized =
      user.roles.includes("SUPER_ADMIN") ||
      user.permissions.includes("subscription:override");

    if (!isAuthorized) {
      return { success: false, error: "Unauthorized: Entitlement override permission required" };
    }

    const validated = grantOverrideSchema.parse(input);
    const result = await grantEntitlementOverride(user, validated);

    if (!result.success) {
      return { success: false, error: result.error };
    }

    revalidatePath("/admin/overrides");
    revalidatePath("/dashboard");
    revalidatePath("/dashboard/billing");
    return { success: true, override: result.override };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to grant override";
    return { success: false, error: message };
  }
}

export async function revokeOverrideAction(input: RevokeOverrideInput) {
  try {
    const user = await requireAuth();
    const isAuthorized =
      user.roles.includes("SUPER_ADMIN") ||
      user.permissions.includes("subscription:override");

    if (!isAuthorized) {
      return { success: false, error: "Unauthorized: Entitlement override permission required" };
    }

    const validated = revokeOverrideSchema.parse(input);
    const result = await revokeEntitlementOverride(user, validated.overrideId);

    if (!result.success) {
      return { success: false, error: result.error };
    }

    revalidatePath("/admin/overrides");
    revalidatePath("/dashboard");
    revalidatePath("/dashboard/billing");
    return { success: true };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to revoke override";
    return { success: false, error: message };
  }
}

export async function getGlobalListingLimitsAction(): Promise<{
  success: boolean;
  mode?: "UNLIMITED" | "ENFORCED";
  error?: string;
}> {
  try {
    const user = await requireAuth();
    if (!user.roles.includes("SUPER_ADMIN") && !user.roles.includes("EMPLOYEE")) {
      return { success: false, error: "Unauthorized" };
    }
    const { getGlobalListingLimitsMode } = await import("@/lib/services/entitlement.service");
    const mode = await getGlobalListingLimitsMode();
    return { success: true, mode };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to fetch listing limits status";
    return { success: false, error: message };
  }
}

export async function toggleGlobalListingLimitsAction(mode: "UNLIMITED" | "ENFORCED"): Promise<{
  success: boolean;
  mode?: "UNLIMITED" | "ENFORCED";
  error?: string;
}> {
  try {
    const user = await requireAuth();
    if (!user.roles.includes("SUPER_ADMIN")) {
      return { success: false, error: "Unauthorized: Super Administrator privileges required" };
    }

    const { setGlobalListingLimitsMode } = await import("@/lib/services/entitlement.service");
    await setGlobalListingLimitsMode(mode, { id: user.id, email: user.email });

    revalidatePath("/admin");
    revalidatePath("/admin/overrides");
    revalidatePath("/dashboard");
    revalidatePath("/dashboard/properties");
    revalidatePath("/dashboard/properties/new");
    revalidatePath("/pricing");

    return { success: true, mode };
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : "Failed to toggle global listing limits";
    return { success: false, error: message };
  }
}