import axios from 'axios';
import { API_CONFIG } from './apiConfig';

const API_BASE_URL = API_CONFIG.baseURL;

// ==================== 타입 정의 ====================

/**
 * 신호 타입 (매수/매도)
 */
export type SignalType = 'BUY' | 'SELL';

/**
 * 추세 타입
 */
export type TrendType = 'ALL' | 'UPTREND' | 'DOWNTREND' | 'SIDEWAYS' | 'RANGE';

/**
 * 논리 연산자 (AND/OR)
 */
export type LogicalOperator = 'AND' | 'OR';

/**
 * 보조지표 타입 (업비트 표준 16개)
 */
export type IndicatorType = 
  | 'VOLUME'              // 거래량
  | 'MACD'                // MACD
  | 'STOCHASTIC'          // Stochastic Slow
  | 'RSI'                 // RSI
  | 'ADX'                 // ADX
  | 'CCI'                 // CCI
  | 'TRIX'                // TRIX
  | 'DISPARITY'           // 이격도
  | 'NEW_PSYCHOLOGICAL'   // 신심리도
  | 'INVEST_PSYCHOLOGICAL' // 투자심리도
  | 'WILLIAMS_R'          // Williams %R
  | 'BWI'                 // 볼린저밴드 %B
  | 'OBV'                 // OBV
  | 'VOLUME_OSC'          // VolumeOSC
  | 'VR'                  // VR
  | 'DMI';                // DMI

/**
 * 조건 타입
 */
export type ConditionType = 
  | 'CROSS_UP'
  | 'CROSS_DOWN'
  | 'GOLDEN_CROSS'
  | 'DEAD_CROSS'
  | 'GOLDEN_HOLD_CHECK'
  | 'DEAD_HOLD_CHECK'
  | 'ABOVE'
  | 'BELOW'
  | 'ABOVE_STRICT'
  | 'BELOW_STRICT'
  | 'EQ'
  | 'NEQ'
  | 'BETWEEN'
  | 'OUTSIDE'
  | 'INCREASING'
  | 'DECREASING'
  | 'TURNING_UP'
  | 'TURNING_DOWN'
  | 'DIVERGENCE_BULLISH'
  | 'DIVERGENCE_BEARISH'
  | 'OVERBOUGHT'
  | 'OVERSOLD'
  | 'ZERO_CROSS_UP'
  | 'ZERO_CROSS_DOWN';

/**
 * 개별 조건 DTO
 */
export interface StrategyConditionDto {
  id?: number;
  conditionGroupId?: number;
  indicatorType: IndicatorType;
  conditionType: ConditionType;
  targetValue?: number;
  secondaryValue?: number;
  period?: number;
  comparePeriod?: number; // 골든/데드 크로스에서 비교 대상 장기 기간
  enabled?: boolean;
  orderIndex?: number;
  description?: string;
  logicalOperator?: LogicalOperator; // 다음 조건과의 논리 연산자 (AND/OR)
  candleRange?: number; // 조건 체크 캔들 범위 (1=현재캔들만, 2=현재+이전1개, 3=현재+이전2개, ...)
}

/**
 * 조건 그룹 DTO
 */
export interface ConditionGroupDto {
  id?: number;
  strategyRuleId?: number;
  parentGroupId?: number;
  logicalOperator: LogicalOperator;
  orderIndex?: number;
  name?: string;
  groupType?: 'BUY' | 'SELL';  // 매수/매도 보조지표 구분용
  conditions: StrategyConditionDto[];
  childGroups?: ConditionGroupDto[];
  interGroupOperator?: LogicalOperator; // 다음 그룹과의 논리 연산자 (AND/OR)
}

/**
 * MA 크로스 타입
 */
export type MaCrossType = 'GOLDEN_CROSS' | 'DEAD_CROSS';

/**
 * 일목균형표 크로스 타입
 */
export type IchimokuCrossType = 'CROSS_UP' | 'CROSS_DOWN';

/**
 * 볼린저밴드 타입
 */
