/**
 * Unified Refresh Hook
 * 
 * Provides consistent refresh functionality for all widgets and notifications.
 * Handles registration, cleanup, and manual refresh triggers.
 */

import { useEffect, useCallback, useRef } from 'react';
import { useSession } from 'next-auth/react';
import { refreshManager, RefreshableResource } from '@/lib/services/refresh-manager';

interface UseUnifiedRefreshOptions {
  resource: RefreshableResource;
  interval: number;
  enabled?: boolean;
  onRefresh: () => Promise<void>;
  priority?: 'high' | 'medium' | 'low';
}

/**
 * Hook for unified refresh management
 * 
 * @example
 * ```tsx
 * const { refresh } = useUnifiedRefresh({
 *   resource: 'calendar',
 *   interval: 300000, // 5 minutes
 *   enabled: status === 'authenticated',
 *   onRefresh: fetchEvents,
 *   priority: 'low',
 * });
 * ```
 */
export function useUnifiedRefresh({
  resource,
  interval,
  enabled = true,
  onRefresh,
  priority = 'medium',
}: UseUnifiedRefreshOptions) {
  const { status } = useSession();
  const onRefreshRef = useRef(onRefresh);
  const isMountedRef = useRef(true);

  // Update callback ref when it changes
  useEffect(() => {
    onRefreshRef.current = onRefresh;
  }, [onRefresh]);

  // Register/unregister with refresh manager
  useEffect(() => {
    const isAuthenticated = status === 'authenticated';
    const shouldEnable = enabled && isAuthenticated;

    if (!shouldEnable) {
      // Unregister if disabled or not authenticated
      refreshManager.unregister(resource);
      return;
    }

    isMountedRef.current = true;

    console.log(`[useUnifiedRefresh] Registering ${resource} (interval: ${interval}ms, priority: ${priority})`);

    // Register with refresh manager
    refreshManager.register({
      resource,
      interval,
      enabled: true,
      priority,
      onRefresh: async () => {
        if (isMountedRef.current) {
          await onRefreshRef.current();
        }
      },
    });

    // Start refresh manager if not already started
    refreshManager.start();

    // Cleanup
    return () => {
      console.log(`[useUnifiedRefresh] Cleaning up ${resource}`);
      isMountedRef.current = false;
      refreshManager.unregister(resource);
    };
  }, [resource, interval, enabled, priority, status]);

  // Manual refresh function
  const refresh = useCallback(
    async (force = false) => {
      if (status !== 'authenticated') {
        console.warn(`[useUnifiedRefresh] Cannot refresh ${resource}: not authenticated`);
        return;
      }
      
      console.log(`[useUnifiedRefresh] Manual refresh triggered for ${resource} (force: ${force})`);
      await refreshManager.refresh(resource, force);
    },
    [resource, status]
  );

  return {
    refresh,
    isActive: refreshManager.getStatus().active,
  };
}