import { useState, useCallback } from "react";
import { useTranslations } from "next-intl";
import { toast } from "sonner";
import {
  getHolidays,
  getHolidayById,
  createHoliday,
  updateHoliday,
  deleteHoliday,
  deleteHolidaysByYear,
  bulkCreateHolidays,
  type HolidayFilters,
  type CreateHolidayData,
  type UpdateHolidayData,
  type BulkCreateHolidaysData,
  type HolidayListResponse,
  type HolidayResponse,
  type DeleteHolidayResponse,
  type BulkCreateHolidaysResponse,
} from "../../services/holidayService";
import type { AxiosError } from "axios";

interface ServiceResult<T = any> {
  success: boolean;
  message: string;
  data?: T;
}

function useHolidayService() {
  const t = useTranslations();
  const [loading, setLoading] = useState(false);

  // Get Holidays
  const getHolidaysService = useCallback(
    async (filters?: HolidayFilters): Promise<ServiceResult<HolidayListResponse["data"]>> => {
      setLoading(true);
      try {
        const response = await getHolidays(filters);
        setLoading(false);

        if (response.data.success) {
          return {
            success: true,
            message: response.data.message || t("holidays.messages.fetchSuccess"),
            data: response.data.data,
          };
        }

        return {
          success: false,
          message: response.data.message || t("holidays.messages.fetchError"),
        };
      } catch (error) {
        setLoading(false);
        const axiosError = error as AxiosError<any>;
        const errorMessage =
          axiosError.response?.data?.message ||
          t("holidays.messages.fetchError");

        return {
          success: false,
          message: errorMessage,
        };
      }
    },
    [t]
  );

  // Get Holiday by ID
  const getHolidayByIdService = useCallback(
    async (id: string): Promise<ServiceResult<HolidayResponse["data"]>> => {
      setLoading(true);
      try {
        const response = await getHolidayById(id);
        setLoading(false);

        if (response.data.success) {
          return {
            success: true,
            message: response.data.message || t("holidays.messages.fetchSuccess"),
            data: response.data.data,
          };
        }

        return {
          success: false,
          message: response.data.message || t("holidays.messages.fetchError"),
        };
      } catch (error) {
        setLoading(false);
        const axiosError = error as AxiosError<any>;
        const errorMessage =
          axiosError.response?.data?.message ||
          t("holidays.messages.fetchError");

        return {
          success: false,
          message: errorMessage,
        };
      }
    },
    [t]
  );

  // Create Holiday
  const createHolidayService = useCallback(
    async (data: CreateHolidayData): Promise<ServiceResult<HolidayResponse["data"]>> => {
      setLoading(true);
      try {
        const response = await createHoliday(data);
        setLoading(false);

        if (response.data.success) {
          toast.success(
            response.data.message || t("holidays.messages.createSuccess")
          );
          return {
            success: true,
            message: response.data.message || t("holidays.messages.createSuccess"),
            data: response.data.data,
          };
        }

        toast.error(response.data.message || t("holidays.messages.createError"));
        return {
          success: false,
          message: response.data.message || t("holidays.messages.createError"),
        };
      } catch (error) {
        setLoading(false);
        const axiosError = error as AxiosError<any>;
        const errorMessage =
          axiosError.response?.data?.message ||
          t("holidays.messages.createError");

        toast.error(errorMessage);
        return {
          success: false,
          message: errorMessage,
        };
      }
    },
    [t]
  );

  // Bulk Create Holidays
  const bulkCreateHolidaysService = useCallback(
    async (data: BulkCreateHolidaysData): Promise<ServiceResult<BulkCreateHolidaysResponse["data"]>> => {
      setLoading(true);
      try {
        const response = await bulkCreateHolidays(data);
        setLoading(false);

        if (response.data.success) {
          toast.success(
            response.data.message || t("holidays.messages.bulkCreateSuccess")
          );
          return {
            success: true,
            message: response.data.message || t("holidays.messages.bulkCreateSuccess"),
            data: response.data.data,
          };
        }

        toast.error(response.data.message || t("holidays.messages.bulkCreateError"));
        return {
          success: false,
          message: response.data.message || t("holidays.messages.bulkCreateError"),
        };
      } catch (error) {
        setLoading(false);
        const axiosError = error as AxiosError<any>;
        const errorMessage =
          axiosError.response?.data?.message ||
          t("holidays.messages.bulkCreateError");

        toast.error(errorMessage);
        return {
          success: false,
          message: errorMessage,
        };
      }
    },
    [t]
  );

  // Update Holiday
  const updateHolidayService = useCallback(
    async (data: UpdateHolidayData): Promise<ServiceResult<HolidayResponse["data"]>> => {
      setLoading(true);
      try {
        const response = await updateHoliday(data);
        setLoading(false);

        if (response.data.success) {
          toast.success(
            response.data.message || t("holidays.messages.updateSuccess")
          );
          return {
            success: true,
            message: response.data.message || t("holidays.messages.updateSuccess"),
            data: response.data.data,
          };
        }

        toast.error(response.data.message || t("holidays.messages.updateError"));
        return {
          success: false,
          message: response.data.message || t("holidays.messages.updateError"),
        };
      } catch (error) {
        setLoading(false);
        const axiosError = error as AxiosError<any>;
        const errorMessage =
          axiosError.response?.data?.message ||
          t("holidays.messages.updateError");

        toast.error(errorMessage);
        return {
          success: false,
          message: errorMessage,
        };
      }
    },
    [t]
  );

  // Delete Holiday
  const deleteHolidayService = useCallback(
    async (id: string): Promise<ServiceResult<DeleteHolidayResponse>> => {
      setLoading(true);
      try {
        const response = await deleteHoliday(id);
        setLoading(false);

        if (response.data.success) {
          toast.success(
            response.data.message || t("holidays.messages.deleteSuccess")
          );
          return {
            success: true,
            message: response.data.message || t("holidays.messages.deleteSuccess"),
            data: response.data,
          };
        }

        toast.error(response.data.message || t("holidays.messages.deleteError"));
        return {
          success: false,
          message: response.data.message || t("holidays.messages.deleteError"),
        };
      } catch (error) {
        setLoading(false);
        const axiosError = error as AxiosError<any>;
        const errorMessage =
          axiosError.response?.data?.message ||
          t("holidays.messages.deleteError");

        toast.error(errorMessage);
        return {
          success: false,
          message: errorMessage,
        };
      }
    },
    [t]
  );

  // Delete Holidays by Year
  const deleteHolidaysByYearService = useCallback(
    async (year: number): Promise<ServiceResult<DeleteHolidayResponse>> => {
      setLoading(true);
      try {
        const response = await deleteHolidaysByYear(year);
        setLoading(false);

        if (response.data.success) {
          toast.success(
            response.data.message || t("holidays.messages.deleteYearSuccess")
          );
          return {
            success: true,
            message: response.data.message || t("holidays.messages.deleteYearSuccess"),
            data: response.data,
          };
        }

        toast.error(response.data.message || t("holidays.messages.deleteYearError"));
        return {
          success: false,
          message: response.data.message || t("holidays.messages.deleteYearError"),
        };
      } catch (error) {
        setLoading(false);
        const axiosError = error as AxiosError<any>;
        const errorMessage =
          axiosError.response?.data?.message ||
          t("holidays.messages.deleteYearError");

        toast.error(errorMessage);
        return {
          success: false,
          message: errorMessage,
        };
      }
    },
    [t]
  );

  return {
    loading,
    getHolidays: getHolidaysService,
    getHolidayById: getHolidayByIdService,
    createHoliday: createHolidayService,
    bulkCreateHolidays: bulkCreateHolidaysService,
    updateHoliday: updateHolidayService,
    deleteHoliday: deleteHolidayService,
    deleteHolidaysByYear: deleteHolidaysByYearService,
  };
}

export default useHolidayService;