export type BollingerBandType = 'UPPER' | 'MIDDLE' | 'LOWER';

/**
 * 볼린저밴드 크로스 타입
 */
export type BollingerCrossType = 'CROSS_UP' | 'CROSS_DOWN';

/**
 * 이동평균선 조건 DTO
 */
export interface MaConditionDto {
  id?: number;
  maShortPeriod: number;
  maLongPeriod: number;
  maCrossType: MaCrossType;
  logicalOperator?: LogicalOperator; // 다음 조건과의 논리 연산자 (AND/OR)
  orderIndex?: number;
}

/**
 * 볼린저밴드 조건 DTO
 */
export interface BollingerBandConditionDto {
  id?: number;
  period: number;  // 기간 (기본: 20)
  stdDev: number;  // 표준편차 배수 (기본: 2.0)
  bandType: BollingerBandType;  // 밴드 타입 (UPPER/MIDDLE/LOWER)
  crossType: BollingerCrossType;  // 크로스 방향 (CROSS_UP/CROSS_DOWN)
  logicalOperator?: LogicalOperator; // 다음 조건과의 논리 연산자 (AND/OR)
  orderIndex?: number;
}

/**
 * 전략 규칙 DTO
 */
export interface StrategyRuleDto {
  id?: number;
  name: string;
  description?: string;
  signalType: SignalType;
  trendType?: TrendType;
  enabled?: boolean;
  strategyType?: string; // DSL/LEGACY/FORM
  createdByUi?: string; // TREE/FORM/LEGACY
  
  // ==================== 매수 조건 설정 ====================
  
  // 매수: 이동평균선 조건 (새로운 배열 구조)
  enableMaBuy?: boolean;
  maConditionsBuy?: MaConditionDto[];
  
  // 매수: 이동평균선 조건 1 (하위 호환성을 위해 유지)
  maShortPeriod1Buy?: number;
  maLongPeriod1Buy?: number;
  maCrossType1Buy?: MaCrossType;
  
  // 매수: 이동평균선 조건 2 (OR 조건) (하위 호환성을 위해 유지)
  enableMaCondition2Buy?: boolean;
  maShortPeriod2Buy?: number;
  maLongPeriod2Buy?: number;
  maCrossType2Buy?: MaCrossType;
  
  // 매수: 일목균형표
  enableIchimokuBuy?: boolean;
  ichimokuTenkanBuy?: number;
  ichimokuKijunBuy?: number;
  ichimokuCrossTypeBuy?: IchimokuCrossType;
  
  // 매수: 볼린저밴드 조건
  enableBollingerBuy?: boolean;
  bollingerConditionsBuy?: BollingerBandConditionDto[];
  
  // 매수: 거래량 필터 (골든크로스용)
  enableVolumeFilterBuy?: boolean;
  
  // ==================== 매도 조건 설정 ====================
  
  // 매도: 이동평균선 조건 (새로운 배열 구조)
  enableMaSell?: boolean;
  maConditionsSell?: MaConditionDto[];
  
  // 매도: 이동평균선 조건 1 (하위 호환성을 위해 유지)
  maShortPeriod1Sell?: number;
  maLongPeriod1Sell?: number;
  maCrossType1Sell?: MaCrossType;
  
  // 매도: 이동평균선 조건 2 (OR 조건) (하위 호환성을 위해 유지)
  enableMaCondition2Sell?: boolean;
  maShortPeriod2Sell?: number;
  maLongPeriod2Sell?: number;
  maCrossType2Sell?: MaCrossType;
  
  // 매도: 일목균형표
  enableIchimokuSell?: boolean;
  ichimokuTenkanSell?: number;
  ichimokuKijunSell?: number;
  ichimokuCrossTypeSell?: IchimokuCrossType;
  
  // 매도: 볼린저밴드 조건
  enableBollingerSell?: boolean;
  bollingerConditionsSell?: BollingerBandConditionDto[];
  
  // 보조지표 ON/OFF
  enableAuxBuy?: boolean;
  enableAuxSell?: boolean;
  
