import { useState } from "react";
import {
  createActivityType,
  getActivityTypes,
  getActivityTypeById,
  updateActivityType,
  deleteActivityType,
  type ActivityTypeFilters,
  type CreateActivityTypeData,
  type UpdateActivityTypeData,
  type ActivityTypeListResponse,
  type ActivityTypeResponse,
  type DeleteActivityTypeResponse,
} from "../../services/activityTypeService";
import { handleToastError, customizeToast } from "../../utils";

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

  // Create Activity Type
  const createActivityTypeAsync = async (data: CreateActivityTypeData) => {
    try {
      setLoading(true);
      const response = await createActivityType(data);

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

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

  // Get Activity Type by ID
  const getActivityTypeByIdAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await getActivityTypeById(id);

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

  // Update Activity Type
  const updateActivityTypeAsync = async (data: UpdateActivityTypeData) => {
    try {
      setLoading(true);
      const response = await updateActivityType(data);

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

  // Delete Activity Type
  const deleteActivityTypeAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await deleteActivityType(id);

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

  return {
    loading,
    createActivityType: createActivityTypeAsync,
    getActivityTypes: getActivityTypesAsync,
    getActivityTypeById: getActivityTypeByIdAsync,
    updateActivityType: updateActivityTypeAsync,
    deleteActivityType: deleteActivityTypeAsync,
  };
}

export default useActivityTypeService;