import { useState } from "react";
import {
  getPayrollCycles,
  getPayrollCycleById,
  getPayrollEntries,
  updatePayrollEntryAttendance,
  processPayroll,
  getEmployeeSalarySlips,
  getSalarySlipById,
  type PayrollCycleFilters,
  type PayrollEntryFilters,
  type UpdateAttendanceData,
  type ProcessPayrollData,
  type SalarySlipFilters,
  type PayrollCycleListResponse,
  type PayrollCycleResponse,
  type PayrollEntryListResponse,
  type PayrollEntryResponse,
  type ProcessPayrollResponse,
  type SalarySlipListResponse,
  type SalarySlipDetailResponse,
} from "../../services/payrollService";
import { handleToastError, customizeToast } from "../../utils";

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

  // Get Payroll Cycles
  const getPayrollCyclesAsync = async (filters?: PayrollCycleFilters) => {
    try {
      setLoading(true);
      const response = await getPayrollCycles(filters);

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

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Payroll cycle fetched successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to fetch payroll cycle";
        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 Payroll Entries
  const getPayrollEntriesAsync = async (cycleId: string, filters?: PayrollEntryFilters) => {
    try {
      setLoading(true);
      const response = await getPayrollEntries(cycleId, filters);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Payroll entries fetched successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to fetch payroll entries";
        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 Payroll Entry Attendance
  const updatePayrollEntryAttendanceAsync = async (entryId: string, data: UpdateAttendanceData) => {
    try {
      setLoading(true);
      const response = await updatePayrollEntryAttendance(entryId, data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Attendance updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Attendance updated successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to update attendance";
        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);
    }
  };

  // Process Payroll
  const processPayrollAsync = async (data: ProcessPayrollData) => {
    try {
      setLoading(true);
      const response = await processPayroll(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Payroll processed successfully", "success");
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Payroll processed successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to process payroll";
        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 Employee Salary Slips
  const getEmployeeSalarySlipsAsync = async (filters?: SalarySlipFilters) => {
    try {
      setLoading(true);
      const response = await getEmployeeSalarySlips(filters);

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

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        return {
          success: true,
          data: response.data,
          message: response.data?.message || "Salary slip fetched successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to fetch salary slip";
        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);
    }
  };

  return {
    loading,
    getPayrollCycles: getPayrollCyclesAsync,
    getPayrollCycleById: getPayrollCycleByIdAsync,
    getPayrollEntries: getPayrollEntriesAsync,
    updatePayrollEntryAttendance: updatePayrollEntryAttendanceAsync,
    processPayroll: processPayrollAsync,
    getEmployeeSalarySlips: getEmployeeSalarySlipsAsync,
    getSalarySlipById: getSalarySlipByIdAsync,
  };
}

export default usePayrollService;