  // 그룹 간 논리연산자 (AND: 모든 그룹 충족, OR: 하나 이상 충족)
  interGroupOperatorBuy?: LogicalOperator;
  interGroupOperatorSell?: LogicalOperator;
  
  // 매수 보조지표 조건 그룹
  buyConditionGroups?: ConditionGroupDto[];
  
  // 매도 보조지표 조건 그룹
  sellConditionGroups?: ConditionGroupDto[];
  
  createdAt?: string;
  updatedAt?: string;
  conditionSummary?: string;
  totalConditionCount?: number;
}

/**
 * 종목 검색 요청 DTO
 */
export interface StrategyRuleSearchRequest {
  symbols?: string[];
  dataSource?: 'REALTIME' | 'HISTORICAL';
  timeframe?: string;
  startDate?: string;
  endDate?: string;
  minMatchScore?: number;
  sortBy?: 'MATCH_SCORE' | 'CHANGE_RATE' | 'VOLUME' | 'TRADE_VALUE' | 'SYMBOL';
  sortDirection?: 'ASC' | 'DESC';
  limit?: number;
}

/**
 * 매칭된 조건 상세
 */
export interface MatchedConditionDetail {
  conditionId: number;
  description: string;
  indicatorType: string;
  currentValue: number;
  previousValue?: number;
  targetValue?: number;
  matched: boolean;
  groupId: number;
}

/**
 * 종목 검색 결과 DTO
 */
export interface SymbolMatchResultDto {
  symbol: string;
  name: string;
  currentPrice: number;
  changeRate: number;
  changePrice: number;
  volume: number;
  tradeValue: number;
  matchScore: number;
  matchedConditionCount: number;
  totalConditionCount: number;
  matchedConditions: MatchedConditionDetail[];
  indicatorValues: Record<string, number>;
  dataTime: string;
  dataSource: string;
}

/**
 * 지표/조건 타입 정보
 */
export interface TypeInfo {
  value: string;
  label: string;
  description: string;
}

// ==================== API 함수 ====================

/**
 * 전략 규칙 목록 조회
 */
export const getStrategyRules = async (
  signalType?: SignalType,
  enabledOnly: boolean = false,
  trendType?: TrendType
): Promise<StrategyRuleDto[]> => {
  try {
    const params: Record<string, any> = {};
    if (signalType) params.signalType = signalType;
    if (enabledOnly) params.enabledOnly = true;
    if (trendType) params.trendType = trendType;
    
    const response = await axios.get(`${API_BASE_URL}/strategy-rules`, { params });
    return response.data;
  } catch (error) {
    console.warn('전략 목록 조회 실패:', error);
    // 에러 발생 시 빈 배열 반환 (UI가 계속 동작하도록)
    return [];
  }
};

/**
 * 추세 타입 목록 조회
 */
export const getTrendTypes = async (): Promise<TypeInfo[]> => {
  const response = await axios.get(`${API_BASE_URL}/strategy-rules/trend-types`);
  return response.data;
};

/**
 * 전략 규칙 상세 조회
 */
export const getStrategyRule = async (id: number): Promise<StrategyRuleDto> => {
  const response = await axios.get(`${API_BASE_URL}/strategy-rules/${id}`);
  return response.data;
};

/**
 * 전략 규칙 생성
 */
export const createStrategyRule = async (rule: StrategyRuleDto): Promise<StrategyRuleDto> => {
  const response = await axios.post(`${API_BASE_URL}/strategy-rules`, rule);
  return response.data;
};

/**
 * 전략 규칙 수정
 */
export const updateStrategyRule = async (id: number, rule: StrategyRuleDto): Promise<StrategyRuleDto> => {
  const response = await axios.put(`${API_BASE_URL}/strategy-rules/${id}`, rule);
  return response.data;
};

/**
 * 전략 규칙 삭제
 */
export const deleteStrategyRule = async (id: number): Promise<void> => {
  await axios.delete(`${API_BASE_URL}/strategy-rules/${id}`);
};

