import { API_BASE_URL } from './apiConfig';

/**
 * 상승 종목 DTO
 */
export interface RisingStock {
  code: string;
  name: string;
  currentPrice: number;
  changeRate: number;
  totalScore: number;
  trendScore: number;
  volumeScore: number;
  flowScore: number;
  momentumScore: number;
  ranking: number;
  signalStrength: 'STRONG' | 'MEDIUM' | 'WEAK';
  buySignal: boolean;
  passStage1: boolean;
  passStage2: boolean;
  passStage3: boolean;
  passStage4: boolean;
  volume?: number;
  volumeRatio?: number;
  foreignNet?: number;
  instNet?: number;
  rsi?: number;
  macd?: number;
  updatedAt: string;
}

/**
 * 검색 필터 옵션
 */
export interface SearchFilter {
  id: string;
  name: string;
  category: string;
  enabled: boolean;
}

/**
 * 검색 요청 DTO
 * 
 * 단계별 필터:
 * - 1단계: 하락추세 제거 (손실 방지)
 * - 2단계: 상승추세 판별 (방향성)
 * - 3단계: 모멘텀 확인 (상승 강도)
 * - 4단계: 추가 확인 (신뢰도)
 */
export interface RisingStockSearchRequest {
  market?: string;
  maxResults?: number;
  minTotalScore?: number;
  
  // ===== 1단계: 하락추세 제거 =====
  enableCloseMa60Filter?: boolean;    // 종가 > MA60
  enableMa20Ma60Filter?: boolean;     // MA20 > MA60
  enableAdxDiFilter?: boolean;        // ADX 하락추세 제거
  enableHigh120Filter?: boolean;      // 120일 고점 대비
  high120DropThreshold?: number;
  
  // ===== 2단계: 상승추세 판별 =====
  enableMaAlignmentFilter?: boolean;  // MA 정배열
  enableMaSlopeFilter?: boolean;      // MA20 기울기 양수
  enableMacdFilter?: boolean;         // MACD > Signal
  enableRsiFilter?: boolean;          // RSI 범위
  rsiMin?: number;
  rsiMax?: number;
  
  // ===== 3단계: 모멘텀 확인 =====
  enableBullishCandleFilter?: boolean;   // 양봉 필터 (신규)
  enableMinChangeRateFilter?: boolean;   // 최소 등락률 (신규)
  minChangeRate?: number;                // 최소 등락률 값 (%)
  enableVolume20dFilter?: boolean;       // 20일 평균 거래량 돌파
  volume20dMultiplier?: number;
  enableVolume5dFilter?: boolean;        // 5일 평균 거래량 + 양봉
  volume5dMultiplier?: number;
  
  // ===== 4단계: 추가 확인 (주식/고급) =====
  enableForeignNetFilter?: boolean;
  foreignNetThreshold?: number;
  enableInstNetFilter?: boolean;
  instNetThreshold?: number;
  enableProgramNetFilter?: boolean;
  enableTradeStrengthFilter?: boolean;
  tradeStrengthThreshold?: number;
  enableBidAskRatioFilter?: boolean;
  bidAskRatioThreshold?: number;
  
  // ===== 시장 상태 =====
  enableMarketStatusFilter?: boolean;
  
  // ===== 정렬 =====
  sortBy?: string;      // totalScore, trendScore, momentumScore, changeRate
  sortDirection?: string; // DESC, ASC
}

/**
 * 시장 상태 DTO
 */
export interface MarketStatus {
  marketType: string;
  currentIndex: number;
  indexMa20: number;
  vix: number;
  vixSpike: boolean;
  status: 'NORMAL' | 'CAUTION' | 'DANGER';
  buyAllowed: boolean;
  advanceRatio: number;
  declineRatio: number;
  tradeValue: number;
  updatedAt: string;
}

/**
 * API 응답 타입
 */
