import React, { createContext, useContext, useState, useEffect, useRef, useCallback } from 'react';
import { 
  getUserIndicatorSettings, 
  saveUserIndicatorSettings, 
  getGuestIndicatorSettings, 
  saveGuestIndicatorSettings 
} from '../services/indicatorSettingsApi';
import { getStorageMode, loadFromFile, saveToFile } from '../services/investmentAnalysisSettingsStorage';

// 이동평균선 개별 설정
export interface MALineConfig {
  id: string;           // MA1, MA2, ... MA8
  enabled: boolean;     // 활성화 여부
  period: number;       // 기간 (5, 10, 20, 60, 120, 200, 300, 480 등)
  color: string;        // 색상 (#RRGGBB)
  width: number;        // 선 굵기 (1~5)
  type: 'SMA' | 'EMA';  // ❌ 이동평균 유형 (SMA 고정, EMA 사용 안 함)
}

// 기본 이동평균선 설정 (8개)
export const defaultMALines: MALineConfig[] = [
  { id: 'MA1', enabled: true, period: 5, color: '#000000', width: 1, type: 'SMA' },
  { id: 'MA2', enabled: true, period: 10, color: '#00E676', width: 1, type: 'SMA' },
  { id: 'MA3', enabled: true, period: 20, color: '#2962FF', width: 1, type: 'SMA' },
  { id: 'MA4', enabled: true, period: 60, color: '#00E5FF', width: 1, type: 'SMA' },
  { id: 'MA5', enabled: false, period: 120, color: '#FFEB3B', width: 1, type: 'SMA' },
  { id: 'MA6', enabled: false, period: 200, color: '#9E9E9E', width: 1, type: 'SMA' },
  { id: 'MA7', enabled: false, period: 300, color: '#2E7D32', width: 1, type: 'SMA' },
  { id: 'MA8', enabled: false, period: 480, color: '#7B1FA2', width: 1, type: 'SMA' },
];

export interface IndicatorVisibilitySettings {
  // 주가 캔들차트는 항상 표시 (변경 불가)
  candleChart: boolean;
  
  // 주가 히스토그램
  priceHistogram: boolean;
  
  // 거래량 (캔들차트 아래 별도 차트)
  volume: boolean;
  
  // 거래량 (보조지표 통합 차트에 오버레이)
  volumeIndicator: boolean;
  
  // 1. 신심리도 (New Psychological Line)
  newPsychological: boolean;
  
  // 2. 투자심리도 (Investor Psychological Line)
  investPsychological: boolean;
  
  // 3. MACD
  macdLine: boolean;
  macdHistogram: boolean;
  
  // 4. CCI (Commodity Channel Index)
  cci: boolean;
  
  // 5. ADX (Average Directional Index)
  adx: boolean;
  
  // 6. BWI (Bollinger Band Width Index)
  bwi: boolean;
  
  // 7. DMI (+DI, -DI)
  plusDi: boolean;
  minusDi: boolean;
  
  // 8. OBV (On Balance Volume)
  obv: boolean;
  
  // 9. RSI (Relative Strength Index)
  rsi: boolean;
  
  // 10. Stochastic Slow
  stochasticSlow: boolean;
  stochasticK: boolean;
  stochasticD: boolean;
  
  // 11. Williams %R
  williamsR: boolean;
  
  // 12. Momentum
  momentum: boolean;
  
  // 12. TRIX
  trix: boolean;
  trixSignal: boolean;
  
  // 13. VolumeOSC (Volume Oscillator)
  volumeOsc: boolean;
  
  // 14. VR (Volume Ratio)
  vr: boolean;
  
  // 15. 이격도 (Disparity Index)
  disparity: boolean;
  
  // 일목균형표 (캔들차트 오버레이) - 별도 유지
  ichimokuTenkan: boolean;    // 전환선
  ichimokuKijun: boolean;     // 기준선
  ichimokuChikou: boolean;    // 후행스팬
  ichimokuSenkouA: boolean;   // 선행스팬1
  ichimokuSenkouB: boolean;   // 선행스팬2
  
  // 일목균형표 기간 설정
  ichimokuTenkanPeriod: number;   // 전환선 기간 (기본 9)
  ichimokuKijunPeriod: number;    // 기준선 기간 (기본 26)
  ichimokuChikouPeriod: number;   // 후행스팬 기간 (기본 26)
  ichimokuSenkouAPeriod: number;  // 선행스팬1 기간 (기본 26)
  ichimokuSenkouBPeriod: number;  // 선행스팬2 기간 (기본 52)
  