/**
 * 전략 규칙 활성화/비활성화 토글
 */
export const toggleStrategyRule = async (id: number, enabled: boolean): Promise<StrategyRuleDto> => {
  const response = await axios.patch(
    `${API_BASE_URL}/strategy-rules/${id}/toggle`,
    null,
    { params: { enabled } }
  );
  return response.data;
};

/**
 * 조건에 맞는 종목 검색
 */
export const searchSymbolsByRule = async (
  ruleId: number,
  request: StrategyRuleSearchRequest
): Promise<SymbolMatchResultDto[]> => {
  const response = await axios.post(`${API_BASE_URL}/strategy-rules/${ruleId}/search`, request);
  return response.data;
};

// ==================== 전략 검증 관련 타입 ====================

/**
 * 검증 상태
 */
export type ValidationStatus = 'PASS' | 'WARNING' | 'FAIL';

/**
 * 검증 오류
 */
export interface ValidationError {
  groupIndex: number;
  conditionIndex: number;
  errorType: string;
  message: string;
  suggestion?: string;
}

/**
 * 검증 경고
 */
export interface ValidationWarning {
  groupIndex: number;
  conditionIndex: number;
  warningType: string;
  message: string;
}

/**
 * 전략 검증 결과 DTO
 */
export interface StrategyValidationResultDto {
  valid: boolean;
  status: ValidationStatus;
  message: string;
  errors: ValidationError[];
  warnings: ValidationWarning[];
  totalConditions: number;
  errorCount: number;
  warningCount: number;
}

/**
 * 전략 규칙 검증
 */
export const validateStrategyRule = async (
  rule: StrategyRuleDto
): Promise<StrategyValidationResultDto> => {
  const response = await axios.post(`${API_BASE_URL}/strategy-rules/validate`, rule);
  return response.data;
};

/**
 * 지표 타입 목록 조회
 */
export const getIndicatorTypes = async (): Promise<TypeInfo[]> => {
  const response = await axios.get(`${API_BASE_URL}/strategy-rules/indicator-types`);
  return response.data;
};

/**
 * 조건 타입 목록 조회
 */
export const getConditionTypes = async (): Promise<TypeInfo[]> => {
  const response = await axios.get(`${API_BASE_URL}/strategy-rules/condition-types`);
  return response.data;
};

// ==================== 헬퍼 함수 ====================

/**
 * 지표 타입 표시 이름
 */
export const getIndicatorDisplayName = (type: IndicatorType): string => {
  const names: Record<IndicatorType, string> = {
    // 업비트 표준 16개 보조지표
    VOLUME: '거래량',
    MACD: 'MACD',
    STOCHASTIC: 'Stochastic Slow',
    RSI: 'RSI',
    ADX: 'ADX',
    CCI: 'CCI',
    TRIX: 'TRIX',
    DISPARITY: '이격도',
    NEW_PSYCHOLOGICAL: '신심리도',
    INVEST_PSYCHOLOGICAL: '투자심리도',
    WILLIAMS_R: 'Williams %R',
    BWI: '볼린저밴드 %B',
    OBV: 'OBV',
    VOLUME_OSC: 'VolumeOSC',
    VR: 'VR',
    DMI: 'DMI',
  };
  return names[type] || type;
};

/**
 * 추세 타입 표시 이름
 */
export const getTrendDisplayName = (type: TrendType): string => {
  const names: Record<TrendType, string> = {
    ALL: '전체',
    UPTREND: '상승추세 (정배열)',
    DOWNTREND: '하락추세 (역배열)',
    SIDEWAYS: '횡보',
    RANGE: '박스권',
  };
  return names[type] || type;
};

/**
 * 조건 타입 표시 이름
 */
