import ApiService from "./ApiService";

// Role interfaces
export interface Role {
  id: number;
  name: string;
  company_id?: number;
  status: number;
  role_count?: number;
  created_at?: string;
  updated_at?: string;
  users?: any[]; // For usage count
}

// Permission interfaces
export interface Permission {
  id: number;
  group_key: string;
  permission_key: string;
  label: string;
  description?: string;
  status: number;
  group_name?: string;
}

// Role Permission interfaces
export interface RolePermission {
  id: number;
  role_id: number;
  permission_id: number;
  company_id: number;
  status: number;
  role?: Role;
  permission?: Permission;
}

// Grouped permissions from backend
export interface GroupedPermissions {
  [groupKey: string]: Permission[];
}

// Filter interfaces
export interface RoleFilters {
  search?: string;
  status?: number;
  page?: number;
  limit?: number;
}

// Create/Update data interfaces
export interface CreateRoleData {
  name: string;
  status?: number;
}

export interface UpdateRoleData {
  id: number;
  name: string;
  status?: number;
}

export interface AssignPermissionData {
  permission_id: number;
}

// Response interfaces
export interface RoleListResponse {
  success: boolean;
  message?: string;
  data: {
    data: Role[];
    count: number;
  };
}

export interface RoleResponse {
  success: boolean;
  message?: string;
  data: Role;
}

export interface PermissionListResponse {
  success: boolean;
  message?: string;
  data: Permission[];
}

export interface RolePermissionResponse {
  success: boolean;
  message?: string;
  data: GroupedPermissions;
}

export interface DeleteRoleResponse {
  success: boolean;
  message?: string;
}

export interface AssignPermissionResponse {
  success: boolean;
  message?: string;
  data?: any;
}

// Create Role
export async function createRole(data: CreateRoleData) {
  return ApiService.request<RoleResponse>({
    url: "/roles",
    method: "post",
    data,
  });
}

// Get Roles with filters
export async function getRoles(filters?: RoleFilters) {
  const params: any = {
    search: filters?.search || "",
    page: filters?.page || 1,
    limit:  50,
  };

  // Only add status to params if it's defined (1 or 0)
  if (filters?.status !== undefined) {
    params.status = filters.status;
  }

  return ApiService.request<RoleListResponse>({
    url: "/roles",
    method: "get",
    params,
  });
}

// Get Role by ID
export async function getRoleById(id: number) {
  return ApiService.request<RoleResponse>({
    url: `/roles/${id}`,
    method: "get",
  });
}

// Update Role
export async function updateRole(data: UpdateRoleData) {
  const { id, ...updateData } = data;
  return ApiService.request<RoleResponse>({
    url: `/roles/${id}`,
    method: "put",
    data: updateData,
  });
}

// Delete Role
export async function deleteRole(id: number) {
  return ApiService.request<DeleteRoleResponse>({
    url: `/roles/${id}`,
    method: "delete",
  });
}

// Toggle Role Status
export async function toggleRoleStatus(id: number) {
  return ApiService.request<RoleResponse>({
    url: `/roles/active-inactive/${id}`,
    method: "patch",
  });
}

// Get All Permissions
export async function getPermissions() {
  return ApiService.request<PermissionListResponse>({
    url: "/permissions",
    method: "get",
    params: {
      is_company_admin: true, // Get all permissions
    },
  });
}

// Get Role Permissions (grouped by group_key) - for current user
export async function getRolePermissions() {
  return ApiService.request<RolePermissionResponse>({
    url: "/role-permissions",
    method: "get",
  });
}

// Get All Role Permissions (for role management)
export async function getAllRolePermissions() {
  return ApiService.request<{
    success: boolean;
    message?: string;
    data: {
      data: RolePermission[];
      count: number;
    };
  }>({
    url: "/role-permissions",
    method: "get",
    params: {
      limit: 1000, // Get all role-permissions
    },
  });
}

// Get Role Permissions for a specific role
export async function getRolePermissionsByRoleId(roleId: number) {
  return ApiService.request<RolePermissionResponse>({
    url: `/role-permissions/${roleId}`,
    method: "get",
  });
}

// Assign Permission to Role
export async function assignPermissionToRole(
  roleId: number,
  data: AssignPermissionData
) {
  return ApiService.request<AssignPermissionResponse>({
    url: `/role-permissions/assign`,
    method: "post",
    data: {
      role_id: roleId,
      ...data,
    },
  });
}

// Remove Permission from Role
export async function removePermissionFromRole(
  roleId: number,
  permissionId: number
) {
  return ApiService.request<AssignPermissionResponse>({
    url: `/role-permissions/remove`,
    method: "post",
    data: {
      role_id: roleId,
      permission_id: permissionId,
    },
  });
}