thrilltrack-explorer/src/hooks/useModerationStats.ts

import { useEffect, useState, useRef, useCallback } from 'react';
import { supabase } from '@/integrations/supabase/client';

interface ModerationStats {
  pendingSubmissions: number;
  openReports: number;
  flaggedContent: number;
}

interface UseModerationStatsOptions {
  onStatsChange?: (stats: ModerationStats) => void;
  enabled?: boolean;
  pollingEnabled?: boolean;
  pollingInterval?: number;
}

export const useModerationStats = (options: UseModerationStatsOptions = {}) => {
  const { 
    onStatsChange, 
    enabled = true, 
    pollingEnabled = true,
    pollingInterval = 30000 // Default 30 seconds
  } = options;
  
  const [stats, setStats] = useState<ModerationStats>({
    pendingSubmissions: 0,
    openReports: 0,
    flaggedContent: 0,
  });
  
  const [isLoading, setIsLoading] = useState(true);
  const [isInitialLoad, setIsInitialLoad] = useState(true);
  const [lastUpdated, setLastUpdated] = useState<Date | null>(null);
  const onStatsChangeRef = useRef(onStatsChange);
  
  // Update ref when callback changes
  useEffect(() => {
    onStatsChangeRef.current = onStatsChange;
  }, [onStatsChange]);

  const fetchStats = useCallback(async (silent = false) => {
    if (!enabled) return;
    
    try {
      // Only show loading on initial load
      if (!silent) {
        setIsLoading(true);
      }
      
      const [submissionsResult, reportsResult, reviewsResult] = await Promise.all([
        supabase
          .from('content_submissions')
          .select('id', { count: 'exact', head: true })
          .eq('status', 'pending'),
        supabase
          .from('reports')
          .select('id', { count: 'exact', head: true })
          .eq('status', 'pending'),
        supabase
          .from('reviews')
          .select('id', { count: 'exact', head: true })
          .eq('moderation_status', 'flagged'),
      ]);

      const newStats = {
        pendingSubmissions: submissionsResult.count || 0,
        openReports: reportsResult.count || 0,
        flaggedContent: reviewsResult.count || 0,
      };

      setStats(newStats);
      setLastUpdated(new Date());
      onStatsChangeRef.current?.(newStats);
    } catch (error) {
      console.error('Error fetching moderation stats:', error);
    } finally {
      // Only clear loading if it was set
      if (!silent) {
        setIsLoading(false);
      }
      if (isInitialLoad) {
        setIsInitialLoad(false);
      }
    }
  }, [enabled, isInitialLoad]);

  // Initial fetch
  useEffect(() => {
    if (enabled) {
      fetchStats(false); // Show loading
    }
  }, [enabled, fetchStats]);

  // Polling
  useEffect(() => {
    if (!enabled || !pollingEnabled || isInitialLoad) return;

    const interval = setInterval(() => {
      fetchStats(true); // Silent refresh
    }, pollingInterval);

    return () => {
      clearInterval(interval);
    };
  }, [enabled, pollingEnabled, pollingInterval, fetchStats, isInitialLoad]);

  return { 
    stats, 
    refresh: fetchStats, 
    isLoading,
    lastUpdated 
  };
};