실전 트레이딩 봇 고도화: DCA 6단계 물타기 + 뉴스 감성분석 + 동적 헤징 전략

# src/dca_strategy.py
from dataclasses import dataclass
from typing import List, Optional

@dataclass
class DCALevel:
    """DCA 단계 정의"""
    level: int
    trigger_drop_pct: float  # 하락률 (예: -5%)
    buy_ratio: float         # 초기 투자 대비 추가 매수 비율 (예: 0.2 = 20%)
    executed: bool = False
    executed_price: Optional[float] = None
    executed_amount: Optional[float] = None

class DCAManager:
    def __init__(self, initial_capital: float, base_price: float):
        """
        initial_capital: 총 DCA 예산
        base_price: 초기 진입가
        """
        self.total_budget = initial_capital
        self.base_price = base_price
        self.base_investment = initial_capital * 0.192  # 초기 투자 19.2% (총 6단계 균형)
        
        # 6단계 DCA 레벨 정의
        self.levels: List[DCALevel] = [
            DCALevel(1, -5.0, 0.20),   # -5%: 초기 투자의 20%
            DCALevel(2, -10.0, 0.30),  # -10%: 30%
            DCALevel(3, -20.0, 0.50),  # -20%: 50%
            DCALevel(4, -30.0, 0.70),  # -30%: 70%
            DCALevel(5, -40.0, 1.00),  # -40%: 100%
            DCALevel(6, -50.0, 1.50),  # -50%: 150%
        ]
        
        self.total_invested = self.base_investment
        self.total_coins = self.base_investment / base_price
        self.remaining_budget = self.total_budget - self.base_investment

    def check_trigger(self, current_price: float) -> Optional[DCALevel]:
        """현재가 기준으로 실행 가능한 DCA 레벨 확인"""
        drop_pct = (current_price - self.base_price) / self.base_price * 100
        
        for level in self.levels:
            if not level.executed and drop_pct <= level.trigger_drop_pct:
                return level
        
        return None

    def execute_dca(self, level: DCALevel, current_price: float) -> dict:
        """DCA 레벨 실행"""
        buy_amount = self.base_investment * level.buy_ratio
        
        if buy_amount > self.remaining_budget:
            buy_amount = self.remaining_budget  # 남은 예산만 사용
        
        coins_to_buy = buy_amount / current_price
        
        # 상태 업데이트
        level.executed = True
        level.executed_price = current_price
        level.executed_amount = coins_to_buy
        
        self.total_invested += buy_amount
        self.total_coins += coins_to_buy
        self.remaining_budget -= buy_amount
        
        avg_price = self.total_invested / self.total_coins
        
        return {
            'level': level.level,
            'trigger_drop': level.trigger_drop_pct,
            'buy_amount': buy_amount,
            'buy_price': current_price,
            'coins_bought': coins_to_buy,
            'total_coins': self.total_coins,
            'avg_price': avg_price,
            'total_invested': self.total_invested,
            'remaining_budget': self.remaining_budget,
        }

    def get_avg_price(self) -> float:
        """현재 평균 단가"""
        return self.total_invested / self.total_coins if self.total_coins > 0 else 0

    def is_budget_exhausted(self) -> bool:
        """DCA 예산 소진 여부"""
        return self.remaining_budget < self.base_investment * 0.1  # 10% 미만 남으면 소진으로 간주

# src/news_sentiment.py
import anthropic
import os
from typing import List, Dict
from datetime import datetime

