import React, { useState, useEffect } from 'react';
import {
  Box,
  TextField,
  Typography,
  Switch,
  FormControlLabel,
  Grid,
  Alert,
  Button,
  Divider,
  Paper,
  Chip,
  CircularProgress,
} from '@mui/material';
import { RestartAlt, Schedule as ScheduleIcon, TrendingUp } from '@mui/icons-material';

interface SchedulerSettings {
  marketSyncCron: string;
  marketSyncEnabled: boolean;
  popularSyncInterval: number;
  popularSyncEnabled: boolean;
  allMarketsSyncCron: string;
  allMarketsSyncEnabled: boolean;
  cleanupCron: string;
  cleanupEnabled: boolean;
  // 추세 강도 갱신 설정
  trendRefreshInterval: number;
  trendRefreshEnabled: boolean;
  // 상승 종목 스캔 설정
  risingStockScanEnabled: boolean;
  risingStockScanInterval: number;
}

const defaultSettings: SchedulerSettings = {
  marketSyncCron: '0 0 9 * * *',
  marketSyncEnabled: true,
  popularSyncInterval: 300000,
  popularSyncEnabled: true,
  allMarketsSyncCron: '0 0 10 * * *',
  allMarketsSyncEnabled: true,
  cleanupCron: '0 0 3 * * *',
  cleanupEnabled: true,
  // 추세 강도 갱신: 기본 3분
  trendRefreshInterval: 180000,
  trendRefreshEnabled: true,
  // 상승 종목 스캔: 기본 30초
  risingStockScanEnabled: true,
  risingStockScanInterval: 30000,
};

// 추세 갱신 설정 localStorage 키
const TREND_REFRESH_STORAGE_KEY = 'trendRefreshSettings';

// 추세 갱신 설정 로드 (외부에서 사용)
export const loadTrendRefreshSettings = (): { interval: number; enabled: boolean } => {
  try {
    const saved = localStorage.getItem(TREND_REFRESH_STORAGE_KEY);
    if (saved) {
      return JSON.parse(saved);
    }
  } catch (e) {
    console.error('추세 갱신 설정 로드 실패:', e);
  }
  return { interval: defaultSettings.trendRefreshInterval, enabled: defaultSettings.trendRefreshEnabled };
};

// 추세 갱신 설정 저장
const saveTrendRefreshSettings = (interval: number, enabled: boolean) => {
  try {
    localStorage.setItem(TREND_REFRESH_STORAGE_KEY, JSON.stringify({ interval, enabled }));
  } catch (e) {
    console.error('추세 갱신 설정 저장 실패:', e);
  }
};