  // 볼린저 밴드 (캔들차트 오버레이)
  bollingerUpper: boolean;    // 상한선
  bollingerMiddle: boolean;   // 중간선
  bollingerLower: boolean;    // 하한선
  
  // 볼린저 밴드 기간 설정
  bollingerPeriod: number;    // 기간 (기본 20)
  bollingerStdDev: number;    // 표준편차 승수 (기본 2.0)
  
  // 이동평균선 (캔들차트 오버레이) - 기존 호환용
  ma10: boolean;
  ma20: boolean;
  ma50: boolean;
  ma60: boolean;
  ma120: boolean;
  ma200: boolean;
  ma300: boolean;
  ma480: boolean;
  
  // 새로운 이동평균선 설정 (사용자 정의)
  maLines: MALineConfig[];
  
  // 툴팁 표시 여부
  tooltipEnabled: boolean;
  
  // 그리드 표시 여부
  showGrid: boolean;
  
  // 보조지표 차트 높이 (기본 70px)
  indicatorHeight: number;
}

export interface IndicatorOrder {
  id: string;
  label: string;
  settingKey: keyof IndicatorVisibilitySettings;
  description: string;
  category: string;
}

// 15가지 보조지표 순서 (사용자 요청대로)
export const defaultOrder: IndicatorOrder[] = [
  { id: 'candleChart', label: '캔들차트', settingKey: 'candleChart', description: '항상 최상단 표시 (변경 불가)', category: 'basic' },
  { id: 'volume', label: '거래량', settingKey: 'volume', description: '거래량 차트', category: 'basic' },
  { id: 'newPsychological', label: '신심리도', settingKey: 'newPsychological', description: '신심리도 (5)', category: 'indicator' },
  { id: 'investPsychological', label: '투자심리도', settingKey: 'investPsychological', description: '투자심리도 (10)', category: 'indicator' },
  { id: 'macdLine', label: 'MACD', settingKey: 'macdLine', description: 'MACD (12, 26, 9)', category: 'indicator' },
  { id: 'cci', label: 'CCI', settingKey: 'cci', description: 'CCI (기간:13, 신호:10)', category: 'indicator' },
  { id: 'adx', label: 'ADX', settingKey: 'adx', description: 'ADX (11)', category: 'indicator' },
  { id: 'bwi', label: 'BWI', settingKey: 'bwi', description: 'BWI (20)', category: 'indicator' },
  { id: 'plusDi', label: 'DMI (+DI)', settingKey: 'plusDi', description: 'DMI +DI (14)', category: 'indicator' },
  { id: 'minusDi', label: 'DMI (-DI)', settingKey: 'minusDi', description: 'DMI -DI (14)', category: 'indicator' },
  { id: 'obv', label: 'OBV', settingKey: 'obv', description: 'OBV (기간:9, 신호:9)', category: 'indicator' },
  { id: 'rsi', label: 'RSI', settingKey: 'rsi', description: 'RSI (기간:9, 신호:9)', category: 'indicator' },
  { id: 'stochasticK', label: 'Stochastic Slow', settingKey: 'stochasticK', description: 'Stochastic Slow (12, 5, 5)', category: 'indicator' },
  { id: 'williamsR', label: 'Williams %R', settingKey: 'williamsR', description: 'Williams %R (11)', category: 'indicator' },
  { id: 'trix', label: 'TRIX', settingKey: 'trix', description: 'TRIX (12, 9)', category: 'indicator' },
  { id: 'volumeOsc', label: 'VolumeOSC', settingKey: 'volumeOsc', description: 'VolumeOSC (10, 20)', category: 'indicator' },
  { id: 'vr', label: 'VR', settingKey: 'vr', description: 'VR (10)', category: 'indicator' },
  { id: 'disparity', label: '이격도', settingKey: 'disparity', description: '이격도', category: 'indicator' },
];