class NewsSentimentAnalyzer:
    def __init__(self):
        self.client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.model = "claude-3-5-sonnet-20241022"
    
    def analyze_crypto_news(self, news_list: List[Dict]) -> float:
        """
        뉴스 리스트 감성 분석
        
        Args:
            news_list: [{'title': str, 'summary': str, 'source': str}, ...]
        
        Returns:
            float: -1.0 (매우 부정) ~ +1.0 (매우 긍정)
        """
        news_text = "\n\n".join([
            f"[{news['source']}] {news['title']}\n{news.get('summary', '')}"
            for news in news_list
        ])
        
        prompt = f"""다음은 최근 4시간 동안의 암호화폐 관련 뉴스입니다.

{news_text}

위 뉴스들을 종합적으로 분석하여 암호화폐 시장 전반에 대한 감성 점수를 -1.0에서 +1.0 사이로 평가해주세요.

- +1.0: 매우 긍정적 (강력한 상승 신호)
- +0.5: 긍정적 (온건한 상승 기대)
- 0.0: 중립
- -0.5: 부정적 (하락 우려)
- -1.0: 매우 부정적 (강력한 하락 신호)

분석 시 고려사항:
1. 규제/정책 뉴스의 영향력
2. 주요 거래소·기업의 동향
3. 기술적 발전 vs 보안 사고
4. 거시경제 지표와의 연관성
5. 과장된 표현 vs 실질적 영향

응답 형식: 숫자만 출력 (예: 0.3)"""

        response = self.client.messages.create(
            model=self.model,
            max_tokens=50,
            messages=[{"role": "user", "content": prompt}]
        )
        
        try:
            score = float(response.content[0].text.strip())
            return max(-1.0, min(1.0, score))  # 범위 제한
        except ValueError:
            return 0.0  # 파싱 실패 시 중립

class HybridSignalGenerator:
    def __init__(self, news_analyzer: NewsSentimentAnalyzer):
        self.news_analyzer = news_analyzer
        self.last_news_check = None
        self.cached_sentiment = 0.0
    
    def generate_signal(self, news_list: List[Dict] = None) -> str:
        """
        하이브리드 시그널 생성
        
        Returns:
            'BUY', 'SELL', 'HOLD'
        """
        import random
        
        # 1. 랜덤 시그널 (50%)
        random_value = random.uniform(-1, 1)
        
        # 2. 뉴스 감성 시그널 (50%)
        if news_list:
            sentiment = self.news_analyzer.analyze_crypto_news(news_list)
            self.cached_sentiment = sentiment
        else:
            sentiment = self.cached_sentiment
        
        # 3. 하이브리드 점수 (평균)
        hybrid_score = (random_value + sentiment) / 2
        
        # 4. 시그널 변환 (임계값 기반)
        if hybrid_score > 0.2:
            return 'BUY'
        elif hybrid_score < -0.2:
            return 'SELL'
        else:
            return 'HOLD'

# src/news_collector.py
import feedparser
from datetime import datetime, timedelta
from typing import List, Dict

class CryptoNewsCollector:
    def __init__(self):
        self.rss_feeds = [
            'https://cointelegraph.com/rss',
            'https://www.coindesk.com/arc/outboundfeeds/rss/',
            'https://decrypt.co/feed',
            # 추가 피드...
        ]
    
    def fetch_recent_news(self, hours: int = 4) -> List[Dict]:
        """최근 N시간 뉴스 수집"""
        cutoff_time = datetime.now() - timedelta(hours=hours)
        all_news = []
        
        for feed_url in self.rss_feeds:
            try:
                feed = feedparser.parse(feed_url)
                for entry in feed.entries:
                    pub_date = datetime(*entry.published_parsed[:6])
                    
                    if pub_date >= cutoff_time:
                        all_news.append({
                            'title': entry.title,
                            'summary': entry.get('summary', '')[:300],
                            'source': feed.feed.title,
                            'published': pub_date.isoformat(),
                        })
            except Exception as e:
                print(f"피드 수집 실패 {feed_url}: {e}")
        
        # 최신순 정렬
        all_news.sort(key=lambda x: x['published'], reverse=True)
        return all_news[:20]  # 최대 20개

# src/phase_defense.py
from enum import Enum
from loguru import logger

class TradingPhase(Enum):
    DCA_ACTIVE = "DCA_ACTIVE"       # DCA 예산 있음
    DCA_EXHAUSTED = "DCA_EXHAUSTED" # DCA 예산 소진, 방어 모드