interface ApiResponse<T> {
  success: boolean;
  data: T;
  count?: number;
  source?: string;
  error?: string;
  timestamp: string;
}

/** 정렬 기준: totalScore | trendScore | volumeScore */
export type TopRisingSort = 'totalScore' | 'trendScore' | 'volumeScore';

/**
 * TOP 상승 종목 조회
 * @param limit 최대 개수
 * @param sort totalScore(종합), trendScore(추세순-차트 상승추세와 일치), volumeScore(거래량순)
 */
export const getTopRisingStocks = async (
  limit: number = 20,
  sort: TopRisingSort = 'totalScore'
): Promise<RisingStock[]> => {
  try {
    const response = await fetch(
      `${API_BASE_URL}/rising-stocks/top?limit=${limit}&sort=${sort}`
    );
    const result: ApiResponse<RisingStock[]> = await response.json();

    if (result.success) {
      return result.data;
    } else {
      console.error('TOP 상승 종목 조회 실패:', result.error);
      return [];
    }
  } catch (error) {
    console.error('TOP 상승 종목 조회 오류:', error);
    return [];
  }
};

/**
 * 조건별 상승 종목 검색
 */
export const searchRisingStocks = async (request: RisingStockSearchRequest): Promise<RisingStock[]> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/search`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(request),
    });
    const result: ApiResponse<RisingStock[]> = await response.json();
    
    if (result.success) {
      return result.data;
    } else {
      console.error('상승 종목 검색 실패:', result.error);
      return [];
    }
  } catch (error) {
    console.error('상승 종목 검색 오류:', error);
    return [];
  }
};

/**
 * 특정 종목 점수 조회
 */
export const getStockScore = async (code: string): Promise<RisingStock | null> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/${code}/score`);
    const result: ApiResponse<RisingStock> = await response.json();
    
    if (result.success) {
      return result.data;
    } else {
      console.error('종목 점수 조회 실패:', result.error);
      return null;
    }
  } catch (error) {
    console.error('종목 점수 조회 오류:', error);
    return null;
  }
};

/**
 * 시장 상태 조회
 */
export const getMarketStatus = async (): Promise<MarketStatus | null> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/market/status`);
    const result: ApiResponse<MarketStatus> = await response.json();
    
    if (result.success) {
      return result.data;
    } else {
      console.error('시장 상태 조회 실패:', result.error);
      return null;
    }
  } catch (error) {
    console.error('시장 상태 조회 오류:', error);
    return null;
  }
};

/**
 * 실시간 매수 신호 조회
 */
export const getRealtimeSignal = async (): Promise<{ stocks: RisingStock[], marketStatus: string, tradingAllowed: boolean }> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/realtime/signal`);
    const result = await response.json();
    
    if (result.success) {
      return {
        stocks: result.data,
        marketStatus: result.marketStatus,
        tradingAllowed: result.tradingAllowed,
      };
    } else {
      console.error('실시간 신호 조회 실패:', result.error);
      return { stocks: [], marketStatus: 'UNKNOWN', tradingAllowed: false };
    }
  } catch (error) {
    console.error('실시간 신호 조회 오류:', error);
    return { stocks: [], marketStatus: 'UNKNOWN', tradingAllowed: false };
  }
};

/**
 * 수동 스캔 트리거
 */
export const triggerScan = async (): Promise<boolean> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/scan`, {
      method: 'POST',
    });
    const result = await response.json();
    return result.success;
  } catch (error) {
    console.error('수동 스캔 트리거 오류:', error);
    return false;
  }
};

/**
 * 스캔 상태 조회
 */
export const getScanStatus = async (): Promise<{ isScanning: boolean, totalScanCount: number }> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/scan/status`);
    const result = await response.json();
    
    if (result.success) {
      return {
        isScanning: result.isScanning,
        totalScanCount: result.totalScanCount,
      };
    }
    return { isScanning: false, totalScanCount: 0 };
  } catch (error) {
    console.error('스캔 상태 조회 오류:', error);
    return { isScanning: false, totalScanCount: 0 };
  }
};

