'use client';

import { useState, useEffect, useRef } from 'react';
import { useEarnLayer } from '../providers/EarnLayerProvider';
import { DisplayAd } from '../../core/types';

interface UseDisplayAdsOptions {
  conversationId?: string;
  autoRefresh?: boolean;
  refreshInterval?: number;
  pollInterval?: number;
  debug?: boolean;
}

export function useDisplayAds({
  conversationId: propConversationId,
  autoRefresh = true,
  refreshInterval = 30000,
  pollInterval = 5000,
  debug = false,
}: UseDisplayAdsOptions = {}) {
  const { client, conversationId: contextConversationId, isReady } = useEarnLayer();
  const [ads, setAds] = useState<DisplayAd[]>([]);
  const [currentAd, setCurrentAd] = useState<DisplayAd | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);
  
  const adIndexRef = useRef(0);
  const lastFetchRef = useRef<number>(0);

  const activeConversationId = propConversationId || contextConversationId;

  const fetchAds = async () => {
    if (!activeConversationId || !isReady) return;

    try {
      setLoading(true);
      setError(null);
      
      const ad = await client.getDisplayAd(activeConversationId);
      if (ad) {
        setAds([ad]);
        setCurrentAd(ad);
      }
      
      lastFetchRef.current = Date.now();
    } catch (err) {
      const error = err as Error;
      setError(error);
      
      if (debug) {
        console.error('[EarnLayer SDK - useDisplayAds] Error fetching ads:', {
          conversationId: activeConversationId,
          error: error.message,
          timestamp: new Date().toISOString()
        });
      }
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (!activeConversationId || !isReady) return undefined;

    fetchAds();

    if (autoRefresh && pollInterval > 0) {
      const interval = setInterval(() => {
        const timeSinceLastFetch = Date.now() - lastFetchRef.current;
        if (timeSinceLastFetch >= refreshInterval) {
          fetchAds();
        }
      }, pollInterval);

      return () => clearInterval(interval);
    }

    return undefined;
  }, [activeConversationId, isReady, autoRefresh, pollInterval, refreshInterval]);

  const nextAd = () => {
    if (ads.length === 0) return;
    
    adIndexRef.current = (adIndexRef.current + 1) % ads.length;
    setCurrentAd(ads[adIndexRef.current]);
  };

  const previousAd = () => {
    if (ads.length === 0) return;
    
    adIndexRef.current = (adIndexRef.current - 1 + ads.length) % ads.length;
    setCurrentAd(ads[adIndexRef.current]);
  };

  return {
    ads,
    currentAd,
    loading,
    error,
    refetch: fetchAds,
    nextAd,
    previousAd,
  };
}