class PhaseDefenseManager:
    def __init__(self, dca_manager, notifier):
        self.dca_manager = dca_manager
        self.notifier = notifier
        self.phase = TradingPhase.DCA_ACTIVE
        self.alert_sent_3pct = False
        self.reduced_at_5pct = False
    
    def update_phase(self):
        """현재 Phase 업데이트"""
        if self.dca_manager.is_budget_exhausted():
            if self.phase != TradingPhase.DCA_EXHAUSTED:
                self.phase = TradingPhase.DCA_EXHAUSTED
                self.notifier.send(
                    "⚠️ <b>Phase 전환</b>\n\n"
                    "DCA 예산 소진 → 방어 모드 진입\n"
                    "평단가 기준 -3%/-5%/-8% 방어 정책 활성화"
                )
                logger.warning("Phase 전환: DCA_ACTIVE -> DCA_EXHAUSTED")
    
    def check_defense_trigger(self, current_price: float, position_size: float) -> dict:
        """방어 정책 체크 (Phase 2에서만 동작)"""
        if self.phase != TradingPhase.DCA_EXHAUSTED:
            return {'action': 'NONE'}
        
        avg_price = self.dca_manager.get_avg_price()
        drop_from_avg = (current_price - avg_price) / avg_price * 100
        
        # -8% 전량 청산
        if drop_from_avg <= -8.0:
            self.notifier.send(
                f"🚨 <b>긴급 청산 실행</b>\n\n"
                f"평단가 대비: {drop_from_avg:.2f}%\n"
                f"현재가: {current_price:,.0f}원\n"
                f"평단가: {avg_price:,.0f}원\n\n"
                f"포지션 전량 청산 + 봇 중지"
            )
            return {
                'action': 'LIQUIDATE_ALL',
                'reason': f'평단가 대비 {drop_from_avg:.2f}% 하락',
                'sell_ratio': 1.0
            }
        
        # -5% 50% 감축
        if drop_from_avg <= -5.0 and not self.reduced_at_5pct:
            self.reduced_at_5pct = True
            self.notifier.send(
                f"⚠️ <b>포지션 50% 감축</b>\n\n"
                f"평단가 대비: {drop_from_avg:.2f}%\n"
                f"현재가: {current_price:,.0f}원\n"
                f"평단가: {avg_price:,.0f}원"
            )
            return {
                'action': 'REDUCE_POSITION',
                'reason': f'평단가 대비 {drop_from_avg:.2f}% 하락',
                'sell_ratio': 0.5
            }
        
        # -3% 알림
        if drop_from_avg <= -3.0 and not self.alert_sent_3pct:
            self.alert_sent_3pct = True
            self.notifier.send(
                f"⚡ <b>하락 알림</b>\n\n"
                f"평단가 대비: {drop_from_avg:.2f}%\n"
                f"현재가: {current_price:,.0f}원\n"
                f"평단가: {avg_price:,.0f}원\n\n"
                f"추가 하락 시 -5%에서 50% 감축 예정"
            )
        
        return {'action': 'NONE'}

# src/volatility_monitor.py
from collections import deque
from datetime import datetime
from loguru import logger

class VolatilityMonitor:
    def __init__(self, threshold_pct: float = 3.0, window_minutes: int = 15):
        """
        threshold_pct: 알림 발동 변동률 (예: 3.0 = ±3%)
        window_minutes: 감시 시간 창 (분)
        """
        self.threshold = threshold_pct
        self.window_minutes = window_minutes
        self.price_history = deque(maxlen=window_minutes)  # 최근 15분 가격
    
    def update(self, current_price: float) -> dict:
        """
        가격 업데이트 및 급변 감지
        
        Returns:
            {'alert': bool, 'change_pct': float, 'direction': str}
        """
        now = datetime.now()
        self.price_history.append({'time': now, 'price': current_price})
        
        if len(self.price_history) < 2:
            return {'alert': False}
        
        # 15분 전 가격과 비교
        oldest_price = self.price_history[0]['price']
        change_pct = (current_price - oldest_price) / oldest_price * 100
        
        if abs(change_pct) >= self.threshold:
            direction = "상승" if change_pct > 0 else "하락"
            logger.warning(f"급변 감지: {change_pct:+.2f}% ({direction})")
            
            return {
                'alert': True,
                'change_pct': change_pct,
                'direction': direction,
                'old_price': oldest_price,
                'new_price': current_price,
            }
        
        return {'alert': False}

