import { useState } from "react";
import {
  createLeaveType,
  getLeaveTypes,
  getLeaveTypeById,
  updateLeaveType,
  deleteLeaveType,
  toggleLeaveTypeStatus,
  type LeaveTypeFilters,
  type CreateLeaveTypeData,
  type UpdateLeaveTypeData,
  type LeaveTypeListResponse,
  type LeaveTypeResponse,
  type DeleteLeaveTypeResponse,
} from "../../services/leaveTypeService";
import { handleToastError, customizeToast } from "../../utils";

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

  // Create Leave Type
  const createLeaveTypeAsync = async (data: CreateLeaveTypeData) => {
    try {
      setLoading(true);
      const response = await createLeaveType(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Leave type created successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Leave type created successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to create leave type";
        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 Leave Types
  const getLeaveTypesAsync = async (filters?: LeaveTypeFilters) => {
    try {
      setLoading(true);
      const response = await getLeaveTypes(filters);

      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Leave types fetched successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to fetch leave types";
        handleToastError(response);
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      const errorMessage = error?.response?.data?.message || error.toString();
      handleToastError(error?.response);
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Get Leave Type by ID
  const getLeaveTypeByIdAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await getLeaveTypeById(id);

      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Leave type fetched successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to fetch leave type";
        handleToastError(response);
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      const errorMessage = error?.response?.data?.message || error.toString();
      handleToastError(error?.response);
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Update Leave Type
  const updateLeaveTypeAsync = async (data: UpdateLeaveTypeData) => {
    try {
      setLoading(true);
      const response = await updateLeaveType(data);

      if (response?.data?.success !== false) {
        customizeToast("Leave type updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Leave type updated successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to update leave type";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Delete Leave Type
  const deleteLeaveTypeAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await deleteLeaveType(id);

      if (response?.data?.success !== false) {
        customizeToast("Leave type deleted successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Leave type deleted successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to delete leave type";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  // Toggle Leave Type Status
  const toggleLeaveTypeStatusAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await toggleLeaveTypeStatus(id);

      if (response?.data?.success !== false) {
        customizeToast("Leave type status updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Leave type status updated successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to update leave type status";
        customizeToast(errorMessage, "danger");
        return {
          success: false,
          data: null,
          message: errorMessage,
        };
      }
    } catch (error: any) {
      setLoading(false);
      const errorMessage = error?.response?.data?.message || error.toString();
      customizeToast(errorMessage, "danger");
      return {
        success: false,
        data: null,
        message: errorMessage,
      };
    } finally {
      setLoading(false);
    }
  };

  return {
    loading,
    createLeaveType: createLeaveTypeAsync,
    getLeaveTypes: getLeaveTypesAsync,
    getLeaveTypeById: getLeaveTypeByIdAsync,
    updateLeaveType: updateLeaveTypeAsync,
    deleteLeaveType: deleteLeaveTypeAsync,
    toggleLeaveTypeStatus: toggleLeaveTypeStatusAsync,
  };
}

export default useLeaveTypeService;