import { useState } from "react";
import {
  createLeaveRequest,
  getLeaveRequests,
  getMyLeaveRequests,
  getLeaveRequestById,
  updateLeaveRequest,
  deleteLeaveRequest,
  changeLeaveRequestStatus,
  type LeaveRequestFilters,
  type CreateLeaveRequestData,
  type UpdateLeaveRequestData,
  type StatusChangeData,
  type LeaveRequestListResponse,
  type LeaveRequestResponse,
  type DeleteLeaveRequestResponse,
  type StatusChangeResponse,
} from "../../services/leaveRequestService";
import { handleToastError, customizeToast } from "../../utils";

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

  // Create Leave Request
  const createLeaveRequestAsync = async (data: CreateLeaveRequestData) => {
    try {
      setLoading(true);
      const response = await createLeaveRequest(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Leave request submitted successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Leave request submitted successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to submit leave request";
        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 Requests
  const getLeaveRequestsAsync = async (filters?: LeaveRequestFilters) => {
    try {
      setLoading(true);
      const response = await getLeaveRequests(filters);

      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Leave requests fetched successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to fetch leave requests";
        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 My Leave Requests (current user only)
  const getMyLeaveRequestsAsync = async (filters?: LeaveRequestFilters) => {
    try {
      setLoading(true);
      const response = await getMyLeaveRequests(filters);

      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "My leave requests fetched successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to fetch my leave requests";
        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 Request by ID
  const getLeaveRequestByIdAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await getLeaveRequestById(id);

      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Leave request fetched successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to fetch leave request";
        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 Request
  const updateLeaveRequestAsync = async (data: UpdateLeaveRequestData) => {
    try {
      setLoading(true);
      const response = await updateLeaveRequest(data);

      if (response?.data?.success !== false) {
        customizeToast("Leave request updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Leave request updated successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to update leave request";
        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 Request
  const deleteLeaveRequestAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await deleteLeaveRequest(id);

      if (response?.data?.success !== false) {
        customizeToast("Leave request cancelled successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Leave request cancelled successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to cancel leave request";
        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);
    }
  };

  // Change Leave Request Status
  const changeLeaveRequestStatusAsync = async (id: string, data: StatusChangeData) => {
    try {
      setLoading(true);
      const response = await changeLeaveRequestStatus(id, data);

      if (response?.data?.success !== false) {
        const statusText = data.status === "approved" ? "approved" : 
                          data.status === "rejected" ? "rejected" : "cancelled";
        customizeToast(`Leave request ${statusText} successfully`, "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || `Leave request ${statusText} successfully`,
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to update leave request 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,
    createLeaveRequest: createLeaveRequestAsync,
    getLeaveRequests: getLeaveRequestsAsync,
    getMyLeaveRequests: getMyLeaveRequestsAsync,
    getLeaveRequestById: getLeaveRequestByIdAsync,
    updateLeaveRequest: updateLeaveRequestAsync,
    deleteLeaveRequest: deleteLeaveRequestAsync,
    changeLeaveRequestStatus: changeLeaveRequestStatusAsync,
  };
}

export default useLeaveRequestService;