# 메인 루프에 통합
def monitor_loop(exchange, volatility_monitor, notifier):
    """1분마다 실행"""
    current_price = exchange.get_ticker('BTC/USDT')['last']
    result = volatility_monitor.update(current_price)
    
    if result['alert']:
        emoji = "🚀" if result['change_pct'] > 0 else "⚡"
        notifier.send(
            f"{emoji} <b>15분 급변 감지!</b>\n\n"
            f"변동폭: {result['change_pct']:+.2f}%\n"
            f"방향: {result['direction']}\n"
            f"이전: {result['old_price']:,.0f}원\n"
            f"현재: {result['new_price']:,.0f}원"
        )

# src/order_manager.py
from typing import List, Dict

class LimitOrderManager:
    def __init__(self, exchange):
        self.exchange = exchange
        self.active_orders: List[str] = []  # 주문 ID 목록
    
    def register_dca_orders(self, symbol: str, dca_manager) -> List[Dict]:
        """DCA 물타기 주문 사전 등록"""
        orders = []
        
        for level in dca_manager.levels:
            if level.executed:
                continue
            
            # 트리거 가격 계산
            trigger_price = dca_manager.base_price * (1 + level.trigger_drop_pct / 100)
            buy_amount_usd = dca_manager.base_investment * level.buy_ratio
            buy_quantity = buy_amount_usd / trigger_price
            
            try:
                order = self.exchange.create_limit_buy_order(
                    symbol=symbol,
                    amount=buy_quantity,
                    price=trigger_price
                )
                
                self.active_orders.append(order['id'])
                orders.append({
                    'level': level.level,
                    'order_id': order['id'],
                    'price': trigger_price,
                    'amount': buy_quantity,
                })
                
                logger.info(f"DCA Level {level.level} 지정가 주문 등록: {trigger_price:,.0f}원")
            
            except Exception as e:
                logger.error(f"지정가 주문 실패: {e}")
        
        return orders
    
    def register_take_profit_orders(self, symbol: str, avg_price: float, 
                                     total_coins: float, targets: List[float]) -> List[Dict]:
        """익절 주문 사전 등록 (분할 익절)"""
        orders = []
        coins_per_target = total_coins / len(targets)
        
        for i, profit_pct in enumerate(targets):
            target_price = avg_price * (1 + profit_pct / 100)
            
            try:
                order = self.exchange.create_limit_sell_order(
                    symbol=symbol,
                    amount=coins_per_target,
                    price=target_price
                )
                
                self.active_orders.append(order['id'])
                orders.append({
                    'target': f'+{profit_pct}%',
                    'order_id': order['id'],
                    'price': target_price,
                    'amount': coins_per_target,
                })
                
                logger.info(f"익절 주문 등록 (+{profit_pct}%): {target_price:,.0f}원")
            
            except Exception as e:
                logger.error(f"익절 주문 실패: {e}")
        
        return orders
    
    def cancel_all_orders(self):
        """모든 미체결 주문 취소"""
        for order_id in self.active_orders:
            try:
                self.exchange.cancel_order(order_id)
            except:
                pass
        self.active_orders.clear()

# 초기 진입 후
order_manager.register_dca_orders('BTC/USDT', dca_manager)
order_manager.register_take_profit_orders(
    'BTC/USDT',
    avg_price=50_000_000,
    total_coins=0.02,
    targets=[5, 10, 15, 20]  # +5%, +10%, +15%, +20% 분할 익절
)

# src/hedging_manager.py
import ccxt

