import { useState } from "react";
import {
  createRole,
  getRoles,
  getRoleById,
  updateRole,
  deleteRole,
  toggleRoleStatus,
  getPermissions,
  getRolePermissions,
  getAllRolePermissions,
  assignPermissionToRole,
  removePermissionFromRole,
  type RoleFilters,
  type CreateRoleData,
  type UpdateRoleData,
  type AssignPermissionData,
  type RoleListResponse,
  type RoleResponse,
  type PermissionListResponse,
  type RolePermissionResponse,
  type DeleteRoleResponse,
  type AssignPermissionResponse,
} from "../../services/roleService";
import { handleToastError, customizeToast } from "../../utils";

function useRoleService() {
  const [loading, setLoading] = useState(false);

  // Create Role
  const createRoleAsync = async (data: CreateRoleData) => {
    try {
      setLoading(true);
      const response = await createRole(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Role created successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Role created successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage = response.data?.message || "Failed to create role";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Get Roles
  const getRolesAsync = async (filters?: RoleFilters) => {
    try {
      setLoading(true);
      const response = await getRoles(filters);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Roles retrieved successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to retrieve roles";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Get Role by ID
  const getRoleByIdAsync = async (id: number) => {
    try {
      setLoading(true);
      const response = await getRoleById(id);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Role retrieved successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to retrieve role";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Update Role
  const updateRoleAsync = async (data: UpdateRoleData) => {
    try {
      setLoading(true);
      const response = await updateRole(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Role updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Role updated successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage = response.data?.message || "Failed to update role";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Delete Role
  const deleteRoleAsync = async (id: number) => {
    try {
      setLoading(true);
      const response = await deleteRole(id);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Role deleted successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Role deleted successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage = response.data?.message || "Failed to delete role";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Toggle Role Status
  const toggleRoleStatusAsync = async (id: number) => {
    try {
      setLoading(true);
      const response = await toggleRoleStatus(id);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Role status updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Role status updated successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to update role status";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Get Permissions
  const getPermissionsAsync = async () => {
    try {
      setLoading(true);
      const response = await getPermissions();

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Permissions retrieved successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to retrieve permissions";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Get Role Permissions
  const getRolePermissionsAsync = async () => {
    try {
      setLoading(true);
      const response = await getRolePermissions();

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Role permissions retrieved successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to retrieve role permissions";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Get All Role Permissions
  const getAllRolePermissionsAsync = async () => {
    try {
      setLoading(true);
      const response = await getAllRolePermissions();

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message ||
            "All role permissions retrieved successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to retrieve all role permissions";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Assign Permission to Role
  const assignPermissionAsync = async (
    roleId: number,
    data: AssignPermissionData
  ) => {
    try {
      setLoading(true);
      const response = await assignPermissionToRole(roleId, data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast(
          response.data?.message || "Permission assigned successfully",
          "success"
        );
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Permission assigned successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to assign permission";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Remove Permission from Role
  const removePermissionAsync = async (
    roleId: number,
    permissionId: number
  ) => {
    try {
      setLoading(true);
      const response = await removePermissionFromRole(roleId, permissionId);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast(response.data?.message || "Permission removed successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Permission removed successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to remove permission";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  return {
    loading,
    createRole: createRoleAsync,
    getRoles: getRolesAsync,
    getRoleById: getRoleByIdAsync,
    updateRole: updateRoleAsync,
    deleteRole: deleteRoleAsync,
    toggleRoleStatus: toggleRoleStatusAsync,
    getPermissions: getPermissionsAsync,
    getRolePermissions: getRolePermissionsAsync,
    getAllRolePermissions: getAllRolePermissionsAsync,
    assignPermission: assignPermissionAsync,
    removePermission: removePermissionAsync,
  };
}

export default useRoleService;