useHazardousWasteRecords

import { useCallback } from 'react';
import { useSelector, useDispatch } from 'react-redux';
import {
  fetchHazardousWasteRecords,
  fetchHazardousWasteRecord,
  createHazardousWasteRecord,
  updateHazardousWasteRecord,
  deleteHazardousWasteRecord,
  fetchHazardousWasteRecordStatistics,
  setFilters,
  resetFilters,
  resetError,
  clearCurrentWasteRecord,
} from '../features/hazardousWasteRecords/hazardousWasteRecordsSlice';

const useHazardousWasteRecords = () => {
  const dispatch = useDispatch();
  const {
    wasteRecords,
    currentWasteRecord,
    statistics,
    loading,
    error,
    meta,
    filters,
  } = useSelector((state) => state.hazardousWasteRecords);
  // Load hazardous waste records
  const loadHazardousWasteRecords = useCallback((params = {}) => {
    return dispatch(fetchHazardousWasteRecords(params));
  }, [dispatch]);

  // Load single hazardous waste record
  const loadHazardousWasteRecord = useCallback((id, params = {}) => {
    return dispatch(fetchHazardousWasteRecord({ id, params }));
  }, [dispatch]);

  // Add new hazardous waste record
  const addHazardousWasteRecord = useCallback((recordData) => {
    return dispatch(createHazardousWasteRecord(recordData));
  }, [dispatch]);

  // Edit hazardous waste record
  const editHazardousWasteRecord = useCallback((id, data) => {
    return dispatch(updateHazardousWasteRecord({ id, data }));
  }, [dispatch]);

  // Remove hazardous waste record
  const removeHazardousWasteRecord = useCallback((id) => {
    return dispatch(deleteHazardousWasteRecord(id));
  }, [dispatch]);

  // Load statistics
  const loadStatistics = useCallback((params = {}) => {
    return dispatch(fetchHazardousWasteRecordStatistics(params));
  }, [dispatch]);

  // Update filters
  const updateFilters = useCallback((filters) => {
    dispatch(setFilters(filters));
  }, [dispatch]);

  // Reset filters
  const resetFiltersAction = useCallback(() => {
    dispatch(resetFilters());
  }, [dispatch]);

  // Reset error
  const resetErrorAction = useCallback(() => {
    dispatch(resetError());
  }, [dispatch]);

  // Clear current waste record
  const clearCurrentRecord = useCallback(() => {
    dispatch(clearCurrentWasteRecord());
  }, [dispatch]);

  return {
    // State
    wasteRecords,
    currentWasteRecord,
    statistics,
    loading,
    error,
    meta,
    filters,

    // Actions
    loadHazardousWasteRecords,
    loadHazardousWasteRecord,
    addHazardousWasteRecord,
    editHazardousWasteRecord,
    removeHazardousWasteRecord,
    loadStatistics,
    updateFilters,
    resetFilters: resetFiltersAction,
    resetError: resetErrorAction,
    clearCurrentRecord,
  };
};

export default useHazardousWasteRecords;