class BybitHedgingManager:
    def __init__(self, api_key: str, api_secret: str):
        self.exchange = ccxt.bybit({
            'apiKey': api_key,
            'secret': api_secret,
            'options': {'defaultType': 'future'},  # 선물 거래
        })
    
    def calculate_hedge_ratio(self, sentiment_score: float) -> float:
        """
        뉴스 감성 점수로 헤지 비율 계산
        
        Args:
            sentiment_score: -1.0 ~ +1.0
        
        Returns:
            0.0 ~ 1.0 (헤지 비율)
        """
        if sentiment_score >= 0.5:
            # BULLISH: 0~20% 헤지
            return 0.0 + (0.5 - sentiment_score) * 0.4  # 0~0.2
        elif sentiment_score <= -0.5:
            # BEARISH: 80~100% 헤지
            return 0.8 + (-0.5 - sentiment_score) * 0.4  # 0.8~1.0
        else:
            # NEUTRAL: 40~60% 헤지 (선형 보간)
            return 0.4 + (0.5 - sentiment_score) * 0.2  # 0.4~0.6
    
    def adjust_hedge_position(self, symbol: str, spot_position_value: float, 
                               target_hedge_ratio: float):
        """
        헤지 포지션 조정 (Short 선물)
        
        Args:
            symbol: 'BTC/USDT:USDT' (Bybit 영구선물)
            spot_position_value: 현물 포지션 가치 (USDT)
            target_hedge_ratio: 목표 헤지 비율 (0.0~1.0)
        """
        target_short_value = spot_position_value * target_hedge_ratio
        
        # 현재 선물 포지션 조회
        positions = self.exchange.fetch_positions([symbol])
        current_short_value = 0
        
        for pos in positions:
            if pos['side'] == 'short':
                current_short_value = abs(pos['notional'])
        
        # 조정 필요 여부 판단
        diff_value = target_short_value - current_short_value
        
        if abs(diff_value) < spot_position_value * 0.05:  # 5% 미만 차이는 무시
            logger.info(f"헤지 포지션 유지 (현재: {current_short_value:.2f} USDT)")
            return
        
        # 포지션 조정
        current_price = self.exchange.fetch_ticker(symbol)['last']
        contracts_to_adjust = diff_value / current_price
        
        try:
            if contracts_to_adjust > 0:
                # 헤지 증가 (Short 추가)
                order = self.exchange.create_market_sell_order(symbol, abs(contracts_to_adjust))
                logger.info(f"헤지 증가: {abs(contracts_to_adjust):.6f} BTC Short")
            else:
                # 헤지 감소 (Short 청산)
                order = self.exchange.create_market_buy_order(symbol, abs(contracts_to_adjust))
                logger.info(f"헤지 감소: {abs(contracts_to_adjust):.6f} BTC 청산")
        
        except Exception as e:
            logger.error(f"헤지 조정 실패: {e}")

# 4시간마다 실행
def hedge_rebalance_task(spot_value, sentiment_score, hedging_manager):
    hedge_ratio = hedging_manager.calculate_hedge_ratio(sentiment_score)
    logger.info(f"목표 헤지 비율: {hedge_ratio*100:.1f}% (감성: {sentiment_score:+.2f})")
    
    hedging_manager.adjust_hedge_position(
        'BTC/USDT:USDT',
        spot_value,
        hedge_ratio
    )

# main.py에 추가
import schedule

def news_analysis_task(news_collector, sentiment_analyzer, signal_generator, notifier):
    """4시간마다 뉴스 분석 + 시그널 생성"""
    logger.info("뉴스 분석 작업 시작")
    
    # 1. 뉴스 수집
    news_list = news_collector.fetch_recent_news(hours=4)
    logger.info(f"수집된 뉴스: {len(news_list)}개")
    
    # 2. 감성 분석
    sentiment_score = sentiment_analyzer.analyze_crypto_news(news_list)
    logger.info(f"감성 점수: {sentiment_score:+.2f}")
    
    # 3. 시그널 생성
    signal = signal_generator.generate_signal(news_list)
    logger.info(f"생성된 시그널: {signal}")
    
    # 4. 알림 발송
    sentiment_emoji = "🟢" if sentiment_score > 0 else "🔴" if sentiment_score < 0 else "⚪"
    notifier.send(
        f"{sentiment_emoji} <b>4시간 뉴스 분석 완료</b>\n\n"
        f"📰 수집: {len(news_list)}개\n"
        f"💭 감성: {sentiment_score:+.2f}\n"
        f"📊 시그널: {signal}\n\n"
        f"다음 분석: 4시간 후"
    )

