/**
 * Throttled Market Data Hook
 * - WebSocket으로 실시간 데이터 수신
 * - 설정된 갱신 간격마다 차트 업데이트
 * - 데이터는 내부 버퍼에 실시간 저장, 차트는 주기적으로 업데이트
 */
import { useState, useEffect, useRef, useCallback } from 'react';
import { useMarketDataWebSocket } from './useMarketDataWebSocket';

interface Candle {
  timestamp: number;
  open: number;
  high: number;
  low: number;
  close: number;
  volume: number;
  is_closed?: boolean;
  trade_count?: number;
}

interface Indicators {
  rsi_14?: number;
  ema_9?: number;
  ema_21?: number;
  macd?: number;
  macd_signal?: number;
  macd_histogram?: number;
  bb_upper?: number;
  bb_middle?: number;
  bb_lower?: number;
  stoch_k?: number;
  stoch_d?: number;
  adx?: number;
  plus_di?: number;
  minus_di?: number;
}

interface UseThrottledMarketDataOptions {
  market: string;
  timeframe: string;
  updateIntervalMs?: number; // 차트 갱신 간격 (밀리초, 기본 5000ms = 5초)
  enabled?: boolean;
  onError?: (error: any) => void;
}

export const useThrottledMarketData = ({
  market,
  timeframe,
  updateIntervalMs = 5000, // 기본 5초
  enabled = true,
  onError,
}: UseThrottledMarketDataOptions) => {
  // WebSocket으로 실시간 데이터 수신 (내부 버퍼)
  const [bufferCandles, setBufferCandles] = useState<Candle[]>([]);
  const [bufferIndicators, setBufferIndicators] = useState<Indicators>({});
  const [lastUpdateTime, setLastUpdateTime] = useState<number>(Date.now());
  
  // 차트에 표시될 데이터 (주기적으로 업데이트)
  const [displayCandles, setDisplayCandles] = useState<Candle[]>([]);
  const [displayIndicators, setDisplayIndicators] = useState<Indicators>({});
  const [updateCount, setUpdateCount] = useState(0);
  
  // WebSocket Hook 사용 (실시간 데이터를 버퍼에 저장)
  const { status, candles: wsCandles, indicators: wsIndicators } = useMarketDataWebSocket({
    market,
    timeframe,
    enabled,
    onData: ({ candles, indicators }) => {
      // 실시간 데이터를 버퍼에 즉시 저장
      if (candles.length > 0) {
        setBufferCandles(candles);
        setBufferIndicators(indicators);
      }
    },
    onError,
  });
  
  // 주기적으로 버퍼 데이터를 차트에 반영
  useEffect(() => {
    if (!enabled) return;
    
    const intervalId = setInterval(() => {
      const now = Date.now();
      const timeSinceLastUpdate = now - lastUpdateTime;
      
      // 버퍼에 데이터가 있으면 차트에 반영
      if (bufferCandles.length > 0) {
        setDisplayCandles(bufferCandles);
        setDisplayIndicators(bufferIndicators);
        setLastUpdateTime(now);
        setUpdateCount(prev => prev + 1);
        
        console.log(
          `[Throttled Update] 차트 갱신 #${updateCount + 1} ` +
          `(간격: ${timeSinceLastUpdate}ms, 캔들: ${bufferCandles.length}개)`
        );
      }
    }, updateIntervalMs);
    
    return () => clearInterval(intervalId);
  }, [enabled, updateIntervalMs, bufferCandles, bufferIndicators, lastUpdateTime, updateCount]);
  
  // 초기 데이터는 즉시 표시
  useEffect(() => {
    if (wsCandles.length > 0 && displayCandles.length === 0) {
      setDisplayCandles(wsCandles);
      setDisplayIndicators(wsIndicators);
      setBufferCandles(wsCandles);
      setBufferIndicators(wsIndicators);
      setLastUpdateTime(Date.now());
      console.log('[Throttled Update] 초기 데이터 로드:', wsCandles.length);
    }
  }, [wsCandles, wsIndicators, displayCandles.length]);
  
  // 수동 갱신 함수
  const refreshNow = useCallback(() => {
    if (bufferCandles.length > 0) {
      setDisplayCandles(bufferCandles);
      setDisplayIndicators(bufferIndicators);
      setLastUpdateTime(Date.now());
      setUpdateCount(prev => prev + 1);
      console.log('[Throttled Update] 수동 갱신 실행');
    }
  }, [bufferCandles, bufferIndicators]);
  
  return {
    status,
    candles: displayCandles,
    indicators: displayIndicators,
    updateCount, // 갱신 횟수
    lastUpdateTime, // 마지막 갱신 시간
    nextUpdateIn: Math.max(0, updateIntervalMs - (Date.now() - lastUpdateTime)), // 다음 갱신까지 남은 시간
    refreshNow, // 수동 갱신 함수
  };
};
