import { useState, useEffect, useCallback } from "react";
import {
  getEmployeeProjects,
  assignProjectsToEmployee,
  removeProjectFromEmployee,
  type EmployeeProject,
  type AssignProjectsData,
} from "../../services/employeeService";
import { customizeToast } from "@/lib/utils";

interface UseEmployeeProjectState {
  employeeProjects: EmployeeProject[];
  loading: boolean;
  error: string | null;
}

interface UseEmployeeProjectActions {
  refreshProjects: () => Promise<void>;
  assignProjects: (data: AssignProjectsData) => Promise<boolean>;
  removeProject: (projectId: string, assignmentId: string) => Promise<boolean>;
}

const INITIAL_STATE: UseEmployeeProjectState = {
  employeeProjects: [],
  loading: false,
  error: null,
};

function useEmployeeProject(employeeId: string) {
  const [state, setState] = useState<UseEmployeeProjectState>(INITIAL_STATE);

  // Fetch employee projects
  const refreshProjects = useCallback(async () => {
    if (!employeeId) return;

    setState((prev) => ({ ...prev, loading: true, error: null }));

    try {
      const response = await getEmployeeProjects(employeeId);

      if (response?.data?.success && response.data.data) {
        setState((prev) => ({
          ...prev,
          employeeProjects: response.data.data ?? [],
          loading: false,
          error: null,
        }));
      } else {
        setState((prev) => ({
          ...prev,
          employeeProjects: [],
          loading: false,
          error: response?.data?.message || "Failed to fetch employee projects",
        }));
      }
    } catch (error: any) {
      console.error("Error fetching employee projects:", error);
      setState((prev) => ({
        ...prev,
        employeeProjects: [],
        loading: false,
        error: error?.message || "Failed to fetch employee projects",
      }));
    }
  }, [employeeId]);

  // Auto-fetch when employeeId changes
  useEffect(() => {
    if (employeeId) {
      refreshProjects();
    }
  }, [employeeId, refreshProjects]);

  // Assign projects to employee
  const assignProjects = useCallback(
    async (data: AssignProjectsData): Promise<boolean> => {
      if (!employeeId) return false;

      setState((prev) => ({ ...prev, loading: true }));

      try {
        const response = await assignProjectsToEmployee(employeeId, data);

        if (response?.data?.success) {
          customizeToast("Projects assigned successfully!", "success");
          await refreshProjects();
          return true;
        } else {
          customizeToast(
            response?.data?.message || "Failed to assign projects",
            "danger"
          );
          return false;
        }
      } catch (error: any) {
        console.error("Error assigning projects:", error);
        customizeToast(
          error?.response?.data?.message ||
            error?.message ||
            "Failed to assign projects",
          "danger"
        );
        return false;
      } finally {
        setState((prev) => ({ ...prev, loading: false }));
      }
    },
    [employeeId, refreshProjects]
  );

  // Remove project from employee
  const removeProject = useCallback(
    async (projectId: string, assignmentId: string): Promise<boolean> => {
      if (!employeeId) return false;

      setState((prev) => ({ ...prev, loading: true }));

      try {
        const response = await removeProjectFromEmployee(projectId, assignmentId);

        if (response?.data?.success) {
          customizeToast("Project removed successfully!", "success");
          await refreshProjects();
          return true;
        } else {
          customizeToast(
            response?.data?.message || "Failed to remove project",
            "danger"
          );
          return false;
        }
      } catch (error: any) {
        console.error("Error removing project:", error);
        customizeToast(
          error?.response?.data?.message ||
            error?.message ||
            "Failed to remove project",
          "danger"
        );
        return false;
      } finally {
        setState((prev) => ({ ...prev, loading: false }));
      }
    },
    [employeeId, refreshProjects]
  );

  const actions: UseEmployeeProjectActions = {
    refreshProjects,
    assignProjects,
    removeProject,
  };

  return {
    ...state,
    ...actions,
  };
}

export default useEmployeeProject;