# 스케줄 등록
schedule.every(4).hours.do(
    news_analysis_task,
    news_collector,
    sentiment_analyzer,
    signal_generator,
    notifier
)

# src/paper_trading.py
from datetime import datetime
from typing import Dict, List

class PaperTradingExchange:
    """모의 거래소 (실제 주문 없이 시뮬레이션)"""
    
    def __init__(self, initial_balance: float = 10_000_000):
        self.balance = {'USDT': initial_balance, 'BTC': 0.0}
        self.orders: List[Dict] = []
        self.trades: List[Dict] = []
    
    def create_market_buy_order(self, symbol: str, amount: float, price: float) -> Dict:
        """시장가 매수 (시뮬레이션)"""
        cost = amount * price
        fee = cost * 0.001  # 0.1% 수수료
        
        if self.balance['USDT'] < cost + fee:
            raise Exception("잔고 부족")
        
        self.balance['USDT'] -= (cost + fee)
        self.balance['BTC'] += amount
        
        trade = {
            'id': f"PAPER_{len(self.trades)}",
            'timestamp': datetime.now().isoformat(),
            'symbol': symbol,
            'side': 'buy',
            'amount': amount,
            'price': price,
            'cost': cost,
            'fee': fee,
        }
        self.trades.append(trade)
        
        return trade
    
    def create_market_sell_order(self, symbol: str, amount: float, price: float) -> Dict:
        """시장가 매도 (시뮬레이션)"""
        if self.balance['BTC'] < amount:
            raise Exception("보유량 부족")
        
        proceeds = amount * price
        fee = proceeds * 0.001
        
        self.balance['BTC'] -= amount
        self.balance['USDT'] += (proceeds - fee)
        
        trade = {
            'id': f"PAPER_{len(self.trades)}",
            'timestamp': datetime.now().isoformat(),
            'symbol': symbol,
            'side': 'sell',
            'amount': amount,
            'price': price,
            'cost': proceeds,
            'fee': fee,
        }
        self.trades.append(trade)
        
        return trade
    
    def get_balance(self) -> Dict:
        """잔고 조회"""
        return self.balance.copy()
    
    def get_trades(self) -> List[Dict]:
        """거래 내역"""
        return self.trades.copy()

# 사용
paper_mode = True  # 환경변수로 관리 권장

if paper_mode:
    exchange = PaperTradingExchange(initial_balance=10_000_000)
else:
    exchange = ccxt.upbit({...})  # 실거래소

# main.py
import schedule
import time
from loguru import logger
from dotenv import load_dotenv
import os

load_dotenv()

from src.dca_strategy import DCAManager
from src.phase_defense import PhaseDefenseManager, TradingPhase
from src.news_sentiment import NewsSentimentAnalyzer, HybridSignalGenerator
from src.news_collector import CryptoNewsCollector
from src.volatility_monitor import VolatilityMonitor
from src.order_manager import LimitOrderManager
from src.hedging_manager import BybitHedgingManager
from src.paper_trading import PaperTradingExchange
from src.notifier import TelegramNotifier

# 설정
PAPER_MODE = os.getenv('PAPER_MODE', 'true').lower() == 'true'
SYMBOL = 'BTC/USDT'
INITIAL_CAPITAL = 10_000_000  # 1천만원
BASE_PRICE = 50_000_000  # 초기 진입가 5천만원