const SchedulerSettingsTab: React.FC = () => {
  const [settings, setSettings] = useState<SchedulerSettings>(defaultSettings);
  const [success, setSuccess] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [loading, setLoading] = useState(false);

  useEffect(() => {
    loadSettings();
  }, []);

  const loadSettings = async () => {
    try {
      const response = await fetch('/api/settings/scheduler', {
        credentials: 'include',
      });
      
      // localStorage에서 추세 갱신 설정 로드
      const trendSettings = loadTrendRefreshSettings();
      
      // 상승 종목 스캔 설정 로드
      const risingStockResponse = await fetch('/api/rising-stock-scheduler/config', {
        credentials: 'include',
      });
      
      let risingStockConfig = {
        enabled: defaultSettings.risingStockScanEnabled,
        scanInterval: defaultSettings.risingStockScanInterval,
      };
      
      if (risingStockResponse.ok) {
        const risingStockData = await risingStockResponse.json();
        risingStockConfig = {
          enabled: risingStockData.enabled,
          scanInterval: risingStockData.scanInterval,
        };
      }
      
      if (response.ok) {
        const data = await response.json();
        console.log('스케줄러 설정 로드:', data);
        // 서버 설정과 localStorage 추세 설정, 상승 종목 스캔 설정 병합
        setSettings({
          ...data,
          trendRefreshInterval: trendSettings.interval,
          trendRefreshEnabled: trendSettings.enabled,
          risingStockScanEnabled: risingStockConfig.enabled,
          risingStockScanInterval: risingStockConfig.scanInterval,
        });
      } else {
        console.warn('설정 로드 실패, 기본값 사용');
        setSettings({
          ...defaultSettings,
          trendRefreshInterval: trendSettings.interval,
          trendRefreshEnabled: trendSettings.enabled,
          risingStockScanEnabled: risingStockConfig.enabled,
          risingStockScanInterval: risingStockConfig.scanInterval,
        });
      }
    } catch (err) {
      console.error('설정 로드 실패:', err);
      setError('설정을 불러오는데 실패했습니다.');
      // 에러 시 기본값 사용
      const trendSettings = loadTrendRefreshSettings();
      setSettings({
        ...defaultSettings,
        trendRefreshInterval: trendSettings.interval,
        trendRefreshEnabled: trendSettings.enabled,
      });
    }
  };

  const handleSave = async (): Promise<boolean> => {
    try {
      setError(null);
      
      // 추세 갱신 설정을 localStorage에 저장 (프론트엔드에서 사용)
      saveTrendRefreshSettings(settings.trendRefreshInterval, settings.trendRefreshEnabled);
      
      // 상승 종목 스캔 설정 저장
      const risingStockResponse = await fetch('/api/rising-stock-scheduler/config', {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
        },
        credentials: 'include',
        body: JSON.stringify({
          enabled: settings.risingStockScanEnabled,
          scanInterval: settings.risingStockScanInterval,
          maxResults: 20,
        }),
      });
      
      if (!risingStockResponse.ok) {
        throw new Error('상승 종목 스캔 설정 저장 실패');
      }
      
      const response = await fetch('/api/settings/scheduler', {
        method: 'POST',
        headers: { 
          'Content-Type': 'application/json',
        },
        credentials: 'include',
        body: JSON.stringify(settings),
      });
      
      if (response.ok) {
        console.log('스케줄러 설정 저장 성공');
        setSuccess(true);
        setTimeout(() => setSuccess(false), 3000);
        
        // 설정 저장 후 재로드하여 확인
        await loadSettings();
        return true;
      } else {
        const errorText = await response.text();
        throw new Error(errorText || '설정 저장 실패');
      }
    } catch (err: any) {
      console.error('설정 저장 실패:', err);
      setError(err.message || '설정 저장에 실패했습니다.');
      return false;
    }
  };

  const handleReset = async () => {
    if (window.confirm('스케줄러 설정을 기본값으로 초기화하시겠습니까?')) {
      try {
        setSettings(defaultSettings);
        
        // 기본값을 서버에 저장
        const response = await fetch('/api/settings/scheduler', {
          method: 'POST',
          headers: { 
            'Content-Type': 'application/json',
          },
          credentials: 'include',
          body: JSON.stringify(defaultSettings),
        });
        
        if (response.ok) {
          console.log('스케줄러 설정 초기화 성공');
          setSuccess(true);
          setTimeout(() => setSuccess(false), 3000);
          await loadSettings();
        } else {
          throw new Error('초기화 실패');
        }
      } catch (err: any) {
        console.error('설정 초기화 실패:', err);
        setError(err.message || '설정 초기화에 실패했습니다.');
      }
    }
  };

  const handleChange = (field: keyof SchedulerSettings, value: string | number | boolean) => {
    setSettings(prev => ({ ...prev, [field]: value }));
  };

  const handleSaveAndReload = async () => {
    if (loading) return; // 중복 클릭 방지
    
    try {
      setLoading(true);
      setError(null);
      
      console.log('스케줄러 설정 저장 시작...', settings);
      
      // 1. 설정 저장
      const saveSuccess = await handleSave();
      
      if (!saveSuccess) {
        console.error('설정 저장 실패, 스케줄러 재시작 중단');
        setLoading(false);
        return;
      }
      
      console.log('설정 저장 완료, 스케줄러 재시작 시작...');
      
      // 2. 스케줄러 재시작
      const reloadResponse = await fetch('/api/settings/scheduler/reload', {
        method: 'POST',
        credentials: 'include',
      });
      
      if (reloadResponse.ok) {
        const message = await reloadResponse.text();
        console.log('스케줄러 재시작 성공:', message);
        setSuccess(true);
        setTimeout(() => setSuccess(false), 3000);
      } else {
        const errorText = await reloadResponse.text();
        throw new Error(errorText || '스케줄러 재시작 실패');
      }
    } catch (err: any) {
      console.error('설정 저장 및 적용 실패:', err);
      setError(err.message || '설정 저장 및 적용에 실패했습니다.');
    } finally {
      setLoading(false);
    }
  };

  const parseCronDescription = (cron: string): string => {
    // 간단한 cron 표현식 해석
    const parts = cron.split(' ');
    if (parts.length !== 6) return '잘못된 형식';
    
    const [sec, min, hour, day, month, weekday] = parts;
    
    if (hour !== '*' && min !== '*') {
      return `매일 ${hour}시 ${min}분`;
    }
    return cron;
  };

  const convertIntervalToMinutes = (ms: number): number => {
    return Math.floor(ms / 60000);
  };

  const convertMinutesToInterval = (minutes: number): number => {
    return minutes * 60000;
  };

  return (
    <Box>
      <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 2 }}>
        <Typography variant="h6">
          스케줄러 설정
        </Typography>
        <Button
          variant="outlined"
          size="small"
          startIcon={<RestartAlt />}
          onClick={handleReset}
          color="secondary"
        >
          초기화
        </Button>
      </Box>

      {success && (
        <Alert severity="success" sx={{ mb: 2 }}>
          설정이 저장되었습니다.
        </Alert>
      )}

      {error && (
        <Alert severity="error" sx={{ mb: 2 }}>
          {error}
        </Alert>
      )}

      <Alert severity="info" sx={{ mb: 3 }}>
        <Typography variant="body2">
          업비트 데이터 동기화 스케줄을 설정합니다. Cron 표현식 형식: 초 분 시 일 월 요일
        </Typography>
        <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mt: 1 }}>
          예시: "0 0 9 * * *" = 매일 오전 9시 0분 0초
        </Typography>
      </Alert>

      {/* 마켓 목록 동기화 */}
      <Paper sx={{ p: 3, mb: 3 }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
          <ScheduleIcon color="primary" />
          <Typography variant="subtitle1" fontWeight="bold">
            마켓 목록 동기화
          </Typography>
          <Chip 
            label={settings.marketSyncEnabled ? '활성화' : '비활성화'} 
            size="small" 
            color={settings.marketSyncEnabled ? 'success' : 'default'}
          />
        </Box>
        
        <FormControlLabel
          control={
            <Switch
              checked={settings.marketSyncEnabled}
              onChange={(e) => handleChange('marketSyncEnabled', e.target.checked)}
            />
          }
          label="마켓 목록 동기화 활성화"
          sx={{ mb: 2 }}
        />
        
        <TextField
          fullWidth
          label="스케줄 (Cron 표현식)"
          value={settings.marketSyncCron}
          onChange={(e) => handleChange('marketSyncCron', e.target.value)}
          disabled={!settings.marketSyncEnabled}
          helperText={`해석: ${parseCronDescription(settings.marketSyncCron)}`}
          sx={{ mb: 1 }}
        />
        
        <Typography variant="caption" color="text.secondary">
          업비트의 전체 마켓 목록을 동기화합니다.
        </Typography>
      </Paper>

      {/* 인기 종목 동기화 */}
      <Paper sx={{ p: 3, mb: 3 }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
          <ScheduleIcon color="primary" />
          <Typography variant="subtitle1" fontWeight="bold">
            인기 종목 동기화
          </Typography>
          <Chip 
            label={settings.popularSyncEnabled ? '활성화' : '비활성화'} 
            size="small" 
            color={settings.popularSyncEnabled ? 'success' : 'default'}
          />
        </Box>
        
        <FormControlLabel
          control={
            <Switch
              checked={settings.popularSyncEnabled}
              onChange={(e) => handleChange('popularSyncEnabled', e.target.checked)}
            />
          }
          label="인기 종목 동기화 활성화"
          sx={{ mb: 2 }}
        />
        
        <TextField
          fullWidth
          label="동기화 간격 (분)"
          type="number"
          value={convertIntervalToMinutes(settings.popularSyncInterval)}
          onChange={(e) => handleChange('popularSyncInterval', convertMinutesToInterval(Number(e.target.value)))}
          disabled={!settings.popularSyncEnabled}
          inputProps={{ min: 1, max: 60 }}
          helperText={`${convertIntervalToMinutes(settings.popularSyncInterval)}분마다 동기화`}
          sx={{ mb: 1 }}
        />
        
        <Typography variant="caption" color="text.secondary">
          BTC, ETH, XRP 등 인기 암호화폐 10개의 MACD 데이터를 주기적으로 동기화합니다.
        </Typography>
      </Paper>

      {/* 전체 마켓 동기화 */}
      <Paper sx={{ p: 3, mb: 3 }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
          <ScheduleIcon color="primary" />
          <Typography variant="subtitle1" fontWeight="bold">
            전체 마켓 동기화
          </Typography>
          <Chip 
            label={settings.allMarketsSyncEnabled ? '활성화' : '비활성화'} 
            size="small" 
            color={settings.allMarketsSyncEnabled ? 'success' : 'default'}
          />
        </Box>
        
        <FormControlLabel
          control={
            <Switch
              checked={settings.allMarketsSyncEnabled}
              onChange={(e) => handleChange('allMarketsSyncEnabled', e.target.checked)}
            />
          }
          label="전체 마켓 동기화 활성화"
          sx={{ mb: 2 }}
        />
        
        <TextField
          fullWidth
          label="스케줄 (Cron 표현식)"
          value={settings.allMarketsSyncCron}
          onChange={(e) => handleChange('allMarketsSyncCron', e.target.value)}
          disabled={!settings.allMarketsSyncEnabled}
          helperText={`해석: ${parseCronDescription(settings.allMarketsSyncCron)}`}
          sx={{ mb: 1 }}
        />
        
        <Typography variant="caption" color="text.secondary">
          모든 활성화된 KRW 마켓의 일봉 MACD 데이터를 동기화합니다. (시간이 오래 걸릴 수 있습니다)
        </Typography>
      </Paper>

      {/* 추세 강도 갱신 (정배열/역배열) */}
      <Paper sx={{ p: 3, mb: 3, border: '2px solid', borderColor: 'primary.main' }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
          <TrendingUp color="primary" />
          <Typography variant="subtitle1" fontWeight="bold">
            추세 강도 갱신 (정배열/역배열)
          </Typography>
          <Chip 
            label={settings.trendRefreshEnabled ? '활성화' : '비활성화'} 
            size="small" 
            color={settings.trendRefreshEnabled ? 'success' : 'default'}
          />
        </Box>
        
        <FormControlLabel
          control={
            <Switch
              checked={settings.trendRefreshEnabled}
              onChange={(e) => handleChange('trendRefreshEnabled', e.target.checked)}
            />
          }
          label="추세 강도 자동 갱신 활성화"
          sx={{ mb: 2 }}
        />
        
        <TextField
          fullWidth
          label="갱신 간격 (분)"
          type="number"
          value={convertIntervalToMinutes(settings.trendRefreshInterval)}
          onChange={(e) => handleChange('trendRefreshInterval', convertMinutesToInterval(Number(e.target.value)))}
          disabled={!settings.trendRefreshEnabled}
          inputProps={{ min: 1, max: 60 }}
          helperText={`${convertIntervalToMinutes(settings.trendRefreshInterval)}분마다 정배열/역배열 목록 갱신`}
          sx={{ mb: 1 }}
        />
        
        <Typography variant="caption" color="text.secondary">
          종목 사이드바의 정배열/역배열 목록을 설정된 간격으로 자동 갱신합니다.
          MA10, MA20, MA60, ATR(14) 기반으로 추세 강도를 재계산합니다.
        </Typography>
      </Paper>

      {/* 상승 종목 자동 스캔 */}
      <Paper sx={{ p: 3, mb: 3, border: '2px solid', borderColor: 'success.main' }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
          <TrendingUp color="success" />
          <Typography variant="subtitle1" fontWeight="bold">
            상승 종목 자동 스캔
          </Typography>
          <Chip 
            label={settings.risingStockScanEnabled ? '활성화' : '비활성화'} 
            size="small" 
            color={settings.risingStockScanEnabled ? 'success' : 'default'}
          />
        </Box>
        
        <FormControlLabel
          control={
            <Switch
              checked={settings.risingStockScanEnabled}
              onChange={(e) => handleChange('risingStockScanEnabled', e.target.checked)}
            />
          }
          label="상승 종목 자동 스캔 활성화"
          sx={{ mb: 2 }}
        />
        
        <TextField
          fullWidth
          label="스캔 간격 (초)"
          type="number"
          value={Math.floor(settings.risingStockScanInterval / 1000)}
          onChange={(e) => handleChange('risingStockScanInterval', Number(e.target.value) * 1000)}
          disabled={!settings.risingStockScanEnabled}
          inputProps={{ min: 10, max: 300 }}
          helperText={`${Math.floor(settings.risingStockScanInterval / 1000)}초마다 TOP 20 상승 종목 스캔`}
          sx={{ mb: 1 }}
        />
        
        <Alert severity="info" sx={{ mt: 2 }}>
          <Typography variant="caption">
            <strong>6단계 필터링 시스템:</strong><br />
            1단계: 하락추세 종목 제거 (손실 방지)<br />
            2단계: 상승추세 판별 (방향성)<br />
            3단계: 모멘텀 확인 (상승 강도)<br />
            4단계: 추가 확인 (신뢰도)<br />
            5단계: 종합 스코어링<br />
            6단계: 시장 상태 확인
          </Typography>
        </Alert>
        
        <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mt: 2 }}>
          업비트 전체 암호화폐(약 237개)를 실시간 스캔하여 상승 가능성이 높은 TOP 20 종목을 자동 선정합니다.
          MA, MACD, 거래량 등 다양한 지표를 종합 분석하여 매수 타이밍을 포착합니다.
        </Typography>
      </Paper>

      {/* 오래된 데이터 정리 */}
      <Paper sx={{ p: 3, mb: 3 }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
          <ScheduleIcon color="primary" />
          <Typography variant="subtitle1" fontWeight="bold">
            오래된 데이터 정리
          </Typography>
          <Chip 
            label={settings.cleanupEnabled ? '활성화' : '비활성화'} 
            size="small" 
            color={settings.cleanupEnabled ? 'success' : 'default'}
          />
        </Box>
        
        <FormControlLabel
          control={
            <Switch
              checked={settings.cleanupEnabled}
              onChange={(e) => handleChange('cleanupEnabled', e.target.checked)}
            />
          }
          label="데이터 정리 활성화"
          sx={{ mb: 2 }}
        />
        
        <TextField
          fullWidth
          label="스케줄 (Cron 표현식)"
          value={settings.cleanupCron}
          onChange={(e) => handleChange('cleanupCron', e.target.value)}
          disabled={!settings.cleanupEnabled}
          helperText={`해석: ${parseCronDescription(settings.cleanupCron)}`}
          sx={{ mb: 1 }}
        />
        
        <Typography variant="caption" color="text.secondary">
          6개월 이상 오래된 캔들 데이터와 1년 이상 오래된 MACD 데이터를 삭제합니다.
        </Typography>
      </Paper>

      <Divider sx={{ my: 3 }} />

      <Box sx={{ bgcolor: '#f5f5f5', p: 2, borderRadius: 1, mb: 3 }}>
        <Typography variant="subtitle2" gutterBottom>
          📌 Cron 표현식 가이드
        </Typography>
        <Typography variant="body2" color="text.secondary" paragraph>
          • 형식: 초(0-59) 분(0-59) 시(0-23) 일(1-31) 월(1-12) 요일(0-7)
        </Typography>
        <Typography variant="body2" color="text.secondary" paragraph>
          • 매일 오전 9시: <code>0 0 9 * * *</code>
        </Typography>
        <Typography variant="body2" color="text.secondary" paragraph>
          • 매일 새벽 3시: <code>0 0 3 * * *</code>
        </Typography>
        <Typography variant="body2" color="text.secondary">
          • 매시간 정각: <code>0 0 * * * *</code>
        </Typography>
      </Box>

      <Alert severity="warning" sx={{ mb: 2 }}>
        <Typography variant="body2">
          ⚠️ 설정 변경 후 "저장 및 적용" 버튼을 클릭하면 스케줄러가 재시작되어 새로운 설정이 즉시 적용됩니다.
        </Typography>
      </Alert>

      <Box sx={{ display: 'flex', justifyContent: 'flex-end', gap: 2 }}>
        <Button 
          variant="contained" 
          onClick={handleSaveAndReload}
          disabled={loading}
          startIcon={loading ? <CircularProgress size={20} color="inherit" /> : null}
        >
          {loading ? '저장 중...' : '저장 및 적용'}
        </Button>
      </Box>
    </Box>
  );
};

export default SchedulerSettingsTab;

