[5] 핵심 모듈 구현 – KISBroker, FundManager, StrategyLoader

# ❌ 전략이 API를 직접 호출하면...
from api import kis_auth, kis_account_api, kis_market_api, kis_order_api

class MyStrategy:
    def generate_signal(self, stock_code, data):
        # 잔고 확인하려면 어떤 모듈이지?
        balance = kis_account_api.get_balance()  # 아 이거였나?
        # 아니면 이건가?
        balance = kis_market_api.get_account_balance()  # 이건가?
        # 현재가는?
        price = kis_market_api.get_current_price(stock_code)
        # 주문은?
        kis_order_api.place_order(...)

# ✅ KISBroker를 통해 호출
class MyStrategy:
    def generate_signal(self, stock_code, data):
        balance = self._broker.get_account_balance()
        holdings = self._broker.get_holdings()
        cash = self._broker.get_available_cash()

class KISBroker(BaseBroker):
    """한국투자증권 API 래퍼"""

    async def connect(self) -> bool:
        """API 인증 + 초기화"""
        from api import kis_auth, kis_account_api, kis_market_api

        if not kis_auth.auth():
            return False

        self._connected = True
        return True

    def get_account_balance(self) -> dict:
        """계좌 잔고 조회"""
        balance_info = self._kis_market_api.get_account_balance()
        return {
            'total_balance': balance_info.get('total_value', 0),
            'available_cash': balance_info.get('available_amount', 0),
            'invested_amount': balance_info.get('purchase_amount', 0),
            'total_profit_loss': balance_info.get('total_profit_loss', 0),
            # ...
        }

    def get_holdings(self) -> List[dict]:
        """보유 종목 조회"""
        return self._kis_market_api.get_existing_holdings()

    def get_available_cash(self) -> float:
        """주문 가능 금액 조회"""
        # ...

class BaseBroker(ABC):
    @abstractmethod
    async def connect(self) -> bool: ...

    @abstractmethod
    def get_account_balance(self) -> dict: ...

    @abstractmethod
    def get_holdings(self) -> List[dict]: ...

    @abstractmethod
    def get_available_cash(self) -> float: ...

# 한국투자증권
broker = KISBroker()

# 나중에 다른 증권사로 바꾸고 싶으면?
# broker = KiwoomBroker()  # 인터페이스가 같으니 전략 코드 변경 없음

class FundManager:
    def __init__(self, initial_funds=0, max_position_count=20):
        self._lock = threading.RLock()  # 스레드 안전!

        self.total_funds = initial_funds
        self.available_funds = initial_funds
        self.reserved_funds = 0.0
        self.invested_funds = 0.0

        # 주문별 예약 추적
        self.order_reservations: Dict[str, float] = {}

def reserve_funds(self, order_id: str, amount: float) -> bool:
    with self._lock:
        if self.available_funds < amount:
            return False  # 자금 부족

        self.available_funds -= amount
        self.reserved_funds += amount
        self.order_reservations[order_id] = amount
        return True

def confirm_order(self, order_id: str, actual_amount: float) -> None:
    with self._lock:
        reserved = self.order_reservations[order_id]
        self.reserved_funds -= reserved
        self.invested_funds += actual_amount
        del self.order_reservations[order_id]

        # 예약과 실제 체결 금액의 차액 정산
        diff = reserved - actual_amount
        if diff > 0:
            self.available_funds += diff  # 남은 돈 환불

def release_investment(self, amount: float, stock_code: str = "") -> None:
    with self._lock:
        self.invested_funds -= amount
        self.available_funds += amount

def cancel_order(self, order_id: str) -> None:
    with self._lock:
        reserved = self.order_reservations[order_id]
        self.reserved_funds -= reserved
        self.available_funds += reserved
        del self.order_reservations[order_id]

def get_max_buy_amount(self, stock_code: str) -> float:
    with self._lock:
        max_per_stock = self.total_funds * self.max_position_ratio  # 9%
        max_total = self.total_funds * self.max_total_investment_ratio  # 90%
        remaining = max_total - self.invested_funds - self.reserved_funds

        return min(max_per_stock, remaining, self.available_funds)

def can_add_position(self, stock_code: str) -> bool:
    with self._lock:
        if stock_code in self.current_position_codes:
            return True  # 이미 보유 중이면 분할매수 허용
        return len(self.current_position_codes) < self.max_position_count

# 매도 후 30분간 같은 종목 재매수 금지
self._sell_cooldowns: Dict[str, datetime] = {}
self.sell_cooldown_minutes = 30

# ❌ 전략을 추가할 때마다 main.py를 수정
from strategies.breakout import BreakoutStrategy
from strategies.orb import ORBStrategy
from strategies.momentum import MomentumStrategy  # 새로 추가

strategy = MomentumStrategy()  # 매번 직접 연결

class StrategyLoader:
    STRATEGIES_DIR = Path("strategies")

    @staticmethod
    def discover_strategies() -> Dict[str, Path]:
        strategies_dir = StrategyLoader.STRATEGIES_DIR
        discovered = {}

        for path in strategies_dir.iterdir():
            # 폴더이고, _로 시작하지 않고, 필수 파일이 있으면 전략
            if path.is_dir() and not path.name.startswith('_'):
                if StrategyLoader.validate_strategy(path):
                    discovered[path.name] = path

        return discovered

@staticmethod
def validate_strategy(strategy_path: Path) -> bool:
    if not strategy_path.is_dir():
        return False

    config_file = strategy_path / "config.yaml"
    strategy_file = strategy_path / "strategy.py"

    return config_file.exists() and strategy_file.exists()

@staticmethod
def load_strategy(strategy_name: str) -> BaseStrategy:
    # 1. 설정 로드
    config_loader = StrategyConfig(strategy_name)
    config = config_loader.load()  # config.yaml → dict

    # 2. 전략 클래스 동적 로드
    strategy_class = StrategyLoader._load_strategy_class(strategy_name)

    # 3. 인스턴스 생성 (설정 주입)
    return strategy_class(config)

# strategy.py 안에서 이런 클래스를 자동 발견
class SampleStrategy(BaseStrategy):   # ✅ 이름이 Strategy로 끝남 + BaseStrategy 상속
    ...

class Helper:                          # ❌ Strategy로 안 끝남 → 무시
    ...

class StrategyConfig:
    def load(self) -> Dict[str, Any]:
        with open(self._config_path, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f)

    def get(self, key: str, default=None):
        """점(.) 표기법으로 중첩 키 접근"""
        keys = key.split('.')
        value = self._config
        for k in keys:
            if isinstance(value, dict) and k in value:
                value = value[k]
            else:
                return default
        return value

config.get('risk_management.stop_loss_pct', 0.05)
# config.yaml의 risk_management: → stop_loss_pct: 값을 가져옴
# 없으면 기본값 0.05

# strategies/my_breakout/strategy.py
from strategies.base import BaseStrategy, Signal, SignalType

class MyBreakoutStrategy(BaseStrategy):
    name = "MyBreakout"
    version = "1.0.0"

    def on_init(self, broker, data_provider, executor):
        self._broker = broker
        self._data_provider = data_provider
        self._executor = executor
        self._is_initialized = True
        return True

    def generate_signal(self, stock_code, data, timeframe='daily'):
        # 여기에 돌파 로직 작성
        ...

    def on_order_filled(self, order): ...
    def on_market_open(self): ...
    def on_market_close(self): ...