export const getConditionDisplayName = (type: ConditionType): string => {
  const names: Record<ConditionType, string> = {
    CROSS_UP: '기준값 돌파',
    CROSS_DOWN: '기준값 하향 돌파',
    GOLDEN_CROSS: '골든크로스',
    DEAD_CROSS: '데드크로스',
    GOLDEN_HOLD_CHECK: '골든크로스 유지',
    DEAD_HOLD_CHECK: '데드크로스 유지',
    ABOVE: '기준값 이상',
    BELOW: '기준값 이하',
    ABOVE_STRICT: '기준값 초과',
    BELOW_STRICT: '기준값 미만',
    EQ: '같음',
    NEQ: '다름',
    BETWEEN: '범위',
    OUTSIDE: '범위 외',
    INCREASING: '상승 중',
    DECREASING: '하락 중',
    TURNING_UP: '상승 전환',
    TURNING_DOWN: '하락 전환',
    DIVERGENCE_BULLISH: '상승 다이버전스',
    DIVERGENCE_BEARISH: '하락 다이버전스',
    OVERBOUGHT: '과매수',
    OVERSOLD: '과매도',
    ZERO_CROSS_UP: '0선 상향',
    ZERO_CROSS_DOWN: '0선 하향',
  };
  return names[type] || type;
};

/**
 * 조건 설명 생성 (업비트 16개 지표 기준)
 */
export const generateConditionDescription = (condition: StrategyConditionDto): string => {
  const indicator = getIndicatorDisplayName(condition.indicatorType);
  const conditionName = getConditionDisplayName(condition.conditionType);
  
  // MACD의 CROSS_UP/CROSS_DOWN은 Signal 크로스 (targetValue 무시)
  if (condition.indicatorType === 'MACD' && 
      (condition.conditionType === 'CROSS_UP' || condition.conditionType === 'GOLDEN_CROSS')) {
    return `${indicator} 골든 크로스 (Signal 상향 돌파)`;
  }
  if (condition.indicatorType === 'MACD' && 
      (condition.conditionType === 'CROSS_DOWN' || condition.conditionType === 'DEAD_CROSS')) {
    return `${indicator} 데드 크로스 (Signal 하향 돌파)`;
  }
  
  // TRIX의 CROSS_UP/CROSS_DOWN은 Signal 크로스 (targetValue 무시)
  if (condition.indicatorType === 'TRIX' && 
      (condition.conditionType === 'CROSS_UP' || condition.conditionType === 'GOLDEN_CROSS')) {
    return `${indicator} Signal 상향 돌파`;
  }
  if (condition.indicatorType === 'TRIX' && 
      (condition.conditionType === 'CROSS_DOWN' || condition.conditionType === 'DEAD_CROSS')) {
    return `${indicator} Signal 하향 돌파`;
  }
  
  // Stochastic의 GOLDEN_CROSS/DEAD_CROSS는 %K vs %D 크로스 (targetValue 무시)
  if (condition.indicatorType === 'STOCHASTIC' && condition.conditionType === 'GOLDEN_CROSS') {
    const period = condition.period ? `(${condition.period})` : '';
    return `Stochastic${period} 골든 크로스 (%K > %D)`;
  }
  if (condition.indicatorType === 'STOCHASTIC' && condition.conditionType === 'DEAD_CROSS') {
    const period = condition.period ? `(${condition.period})` : '';
    return `Stochastic${period} 데드 크로스 (%K < %D)`;
  }
  
  // DMI의 CROSS_UP/CROSS_DOWN은 +DI vs -DI 크로스 (targetValue 무시)
  if (condition.indicatorType === 'DMI' && condition.conditionType === 'CROSS_UP') {
    return `DMI 골든 크로스 (+DI > -DI)`;
  }
  if (condition.indicatorType === 'DMI' && condition.conditionType === 'CROSS_DOWN') {
    return `DMI 데드 크로스 (+DI < -DI)`;
  }
  
  let desc = indicator;
  if (condition.period) {
    desc += `(${condition.period})`;
  }
  desc += ` ${conditionName}`;
  
  // 일반 조건에서 targetValue 표시
  if (condition.targetValue !== undefined && condition.targetValue !== null) {
    desc += ` ${condition.targetValue}`;
    if (condition.secondaryValue !== undefined && condition.conditionType === 'BETWEEN') {
      desc += ` ~ ${condition.secondaryValue}`;
    }
  }
  
  return desc;
};