const defaultSettings: IndicatorVisibilitySettings = {
  candleChart: true,  // 항상 true (변경 불가)
  priceHistogram: false,  // 삭제됨 (사용 안 함)
  volume: true,  // ✅ 거래량 차트 - 캔들차트 아래 (초기값 ON으로 변경)
  volumeIndicator: false,  // 거래량 - 보조지표 통합 차트 (초기값 off)
  
  // 15가지 보조지표 기본값
  newPsychological: false,  // 신심리도 초기값 off
  investPsychological: false,  // 투자심리도 초기값 off
  macdLine: true,  // MACD 초기값 on
  macdHistogram: true,  // MACD 히스토그램 초기값 on
  cci: true,  // CCI 초기값 on (테스트용)
  adx: false,  // ADX 초기값 off
  bwi: false,  // BWI 초기값 off
  plusDi: false,  // +DI 초기값 off
  minusDi: false,  // -DI 초기값 off
  obv: true,  // ✅ OBV 초기값 ON으로 변경
  rsi: false,  // RSI 초기값 off
  stochasticSlow: true,  // Stochastic Slow 초기값 on
  stochasticK: false,  // Stochastic %K 초기값 off
  stochasticD: false,  // Stochastic %D 초기값 off
  williamsR: false,  // Williams %R 초기값 off
  momentum: false,  // Momentum 초기값 off
  trix: false,  // TRIX 초기값 off
  trixSignal: false,  // TRIX Signal 초기값 off
  volumeOsc: false,  // VolumeOSC 초기값 off
  vr: false,  // VR 초기값 off
  disparity: false,  // 이격도 초기값 off
  
  // 일목균형표 (캔들차트 오버레이) - 별도 유지
  ichimokuTenkan: false,    // 전환선 (기본 OFF)
  ichimokuKijun: false,     // 기준선 (기본 OFF)
  ichimokuChikou: false,    // 후행스팬 (기본 OFF)
  ichimokuSenkouA: false,   // 선행스팬1 (기본 OFF)
  ichimokuSenkouB: false,   // 선행스팬2 (기본 OFF)
  
  // 일목균형표 기간 설정
  ichimokuTenkanPeriod: 9,     // 전환선 기간 (기본 9)
  ichimokuKijunPeriod: 26,     // 기준선 기간 (기본 26)
  ichimokuChikouPeriod: 26,    // 후행스팬 기간 (기본 26)
  ichimokuSenkouAPeriod: 26,   // 선행스팬1 기간 (기본 26)
  ichimokuSenkouBPeriod: 52,   // 선행스팬2 기간 (기본 52)
  
  // 볼린저 밴드 (캔들차트 오버레이)
  bollingerUpper: false,    // 상한선 (기본 OFF)
  bollingerMiddle: false,   // 중간선 (기본 OFF)
  bollingerLower: false,    // 하한선 (기본 OFF)
  
  // 볼린저 밴드 기간 설정
  bollingerPeriod: 20,    // 기간 (기본 20)
  bollingerStdDev: 2.0,   // 표준편차 승수 (기본 2.0)
  
  // 이동평균선 (캔들차트 오버레이) - 기존 호환용
  ma10: false,   // 10일선
  ma20: true,    // 20일선 (기본 ON)
  ma50: false,   // 50일선
  ma60: true,    // 60일선 (기본 ON)
  ma120: false,  // 120일선
  ma200: false,  // 200일선
  ma300: false,  // 300일선
  ma480: false,  // 480일선
  
  // 새로운 이동평균선 설정 (사용자 정의)
  maLines: defaultMALines,
  
  // 툴팁
  tooltipEnabled: false,  // 툴팁 표시 (기본 OFF)
  // 그리드 표시
  showGrid: true,  // 그리드 표시 (기본 ON)
  // 보조지표 차트 높이
  indicatorHeight: 70,  // 기본 높이 70px (30~150 범위)
};

interface IndicatorVisibilityContextType {
  settings: IndicatorVisibilitySettings;
  order: IndicatorOrder[];
  updateSettings: (newSettings: Partial<IndicatorVisibilitySettings>) => void;
  updateOrder: (newOrder: IndicatorOrder[]) => void;
  updateMALines: (newMALines: MALineConfig[]) => void;
  updateSingleMALine: (index: number, updates: Partial<MALineConfig>) => void;
  resetSettings: () => void;
  loadUserSettings: (isAuthenticated: boolean) => Promise<void>;
  saveSettings: (isAuthenticated: boolean) => Promise<void>;
  setAuthState: (isAuthenticated: boolean) => void;
  maLinesVersion: number;  // ✅ MA 설정 변경 추적용 버전 번호
}

const IndicatorVisibilityContext = createContext<IndicatorVisibilityContextType | undefined>(undefined);

