/**
 * 캔들 데이터 로딩 커스텀 훅
 * - 캐싱 적용
 * - 중복 요청 방지
 * - 로딩 상태 관리
 * - 증분 업데이트 지원
 */

import { useState, useCallback, useRef, useEffect } from 'react';
import type { CandleData, IndicatorData } from '../services/backtestApi';
import {
  fetchCandlesOptimized,
  fetchIndicatorsOptimized,
  invalidateCandleCache,
  fetchCandlesIncremental,
} from '../services/optimizedCandleApi';

interface UseCandleDataOptions {
  symbol: string;
  interval: string;
  count?: number;
  enableAutoRefresh?: boolean;
  refreshInterval?: number;
}

interface UseCandleDataReturn {
  candles: CandleData[];
  indicators: IndicatorData[];
  loading: boolean;
  error: string | null;
  loadData: (options?: LoadDataOptions) => Promise<void>;
  refreshData: () => Promise<void>;
  invalidateCache: () => void;
}

interface LoadDataOptions {
  forceReset?: boolean;
  toTime?: string | null;
  isPrepend?: boolean;
  isAppend?: boolean;
  isIncremental?: boolean;
}

export function useCandleData(options: UseCandleDataOptions): UseCandleDataReturn {
  const {
    symbol,
    interval,
    count = 200,
    enableAutoRefresh = false,
    refreshInterval = 30000,
  } = options;

  const [candles, setCandles] = useState<CandleData[]>([]);
  const [indicators, setIndicators] = useState<IndicatorData[]>([]);
  const [loading, setLoading] = useState<boolean>(false);
  const [error, setError] = useState<string | null>(null);

  const loadingRef = useRef<boolean>(false);
  const symbolRef = useRef<string>(symbol);
  const intervalRef = useRef<string>(interval);

  // symbol/interval 변경 추적
  useEffect(() => {
    symbolRef.current = symbol;
    intervalRef.current = interval;
  }, [symbol, interval]);

  /**
   * 캔들 데이터 로드
   */
  const loadData = useCallback(async (loadOptions?: LoadDataOptions) => {
    const {
      forceReset = false,
      toTime = null,
      isPrepend = false,
      isAppend = false,
      isIncremental = false,
    } = loadOptions || {};

    // 중복 요청 방지
    if (loadingRef.current) {
      console.log(`⏳ [useCandleData] 이미 로딩 중, 스킵`);
      return;
    }

    try {
      loadingRef.current = true;
      setLoading(true);
      setError(null);

      const currentSymbol = symbolRef.current;
      const currentInterval = intervalRef.current;

      console.log(`📊 [useCandleData] 데이터 로드 시작:`, {
        symbol: currentSymbol,
        interval: currentInterval,
        count,
        isIncremental,
      });

      // 1. 캔들 데이터 로드
      let loadedCandles: CandleData[];
      
      if (isIncremental) {
        // 증분 업데이트: 최근 10개만
        loadedCandles = await fetchCandlesIncremental(currentSymbol, currentInterval, 10);
      } else {
        // 전체 로드
        loadedCandles = await fetchCandlesOptimized({
          symbol: currentSymbol,
          interval: currentInterval,
          count: count + 500, // 워밍업 포함
          to: toTime || undefined,
        });
      }

      // symbol이 변경되었으면 중단
      if (symbolRef.current !== currentSymbol || intervalRef.current !== currentInterval) {
        console.log(`⚠️ [useCandleData] Symbol/Interval 변경됨, 중단`);
        return;
      }

      // 2. 표시용 캔들 추출
      const displayCandles = loadedCandles.slice(-count);
      const calculationCandles = loadedCandles; // 전체 (워밍업 포함)

      // 3. 보조지표 계산
      console.log(`📈 [useCandleData] 지표 계산 시작: ${calculationCandles.length}개`);
      const loadedIndicators = await fetchIndicatorsOptimized({
        symbol: currentSymbol,
        interval: currentInterval,
        candles: calculationCandles,
        maPeriods: [5, 10, 20, 60, 120],
        indicatorSettings: {},
      });

      // symbol이 변경되었으면 중단
      if (symbolRef.current !== currentSymbol || intervalRef.current !== currentInterval) {
        console.log(`⚠️ [useCandleData] Symbol/Interval 변경됨, 중단`);
        return;
      }

      // 4. 상태 업데이트
      const displayIndicators = loadedIndicators.slice(-count);

      if (isPrepend) {
        setCandles(prev => [...displayCandles, ...prev]);
        setIndicators(prev => [...displayIndicators, ...prev]);
      } else if (isAppend) {
        setCandles(prev => [...prev, ...displayCandles]);
        setIndicators(prev => [...prev, ...displayIndicators]);
      } else if (isIncremental && candles.length > 0) {
        // 증분: 마지막 캔들만 업데이트
        setCandles(prev => {
          const updated = [...prev];
          const lastIdx = updated.length - 1;
          if (lastIdx >= 0 && loadedCandles.length > 0) {
            updated[lastIdx] = loadedCandles[loadedCandles.length - 1];
          }
          return updated;
        });
        setIndicators(prev => {
          const updated = [...prev];
          const lastIdx = updated.length - 1;
          if (lastIdx >= 0 && displayIndicators.length > 0) {
            updated[lastIdx] = displayIndicators[displayIndicators.length - 1];
          }
          return updated;
        });
      } else {
        setCandles(displayCandles);
        setIndicators(displayIndicators);
      }

      console.log(`✅ [useCandleData] 로드 완료: ${displayCandles.length}개`);
    } catch (err) {
      console.error('❌ [useCandleData] 로드 실패:', err);
      setError(err instanceof Error ? err.message : '데이터 로드 실패');
    } finally {
      loadingRef.current = false;
      setLoading(false);
    }
  }, [symbol, interval, count, candles.length]);

  /**
   * 데이터 새로고침 (캐시 무효화 + 재로드)
   */
  const refreshData = useCallback(async () => {
    console.log(`🔄 [useCandleData] 새로고침`);
    invalidateCandleCache(symbolRef.current, intervalRef.current);
    await loadData({ forceReset: true });
  }, [loadData]);

  /**
   * 캐시 무효화
   */
  const invalidateCache = useCallback(() => {
    invalidateCandleCache(symbolRef.current, intervalRef.current);
  }, []);

  // symbol/interval 변경 시 초기 로드
  useEffect(() => {
    loadData({ forceReset: true });
  }, [symbol, interval]);

  // 자동 새로고침
  useEffect(() => {
    if (!enableAutoRefresh || refreshInterval <= 0) {
      return;
    }

    console.log(`⏰ [useCandleData] 자동 새로고침 시작 (${refreshInterval}ms)`);
    const timerId = setInterval(() => {
      if (!loadingRef.current) {
        loadData({ isIncremental: true });
      }
    }, refreshInterval);

    return () => {
      console.log(`🛑 [useCandleData] 자동 새로고침 중지`);
      clearInterval(timerId);
    };
  }, [enableAutoRefresh, refreshInterval, loadData]);

  return {
    candles,
    indicators,
    loading,
    error,
    loadData,
    refreshData,
    invalidateCache,
  };
}
