import { useState, useEffect, useCallback } from "react";
import useProjectService from "./useProjectService";
import { type ProjectEmployee, type AssignEmployeeData } from "../../services/projectService";
import { useHasPermission } from "../usePermissions";

interface UseProjectEmployeeState {
  projectEmployees: ProjectEmployee[];
  loading: boolean;
  error: string | null;
}

interface UseProjectEmployeeActions {
  refreshEmployees: () => Promise<void>;
  assignEmployee: (data: AssignEmployeeData) => Promise<boolean>;
  removeEmployee: (assignmentId: string) => Promise<boolean>;
}

const INITIAL_STATE: UseProjectEmployeeState = {
  projectEmployees: [],
  loading: false,
  error: null,
};

function useProjectEmployee(projectId: string) {
  const [state, setState] = useState<UseProjectEmployeeState>(INITIAL_STATE);
  const service = useProjectService();
  const canViewAllProjectAssignedEmployees = useHasPermission(
    "view_all_project_assigned_employees"
  );


  // Fetch project employees
  const refreshEmployees = useCallback(async (params?: any) => {
    if (!projectId) return;

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

    const result = await service.getProjectEmployees(projectId, {
      ...params,
      show_all: canViewAllProjectAssignedEmployees ? 'true' : undefined,
    });

    if (result.success && result.data) {
      setState((prev) => ({
        ...prev,
        projectEmployees: result.data!.data ?? [],
        loading: false,
        error: null,
      }));
    } else {
      setState((prev) => ({
        ...prev,
        projectEmployees: [],
        loading: false,
        error: result.message || "Failed to fetch project employees",
      }));
    }
  }, [projectId, service]);

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

  // Assign employee to project
  const assignEmployee = useCallback(
    async (data: AssignEmployeeData): Promise<boolean> => {
      if (!projectId) return false;

      const result = await service.assignEmployeeToProject(projectId, data);
      if (result.success) {
        await refreshEmployees();
      }
      return result.success;
    },
    [projectId, service]
  );

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

      const result = await service.deleteAssignedEmployee(projectId, assignmentId);
      if (result.success) {
        await refreshEmployees();
      }
      return result.success;
    },
    [projectId, service]
  );

  const actions: UseProjectEmployeeActions = {
    refreshEmployees,
    assignEmployee,
    removeEmployee,
  };

  return {
    ...state,
    loading: state.loading || service.loading,
    ...actions,
  };
}

export default useProjectEmployee;