const STORAGE_KEY = 'indicatorVisibilitySettings';
const ORDER_STORAGE_KEY = 'indicatorOrderSettings';

export const IndicatorVisibilityProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [settings, setSettings] = useState<IndicatorVisibilitySettings>(defaultSettings);
  const [order, setOrder] = useState<IndicatorOrder[]>(defaultOrder);
  const [isAuth, setIsAuth] = useState<boolean>(false);
  const [maLinesVersion, setMaLinesVersion] = useState<number>(0);  // ✅ MA 설정 변경 추적용 버전 번호
  const saveTimeoutRef = useRef<NodeJS.Timeout | null>(null);
  const isInitialLoadRef = useRef<boolean>(true);

  // 설정이 변경될 때 자동 저장 (debounce 500ms)
  useEffect(() => {
    // 초기 로드 시에는 저장하지 않음
    if (isInitialLoadRef.current) {
      return;
    }
    
    // 기존 타이머가 있으면 취소
    if (saveTimeoutRef.current) {
      clearTimeout(saveTimeoutRef.current);
    }
    
    // 500ms 후에 저장
    saveTimeoutRef.current = setTimeout(() => {
      saveSettingsInternal(isAuth);
    }, 500);

    return () => {
      if (saveTimeoutRef.current) {
        clearTimeout(saveTimeoutRef.current);
      }
    };
  }, [settings, order, isAuth]);

  const saveSettingsInternal = async (isAuthenticated: boolean) => {
    const storageMode = getStorageMode();
    if (storageMode === 'file') {
      try {
        saveToFile({ indicatorSettings: settings, indicatorOrder: order });
        console.log('✅ 투자분석 설정 자동 저장 완료 (파일)');
      } catch (error) {
        console.error('투자분석 설정 파일 저장 실패:', error);
      }
      return;
    }
    const settingsData = JSON.stringify({ settings, order });
    if (isAuthenticated) {
      try {
        await saveUserIndicatorSettings(settingsData);
        console.log('✅ 사용자 설정 자동 저장 완료 (DB)');
      } catch (error) {
        console.error('사용자 설정 자동 저장 실패:', error);
      }
    } else {
      try {
        await saveGuestIndicatorSettings(settingsData);
        console.log('✅ 게스트 설정 자동 저장 완료 (DB)');
      } catch (error) {
        console.error('게스트 설정 자동 저장 실패, localStorage로 fallback:', error);
        localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
        localStorage.setItem(ORDER_STORAGE_KEY, JSON.stringify(order));
      }
    }
  };

  const setAuthState = useCallback((isAuthenticated: boolean) => {
    setIsAuth(isAuthenticated);
    // 인증 상태 변경 시 설정 로드
    loadUserSettings(isAuthenticated);
  }, []);

  // 마운트 시 DB에서 설정 로드 (초기 로드)
  useEffect(() => {
    const isAuthenticated = !!localStorage.getItem('accessToken');
    setIsAuth(isAuthenticated);
    loadUserSettings(isAuthenticated);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  const loadUserSettings = async (isAuthenticated: boolean) => {
    const storageMode = getStorageMode();
    if (storageMode === 'file') {
      const fileConfig = loadFromFile();
      if (fileConfig?.indicatorSettings || fileConfig?.indicatorOrder) {
        if (fileConfig.indicatorSettings) {
          setSettings({ ...defaultSettings, ...fileConfig.indicatorSettings, candleChart: true });
        }
        if (fileConfig.indicatorOrder && fileConfig.indicatorOrder.length > 0) {
          const migrateOrder = (loadedOrder: IndicatorOrder[]): IndicatorOrder[] => {
            const validIds = defaultOrder.map(item => item.id);
            const filteredOrder = loadedOrder.filter(item => validIds.includes(item.id));
            const existingIds = filteredOrder.map(item => item.id);
            const missingItems = defaultOrder.filter(item => !existingIds.includes(item.id));
            if (missingItems.length > 0) {
              missingItems.forEach(missingItem => {
                if (missingItem.id === 'volume') {
                  const candleIndex = filteredOrder.findIndex(item => item.id === 'candleChart');
                  if (candleIndex !== -1) filteredOrder.splice(candleIndex + 1, 0, missingItem);
                  else filteredOrder.push(missingItem);
                } else {
                  filteredOrder.push(missingItem);
                }
              });
            }
            return filteredOrder;
          };
          setOrder(migrateOrder(fileConfig.indicatorOrder));
        }
        console.log('✅ 투자분석 설정 로드 완료 (파일)');
      }
      setTimeout(() => { isInitialLoadRef.current = false; }, 100);
      return;
    }
    // order 마이그레이션 함수: 유효한 항목만 유지 + 누락된 항목 추가
    const migrateOrder = (loadedOrder: IndicatorOrder[]): IndicatorOrder[] => {
      const validIds = defaultOrder.map(item => item.id);
      const filteredOrder = loadedOrder.filter(item => validIds.includes(item.id));
      
      // 기존 order에 없는 새 항목들 추가 (예: volume이 분리되어 새로 추가된 경우)
      const existingIds = filteredOrder.map(item => item.id);
      const missingItems = defaultOrder.filter(item => !existingIds.includes(item.id));
      
      // 누락된 항목을 적절한 위치에 삽입 (candleChart 다음에 volume 추가)
      if (missingItems.length > 0) {
        missingItems.forEach(missingItem => {
          const defaultIndex = defaultOrder.findIndex(d => d.id === missingItem.id);
          // candleChart 바로 다음 위치에 삽입
          if (missingItem.id === 'volume') {
            const candleIndex = filteredOrder.findIndex(item => item.id === 'candleChart');
            if (candleIndex !== -1) {
              filteredOrder.splice(candleIndex + 1, 0, missingItem);
            } else {
              filteredOrder.push(missingItem);
            }
          } else {
            filteredOrder.push(missingItem);
          }
        });
      }
      
      return filteredOrder;
    };

    if (isAuthenticated) {
      // 로그인 상태: 사용자 계정 DB에서 읽기
      try {
        const savedSettings = await getUserIndicatorSettings();
        if (savedSettings && savedSettings !== '{}') {
          const parsed = JSON.parse(savedSettings);
          setSettings({ ...defaultSettings, ...parsed.settings, candleChart: true });
          // 기존 order에서 삭제된 항목 제거 + 누락된 항목 추가
          const migratedOrder = parsed.order ? migrateOrder(parsed.order) : defaultOrder;
          setOrder(migratedOrder.length > 0 ? migratedOrder : defaultOrder);
          console.log('✅ 사용자 설정 로드 완료 (DB)');
        }
      } catch (error) {
        console.error('사용자 설정 로드 실패:', error);
      }
    } else {
      // 비로그인 상태: 게스트 deviceId로 DB에서 읽기
      try {
        const savedSettings = await getGuestIndicatorSettings();
        if (savedSettings && savedSettings !== '{}') {
          const parsed = JSON.parse(savedSettings);
          setSettings({ ...defaultSettings, ...parsed.settings, candleChart: true });
          const migratedOrder = parsed.order ? migrateOrder(parsed.order) : defaultOrder;
          setOrder(migratedOrder.length > 0 ? migratedOrder : defaultOrder);
          console.log('✅ 게스트 설정 로드 완료 (DB)');
        } else {
          // DB에 없으면 localStorage에서 마이그레이션 시도
          const localSettings = localStorage.getItem(STORAGE_KEY);
          const localOrder = localStorage.getItem(ORDER_STORAGE_KEY);
          
          if (localSettings) {
            try {
              const parsed = JSON.parse(localSettings);
              setSettings({ ...defaultSettings, ...parsed, candleChart: true });
            } catch (e) {
              console.error('로컬 설정 파싱 실패:', e);
            }
          }
          
          if (localOrder) {
            try {
              const loadedOrder = JSON.parse(localOrder);
              const migratedOrder = migrateOrder(loadedOrder);
              setOrder(migratedOrder.length > 0 ? migratedOrder : defaultOrder);
            } catch (e) {
              console.error('로컬 순서 설정 파싱 실패:', e);
            }
          }
        }
      } catch (error) {
        console.error('게스트 설정 로드 실패, localStorage로 fallback:', error);
        // DB 로드 실패 시 localStorage에서 읽기
        const savedSettings = localStorage.getItem(STORAGE_KEY);
        const savedOrder = localStorage.getItem(ORDER_STORAGE_KEY);
        
        if (savedSettings) {
          try {
            const parsed = JSON.parse(savedSettings);
            setSettings({ ...defaultSettings, ...parsed, candleChart: true });
          } catch (e) {
            console.error('로컬 설정 로드 실패:', e);
          }
        }
        
        if (savedOrder) {
          try {
            const loadedOrder = JSON.parse(savedOrder);
            const migratedOrder = migrateOrder(loadedOrder);
            setOrder(migratedOrder.length > 0 ? migratedOrder : defaultOrder);
          } catch (e) {
            console.error('로컬 순서 설정 로드 실패:', e);
          }
        }
      }
    }
    
    // 초기 로드 완료 표시 (이후 변경 시에만 자동 저장)
    setTimeout(() => {
      isInitialLoadRef.current = false;
    }, 100);
  };

  const saveSettings = async (isAuthenticated: boolean) => {
    const storageMode = getStorageMode();
    if (storageMode === 'file') {
      try {
        saveToFile({ indicatorSettings: settings, indicatorOrder: order });
        console.log('✅ 투자분석 설정 저장 완료 (파일)');
      } catch (error) {
        console.error('투자분석 설정 파일 저장 실패:', error);
      }
      return;
    }
    const settingsData = JSON.stringify({ settings, order });
    if (isAuthenticated) {
      try {
        await saveUserIndicatorSettings(settingsData);
        console.log('✅ 사용자 설정 저장 완료 (DB)');
      } catch (error) {
        console.error('사용자 설정 저장 실패:', error);
      }
    } else {
      try {
        await saveGuestIndicatorSettings(settingsData);
        console.log('✅ 게스트 설정 저장 완료 (DB)');
      } catch (error) {
        console.error('게스트 설정 저장 실패, localStorage로 fallback:', error);
        localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
        localStorage.setItem(ORDER_STORAGE_KEY, JSON.stringify(order));
      }
    }
  };

  const updateSettings = (newSettings: Partial<IndicatorVisibilitySettings>) => {
    console.log('🔧 [updateSettings] 호출됨:', newSettings);
    // candleChart는 변경 불가
    const { candleChart, ...rest } = newSettings;
    setSettings(prev => {
      const updated = { ...prev, ...rest };
      console.log('🔧 [updateSettings] 업데이트 후:', { 
        ichimokuSenkouA: updated.ichimokuSenkouA, 
        ichimokuSenkouB: updated.ichimokuSenkouB 
      });
      return updated;
    });
    
    // ✅ maLines가 변경된 경우 버전 증가
    if (newSettings.maLines !== undefined) {
      setMaLinesVersion(prev => prev + 1);
      console.log('🔄 [updateSettings] MA Lines 변경 감지, 버전 증가:', maLinesVersion + 1);
    }
  };

  const updateOrder = (newOrder: IndicatorOrder[]) => {
    setOrder(newOrder);
  };

  const updateMALines = (newMALines: MALineConfig[]) => {
    setSettings(prev => ({ ...prev, maLines: newMALines }));
    setMaLinesVersion(prev => prev + 1);  // ✅ MA 설정 변경 시 버전 증가
    console.log('🔄 [IndicatorVisibilityContext] MA Lines 업데이트, 버전:', maLinesVersion + 1);
  };

  const updateSingleMALine = (index: number, updates: Partial<MALineConfig>) => {
    setSettings(prev => {
      const newMALines = [...prev.maLines];
      if (index >= 0 && index < newMALines.length) {
        newMALines[index] = { ...newMALines[index], ...updates };
      }
      return { ...prev, maLines: newMALines };
    });
    setMaLinesVersion(prev => prev + 1);  // ✅ MA 설정 변경 시 버전 증가
    console.log('🔄 [IndicatorVisibilityContext] Single MA Line 업데이트, 버전:', maLinesVersion + 1);
  };

  const resetSettings = () => {
    setSettings(defaultSettings);
    setOrder(defaultOrder);
    localStorage.removeItem(STORAGE_KEY);
    localStorage.removeItem(ORDER_STORAGE_KEY);
  };

  return (
    <IndicatorVisibilityContext.Provider 
      value={{ 
        settings, 
        order,
        updateSettings, 
        updateOrder,
        updateMALines,
        updateSingleMALine,
        resetSettings,
        loadUserSettings,
        saveSettings,
        setAuthState,
        maLinesVersion,  // ✅ MA 설정 변경 추적용 버전 번호
      }}
    >
      {children}
    </IndicatorVisibilityContext.Provider>
  );
};

export const useIndicatorVisibility = () => {
  const context = useContext(IndicatorVisibilityContext);
  if (!context) {
    throw new Error('useIndicatorVisibility must be used within IndicatorVisibilityProvider');
  }
  return context;
};