def setup():
    """시스템 초기화"""
    # Exchange
    if PAPER_MODE:
        exchange = PaperTradingExchange(INITIAL_CAPITAL)
        logger.warning("⚠️ PAPER MODE: 모의매매 모드")
    else:
        import ccxt
        exchange = ccxt.upbit({
            'apiKey': os.getenv('UPBIT_API_KEY'),
            'secret': os.getenv('UPBIT_SECRET'),
        })
    
    # Components
    dca_manager = DCAManager(INITIAL_CAPITAL * 0.5, BASE_PRICE)  # DCA 예산 50%
    notifier = TelegramNotifier()
    phase_defense = PhaseDefenseManager(dca_manager, notifier)
    
    news_collector = CryptoNewsCollector()
    sentiment_analyzer = NewsSentimentAnalyzer()
    signal_generator = HybridSignalGenerator(sentiment_analyzer)
    
    volatility_monitor = VolatilityMonitor(threshold_pct=3.0)
    order_manager = LimitOrderManager(exchange)
    
    hedging_manager = None
    if not PAPER_MODE:
        hedging_manager = BybitHedgingManager(
            os.getenv('BYBIT_API_KEY'),
            os.getenv('BYBIT_SECRET')
        )
    
    return {
        'exchange': exchange,
        'dca': dca_manager,
        'phase': phase_defense,
        'notifier': notifier,
        'news_collector': news_collector,
        'sentiment': sentiment_analyzer,
        'signal': signal_generator,
        'volatility': volatility_monitor,
        'orders': order_manager,
        'hedging': hedging_manager,
    }

def volatility_check_task(ctx):
    """1분마다: 급변 감지"""
    current_price = 50_000_000  # 실제로는 exchange.fetch_ticker(SYMBOL)['last']
    result = ctx['volatility'].update(current_price)
    
    if result['alert']:
        emoji = "🚀" if result['change_pct'] > 0 else "⚡"
        ctx['notifier'].send(
            f"{emoji} <b>15분 급변!</b> {result['change_pct']:+.2f}%"
        )

def dca_check_task(ctx):
    """15분마다: DCA 트리거 체크"""
    current_price = 50_000_000  # 실제 가격
    
    # Phase 업데이트
    ctx['phase'].update_phase()
    
    # DCA 레벨 체크
    level = ctx['dca'].check_trigger(current_price)
    if level and ctx['phase'].phase == TradingPhase.DCA_ACTIVE:
        result = ctx['dca'].execute_dca(level, current_price)
        ctx['notifier'].send(
            f"💧 <b>DCA Level {result['level']} 실행</b>\n\n"
            f"매수가: {result['buy_price']:,.0f}원\n"
            f"수량: {result['coins_bought']:.6f} BTC\n"
            f"평단가: {result['avg_price']:,.0f}원"
        )
    
    # 방어 정책 체크
    defense_action = ctx['phase'].check_defense_trigger(current_price, 0.1)
    if defense_action['action'] == 'LIQUIDATE_ALL':
        # 전량 청산
        logger.critical("긴급 청산 실행!")
        # exchange.create_market_sell_order(...)

def news_analysis_task(ctx):
    """4시간마다: 뉴스 분석 + 헤지 조정"""
    news_list = ctx['news_collector'].fetch_recent_news(hours=4)
    sentiment = ctx['sentiment'].analyze_crypto_news(news_list)
    signal = ctx['signal'].generate_signal(news_list)
    
    ctx['notifier'].send(
        f"📰 <b>뉴스 분석</b>\n\n"
        f"수집: {len(news_list)}개\n"
        f"감성: {sentiment:+.2f}\n"
        f"시그널: {signal}"
    )
    
    # 헤지 조정 (실전 모드만)
    if ctx['hedging']:
        spot_value = 1_000_000  # 실제 현물 가치
        hedge_ratio = ctx['hedging'].calculate_hedge_ratio(sentiment)
        ctx['hedging'].adjust_hedge_position('BTC/USDT:USDT', spot_value, hedge_ratio)

def main():
    logger.add("logs/bot.log", rotation="1 day", retention="30 days")
    logger.info("🤖 고급 트레이딩 봇 시작")
    
    ctx = setup()
    ctx['notifier'].send("🤖 봇 시작 (PAPER MODE)" if PAPER_MODE else "🤖 봇 시작 (LIVE)")
    
    # 스케줄 등록
    schedule.every(1).minutes.do(volatility_check_task, ctx)
    schedule.every(15).minutes.do(dca_check_task, ctx)
    schedule.every(4).hours.do(news_analysis_task, ctx)
    
    # 즉시 1회 실행
    news_analysis_task(ctx)
    
    while True:
        schedule.run_pending()
        time.sleep(1)

if __name__ == "__main__":
    main()