/**
 * 그룹 설명 생성
 */
export const generateGroupDescription = (group: ConditionGroupDto): string => {
  if (group.conditions.length === 0 && (!group.childGroups || group.childGroups.length === 0)) {
    return '빈 그룹';
  }
  
  const parts: string[] = [];
  
  group.conditions.forEach(condition => {
    parts.push(condition.description || generateConditionDescription(condition));
  });
  
  group.childGroups?.forEach(child => {
    parts.push(`(${generateGroupDescription(child)})`);
  });
  
  return parts.join(` ${group.logicalOperator} `);
};

/**
 * 빈 MA 조건 생성
 */
export const createEmptyMaCondition = (orderIndex: number = 0, signalType: SignalType = 'BUY'): MaConditionDto => ({
  maShortPeriod: signalType === 'BUY' ? 20 : 20,
  maLongPeriod: signalType === 'BUY' ? 60 : 60,
  maCrossType: signalType === 'BUY' ? 'GOLDEN_CROSS' : 'DEAD_CROSS',
  logicalOperator: 'OR',
  orderIndex,
});

/**
 * 빈 볼린저밴드 조건 생성
 */
export const createEmptyBollingerCondition = (orderIndex: number = 0, signalType: SignalType = 'BUY'): BollingerBandConditionDto => ({
  period: 20,
  stdDev: 2.0,
  bandType: signalType === 'BUY' ? 'LOWER' : 'UPPER',
  crossType: signalType === 'BUY' ? 'CROSS_UP' : 'CROSS_DOWN',
  logicalOperator: 'OR',
  orderIndex,
});

/**
 * 기존 하드코딩 필드를 새로운 배열 구조로 마이그레이션
 */
export const migrateMaConditionsToArray = (rule: StrategyRuleDto): StrategyRuleDto => {
  const migratedRule = { ...rule };
  
  // 매수 조건 마이그레이션
  if (!migratedRule.maConditionsBuy || migratedRule.maConditionsBuy.length === 0) {
    const buyConditions: MaConditionDto[] = [];
    
    // 조건 1이 있으면 추가
    if (migratedRule.maShortPeriod1Buy && migratedRule.maLongPeriod1Buy) {
      buyConditions.push({
        maShortPeriod: migratedRule.maShortPeriod1Buy,
        maLongPeriod: migratedRule.maLongPeriod1Buy,
        maCrossType: migratedRule.maCrossType1Buy || 'GOLDEN_CROSS',
        logicalOperator: 'OR',
        orderIndex: 0,
      });
    }
    
    // 조건 2가 활성화되어 있으면 추가
    if (migratedRule.enableMaCondition2Buy && migratedRule.maShortPeriod2Buy && migratedRule.maLongPeriod2Buy) {
      buyConditions.push({
        maShortPeriod: migratedRule.maShortPeriod2Buy,
        maLongPeriod: migratedRule.maLongPeriod2Buy,
        maCrossType: migratedRule.maCrossType2Buy || 'GOLDEN_CROSS',
        logicalOperator: 'OR',
        orderIndex: 1,
      });
    }
    
    // 조건이 없으면 기본 1개 생성
    if (buyConditions.length === 0) {
      buyConditions.push(createEmptyMaCondition(0, 'BUY'));
    }
    
    migratedRule.maConditionsBuy = buyConditions;
  }
  
  // 매도 조건 마이그레이션
  if (!migratedRule.maConditionsSell || migratedRule.maConditionsSell.length === 0) {
    const sellConditions: MaConditionDto[] = [];
    
    // 조건 1이 있으면 추가
    if (migratedRule.maShortPeriod1Sell && migratedRule.maLongPeriod1Sell) {
      sellConditions.push({
        maShortPeriod: migratedRule.maShortPeriod1Sell,
        maLongPeriod: migratedRule.maLongPeriod1Sell,
        maCrossType: migratedRule.maCrossType1Sell || 'DEAD_CROSS',
        logicalOperator: 'OR',
        orderIndex: 0,
      });
    }
    
    // 조건 2가 활성화되어 있으면 추가
    if (migratedRule.enableMaCondition2Sell && migratedRule.maShortPeriod2Sell && migratedRule.maLongPeriod2Sell) {
      sellConditions.push({
        maShortPeriod: migratedRule.maShortPeriod2Sell,
        maLongPeriod: migratedRule.maLongPeriod2Sell,
        maCrossType: migratedRule.maCrossType2Sell || 'DEAD_CROSS',
        logicalOperator: 'OR',
        orderIndex: 1,
      });
    }
    
    // 조건이 없으면 기본 1개 생성
    if (sellConditions.length === 0) {
      sellConditions.push(createEmptyMaCondition(0, 'SELL'));
    }
    
    migratedRule.maConditionsSell = sellConditions;
  }
  
  return migratedRule;
};

