import { useState } from "react";
import {
  createTimeEntry,
  getTimeEntries,
  getTimeEntryById,
  updateTimeEntry,
  stopTimeEntry,
  deleteTimeEntry,
  type TimeTrackingFilters,
  type CreateTimeEntryData,
  type UpdateTimeEntryData,
  type TimeEntryListResponse,
  type TimeEntryResponse,
  type DeleteTimeEntryResponse,
} from "../../services/timeTrackingService";
import { handleToastError, customizeToast } from "../../utils";

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

  // Create Time Entry
  const createTimeEntryAsync = async (data: CreateTimeEntryData) => {
    try {
      setLoading(true);
      const response = await createTimeEntry(data);

      // Check if the response indicates success
      if (response?.data?.success !== false) {
        customizeToast("Time entry created successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Time entry created successfully",
        };
      } else {
        // Backend returned success: false, show the backend error message
        const errorMessage =
          response.data?.message || "Failed to create time entry";
        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 Time Entries
  const getTimeEntriesAsync = async (filters?: TimeTrackingFilters) => {
    try {
      setLoading(true);
      const response = await getTimeEntries(filters);

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

  // Get Time Entry by ID
  const getTimeEntryByIdAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await getTimeEntryById(id);

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

  // Update Time Entry
  const updateTimeEntryAsync = async (data: UpdateTimeEntryData) => {
    try {
      setLoading(true);
      const response = await updateTimeEntry(data);

      if (response?.data?.success !== false) {
        customizeToast("Time entry updated successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Time entry updated successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to update time entry";
        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);
    }
  };

  // Stop Time Entry
  const stopTimeEntryAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await stopTimeEntry(id);

      if (response?.data?.success !== false) {
        customizeToast("Activity stopped successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Activity stopped successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to stop activity";
        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 Time Entry
  const deleteTimeEntryAsync = async (id: string) => {
    try {
      setLoading(true);
      const response = await deleteTimeEntry(id);

      if (response?.data?.success !== false) {
        customizeToast("Time entry deleted successfully", "success");
        return {
          success: true,
          data: response.data,
          message:
            response.data?.message || "Time entry deleted successfully",
        };
      } else {
        const errorMessage =
          response.data?.message || "Failed to delete time entry";
        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,
    createTimeEntry: createTimeEntryAsync,
    getTimeEntries: getTimeEntriesAsync,
    getTimeEntryById: getTimeEntryByIdAsync,
    updateTimeEntry: updateTimeEntryAsync,
    stopTimeEntry: stopTimeEntryAsync,
    deleteTimeEntry: deleteTimeEntryAsync,
  };
}

export default useTimeTrackingService;