import { useState } from "react";
import {
  createProject,
  getProjects,
  getProjectById,
  updateProject,
  deleteProject,
  getProjectEmployees,
  assignEmployeeToProject,
  deleteAssignedEmployee,
  updateCompletionPercentage,
  type ProjectFilters,
  type CreateProjectData,
  type UpdateProjectData,
  type ProjectListResponse,
  type ProjectResponse,
  type DeleteProjectResponse,
  type ProjectEmployeesResponse,
  type AssignEmployeeResponse,
  type AssignEmployeeData,
} from "../../services/projectService";
import { handleToastError, customizeToast } from "../../utils";

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

  // Create Project
  const createProjectAsync = async (data: CreateProjectData) => {
    try {
      setLoading(true);
      const response = await createProject(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Project created successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Project created successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to create project";
        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 Projects
  const getProjectsAsync = async (filters?: ProjectFilters) => {
    try {
      setLoading(true);
      const response = await getProjects(filters);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Projects fetched successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to fetch projects";
        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 Project by ID
  const getProjectByIdAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await getProjectById(id);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Project fetched successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to fetch project";
        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 Project
  const updateProjectAsync = async (data: UpdateProjectData) => {
    try {
      setLoading(true);
      const response = await updateProject(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Project updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Project updated successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to update project";
        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 Project
  const deleteProjectAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await deleteProject(id);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Project deleted successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Project deleted successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to delete project";
        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 Project Employees
  const getProjectEmployeesAsync = async (projectId: string, params?: any) => {
    try {
      setLoading(true);
      
      const response = await getProjectEmployees(projectId, params);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Project employees fetched successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to fetch project employees";
        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 Employee to Project
  const assignEmployeeToProjectAsync = async (
    projectId: string,
    data: AssignEmployeeData
  ) => {
    try {
      setLoading(true);
      const response = await assignEmployeeToProject(projectId, data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Employee assigned to project successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message ||
            "Employee assigned to project successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to assign employee to project";
        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 Assigned Employee
  const deleteAssignedEmployeeAsync = async (
    projectId: string,
    assignmentId: string
  ) => {
    try {
      setLoading(true);
      const response = await deleteAssignedEmployee(projectId, assignmentId);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Employee removed from project successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message ||
            "Employee removed from project successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to remove employee from project";
        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 completion percentage
  const updateCompletionPercentageAsync = async (
    projectId: string,
    completion_percentage: number
  ) => {
    try {
      setLoading(true);
      const response = await updateCompletionPercentage(
        projectId,
        completion_percentage
      );
      if (response?.data?.success !== false) {
        customizeToast("Completion percentage updated.", "success");
        return {
          success: true,
          data: response.data,
          message: response?.data?.message || "Completion percentage updated.",
        };
      } else {
        const errorMessage =
          response?.data?.message || "Failed to update completion percentage.";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      const errorMessage =
        error?.response?.data?.message ||
        error?.response?.data?.errors?.[0] ||
        (error?.response?.status === 404
          ? "Completion percentage endpoint not found (404)."
          : error?.response?.status === 405
            ? "Wrong method: backend may expect PUT or POST."
            : "Failed to update completion percentage.");
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  return {
    loading,
    createProject: createProjectAsync,
    getProjects: getProjectsAsync,
    getProjectById: getProjectByIdAsync,
    updateProject: updateProjectAsync,
    deleteProject: deleteProjectAsync,
    getProjectEmployees: getProjectEmployeesAsync,
    assignEmployeeToProject: assignEmployeeToProjectAsync,
    deleteAssignedEmployee: deleteAssignedEmployeeAsync,
    updateCompletionPercentage: updateCompletionPercentageAsync,
  };
}

export default useProjectService;