/**
 * 검색 필터 기본값 조회
 */
export const getFilterDefaults = async (): Promise<{ filters: SearchFilter[], defaults: RisingStockSearchRequest }> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/filters/defaults`);
    const result = await response.json();
    
    if (result.success) {
      return {
        filters: result.filters,
        defaults: result.defaults,
      };
    }
    return { filters: [], defaults: {} };
  } catch (error) {
    console.error('필터 기본값 조회 오류:', error);
    return { filters: [], defaults: {} };
  }
};

/**
 * 캐시 초기화
 */
export const clearCache = async (): Promise<boolean> => {
  try {
    const response = await fetch(`${API_BASE_URL}/rising-stocks/cache/clear`, {
      method: 'POST',
    });
    const result = await response.json();
    return result.success;
  } catch (error) {
    console.error('캐시 초기화 오류:', error);
    return false;
  }
};

/**
 * 기본 검색 조건 (암호화폐 상승추세 탐지 최적화)
 * 
 * 설계 원칙:
 * - 더 많은 조건을 충족할수록 → 더 강한 상승추세
 * - 단계별로 점진적 필터링
 * - 암호화폐 특성 반영 (수급 데이터 없음)
 */
export const DEFAULT_SEARCH_REQUEST: RisingStockSearchRequest = {
  market: 'KRW',
  maxResults: 30,
  minTotalScore: 0,  // 모든 종목 표시, 점수로 정렬
  
  // ===== 1단계: 하락추세 제거 (기본 ON) =====
  // 손실 위험 최소화
  enableCloseMa60Filter: true,   // 가격 > MA60: ON (기본)
  enableMa20Ma60Filter: true,    // MA20 > MA60: ON (기본)
  enableAdxDiFilter: false,      // ADX 하락추세: OFF (선택)
  enableHigh120Filter: false,    // 120일 고점: OFF (신규 코인)
  high120DropThreshold: -30,
  
  // ===== 2단계: 상승추세 판별 (핵심) =====
  // 실제 상승 중인지 확인
  enableMaAlignmentFilter: false, // MA 정배열: OFF (MA120 데이터 부족)
  enableMaSlopeFilter: true,      // MA20 기울기: ON (상승 방향)
  enableMacdFilter: true,         // MACD > Signal: ON (모멘텀)
  enableRsiFilter: false,         // RSI 범위: OFF (선택)
  rsiMin: 35,
  rsiMax: 75,
  
  // ===== 3단계: 모멘텀 확인 (상승 강도) =====
  // 더 많이 ON할수록 강한 상승 종목만 검색
  enableBullishCandleFilter: true,    // 양봉 필터: ON (매수세)
  enableMinChangeRateFilter: false,   // 최소 등락률: OFF (선택)
  minChangeRate: 1,
  enableVolume20dFilter: false,       // 20일 거래량: OFF (변동성 큼)
  volume20dMultiplier: 2,
  enableVolume5dFilter: false,        // 5일 거래량: OFF (선택)
  volume5dMultiplier: 1.5,
  
  // ===== 4단계: 추가 확인 (수급/고급) =====
  // 암호화폐는 모두 OFF
  enableForeignNetFilter: false,
  foreignNetThreshold: 10,
  enableInstNetFilter: false,
  instNetThreshold: 5,
  enableProgramNetFilter: false,
  enableTradeStrengthFilter: false,
  tradeStrengthThreshold: 140,
  enableBidAskRatioFilter: false,
  bidAskRatioThreshold: 1.5,
  
  // ===== 시장 상태 =====
  enableMarketStatusFilter: false,
  
  // ===== 정렬 =====
  sortBy: 'totalScore',  // 종합 점수 (권장)
  sortDirection: 'DESC',
};