/**
 * 빈 조건 생성
 */
export const createEmptyCondition = (orderIndex: number = 0): StrategyConditionDto => ({
  indicatorType: 'RSI',
  conditionType: 'ABOVE',  // 기본값: RSI의 첫 번째 조건
  targetValue: 30,  // RSI 기본 기준값 (과매도)
  enabled: true,
  orderIndex,
  candleRange: 1,  // 기본값: 현재 캔들만
});

/**
 * 빈 그룹 생성
 */
export const createEmptyGroup = (orderIndex: number = 0, groupType: 'BUY' | 'SELL' = 'BUY'): ConditionGroupDto => ({
  logicalOperator: 'AND',
  orderIndex,
  groupType,
  conditions: [createEmptyCondition(0)],
  childGroups: [],
});

/**
 * 빈 규칙 생성
 */
export const createEmptyRule = (signalType: SignalType = 'BUY', trendType: TrendType = 'ALL'): StrategyRuleDto => ({
  name: '',
  description: '',
  signalType,
  trendType,
  enabled: true,
  
  // ==================== 매수 조건 기본값 ====================
  // 매수: 이동평균선 조건 (새로운 배열 구조)
  enableMaBuy: false,
  maConditionsBuy: [createEmptyMaCondition(0, 'BUY')],
  
  // 매수: 이동평균선 조건 1 (하위 호환성)
  maShortPeriod1Buy: 20,
  maLongPeriod1Buy: 60,
  maCrossType1Buy: 'GOLDEN_CROSS',
  // 매수: 이동평균선 조건 2 (OR) (하위 호환성)
  enableMaCondition2Buy: false,
  maShortPeriod2Buy: 5,
  maLongPeriod2Buy: 20,
  maCrossType2Buy: 'GOLDEN_CROSS',
  // 매수: 일목균형표
  enableIchimokuBuy: false,
  ichimokuTenkanBuy: 9,
  ichimokuKijunBuy: 26,
  ichimokuCrossTypeBuy: 'CROSS_UP',
  // 매수: 볼린저밴드 조건
  enableBollingerBuy: false,
  bollingerConditionsBuy: [createEmptyBollingerCondition(0, 'BUY')],
  // 매수: 거래량 필터 (골든크로스용, 기본 활성화)
  enableVolumeFilterBuy: true,
  
  // ==================== 매도 조건 기본값 ====================
  // 매도: 이동평균선 조건 (새로운 배열 구조)
  enableMaSell: false,
  maConditionsSell: [createEmptyMaCondition(0, 'SELL')],
  
  // 매도: 이동평균선 조건 1 (하위 호환성)
  maShortPeriod1Sell: 20,
  maLongPeriod1Sell: 60,
  maCrossType1Sell: 'DEAD_CROSS',
  // 매도: 이동평균선 조건 2 (OR) (하위 호환성)
  enableMaCondition2Sell: false,
  maShortPeriod2Sell: 5,
  maLongPeriod2Sell: 20,
  maCrossType2Sell: 'DEAD_CROSS',
  // 매도: 일목균형표
  enableIchimokuSell: false,
  ichimokuTenkanSell: 9,
  ichimokuKijunSell: 26,
  ichimokuCrossTypeSell: 'CROSS_DOWN',
  // 매도: 볼린저밴드 조건
  enableBollingerSell: false,
  bollingerConditionsSell: [createEmptyBollingerCondition(0, 'SELL')],
  
  // 보조지표 ON/OFF
  enableAuxBuy: false,
  enableAuxSell: false,
  
  // 그룹 간 논리연산자 (기본값: OR - 하나 이상 충족 시 신호 발생)
  interGroupOperatorBuy: 'OR',
  interGroupOperatorSell: 'OR',
  
  // 매수/매도 보조지표 조건 그룹
  buyConditionGroups: [createEmptyGroup(0, 'BUY')],
  sellConditionGroups: [createEmptyGroup(0, 'SELL')],
});

