import { useState } from "react";
import {
  createConsultant,
  getConsultants,
  getConsultantById,
  updateConsultant,
  deleteConsultant,
  getConsultantTypes,
  createConsultantType,
  getProjectsForDropdown,
  type ConsultantFilters,
  type CreateConsultantData,
  type UpdateConsultantData,
  type CreateConsultantTypeData,
  type ConsultantListResponse,
  type ConsultantResponse,
  type DeleteConsultantResponse,
  type ConsultantTypesResponse,
  type ProjectsResponse,
  type ConsultantTypeResponse,
} from "../../services/consultantService";
import { handleToastError, customizeToast } from "../../utils";

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

  // Create Consultant
  const createConsultantAsync = async (data: CreateConsultantData) => {
    try {
      setLoading(true);
      const response = await createConsultant(data);

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

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

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

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

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Consultant deleted successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Consultant deleted successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to delete consultant";
        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 Consultant Types
  const getConsultantTypesAsync = async () => {
    try {
      const response = await getConsultantTypes();

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

  // Create Consultant Type (Inline)
  const createConsultantTypeAsync = async (data: CreateConsultantTypeData) => {
    try {
      const response = await createConsultantType(data);

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

  // Get Projects for dropdown
  const getProjectsForDropdownAsync = async () => {
    try {
      const response = await getProjectsForDropdown();

      // 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) {
      // Handle network errors or other exceptions
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    }
  };

  return {
    loading,
    createConsultant: createConsultantAsync,
    getConsultants: getConsultantsAsync,
    getConsultantById: getConsultantByIdAsync,
    updateConsultant: updateConsultantAsync,
    deleteConsultant: deleteConsultantAsync,
    getConsultantTypes: getConsultantTypesAsync,
    createConsultantType: createConsultantTypeAsync,
    getProjectsForDropdown: getProjectsForDropdownAsync,
  };
}

export default useConsultantService;