/**
 * 기본 매수 조건 템플릿
 */
export const getBuyConditionTemplates = (): StrategyRuleDto[] => [
  {
    name: 'RSI 과매도 매수',
    description: 'RSI가 30 이하로 하락 후 상향 돌파 시 매수',
    signalType: 'BUY',
    enabled: true,
    buyConditionGroups: [{
      logicalOperator: 'AND',
      orderIndex: 0,
      groupType: 'BUY',
      conditions: [{
        indicatorType: 'RSI',
        conditionType: 'CROSS_UP',
        targetValue: 30,
        period: 14,
        enabled: true,
        orderIndex: 0,
      }],
      childGroups: [],
    }],
  },
  {
    name: 'MACD 골든크로스 매수',
    description: 'MACD 골든크로스 발생 시 매수',
    signalType: 'BUY',
    enabled: true,
    buyConditionGroups: [{
      logicalOperator: 'AND',
      orderIndex: 0,
      groupType: 'BUY',
      conditions: [{
        indicatorType: 'MACD',
        conditionType: 'GOLDEN_CROSS',
        enabled: true,
        orderIndex: 0,
      }],
      childGroups: [],
    }],
  },
  {
    name: 'Stochastic 과매도 + RSI 상승',
    description: 'Stochastic 20 상향 돌파 AND RSI 상승 중',
    signalType: 'BUY',
    enabled: true,
    buyConditionGroups: [{
      logicalOperator: 'AND',
      orderIndex: 0,
      groupType: 'BUY',
      conditions: [
        {
          indicatorType: 'STOCHASTIC',
          conditionType: 'GOLDEN_CROSS',
          period: 14,
          enabled: true,
          orderIndex: 0,
        },
        {
          indicatorType: 'RSI',
          conditionType: 'INCREASING',
          period: 14,
          enabled: true,
          orderIndex: 1,
        },
      ],
      childGroups: [],
    }],
  },
];

/**
 * 기본 매도 조건 템플릿
 */
export const getSellConditionTemplates = (): StrategyRuleDto[] => [
  {
    name: 'RSI 과매수 매도',
    description: 'RSI가 70 이상으로 상승 후 하향 돌파 시 매도',
    signalType: 'SELL',
    enabled: true,
    sellConditionGroups: [{
      logicalOperator: 'AND',
      orderIndex: 0,
      groupType: 'SELL',
      conditions: [{
        indicatorType: 'RSI',
        conditionType: 'CROSS_DOWN',
        targetValue: 70,
        period: 14,
        enabled: true,
        orderIndex: 0,
      }],
      childGroups: [],
    }],
  },
  {
    name: 'MACD 데드크로스 매도',
    description: 'MACD 데드크로스 발생 시 매도',
    signalType: 'SELL',
    enabled: true,
    sellConditionGroups: [{
      logicalOperator: 'AND',
      orderIndex: 0,
      groupType: 'SELL',
      conditions: [{
        indicatorType: 'MACD',
        conditionType: 'DEAD_CROSS',
        enabled: true,
        orderIndex: 0,
      }],
      childGroups: [],
    }],
  },
];

