✍️ 필사 모드: 코어-새틀라이트 ETF 자동 리밸런싱

# 목표: 연 6-8% 수익, 최대 낙폭 15% 이내
# 대상: 은퇴 10-15년 전, 원금 보존 중시
portfolio:
  name: '안정 성장형'
  core_weight: 0.80
  satellite_weight: 0.20

  core:
    - ticker: 'KODEX 미국S&P500TR'
      weight: 0.30
      role: '미국 시장 베타'
    - ticker: 'KODEX 200'
      weight: 0.15
      role: '한국 시장 베타'
    - ticker: 'TIGER 미국채10년선물'
      weight: 0.20
      role: '금리 하락 시 방어'
    - ticker: 'KODEX 종합채권(AA-이상)액티브'
      weight: 0.15
      role: '안정적 이자 수익'

  satellite:
    - ticker: 'TIGER 금은선물(H)'
      weight: 0.10
      role: '인플레이션 헤지'
    - ticker: 'TIGER 미국배당다우존스'
      weight: 0.10
      role: '배당 수익'

  expected:
    annual_return: '6-8%'
    max_drawdown: '-15%'
    total_expense_ratio: '0.07%'

# 목표: 연 10-12% 수익, 최대 낙폭 25% 감수
# 대상: 투자 기간 15년 이상, 적극적 성장 추구
portfolio:
  name: '성장 추구형'
  core_weight: 0.65
  satellite_weight: 0.35

  core:
    - ticker: 'TIGER 미국S&P500'
      weight: 0.35
      role: '미국 시장 베타'
    - ticker: 'TIGER 미국나스닥100'
      weight: 0.15
      role: '기술주 성장'
    - ticker: 'KODEX 200'
      weight: 0.10
      role: '한국 시장 베타'
    - ticker: 'TIGER 미국채10년선물'
      weight: 0.05
      role: '최소 채권 배분'

  satellite:
    - ticker: 'TIGER 반도체'
      weight: 0.12
      role: '반도체 사이클 알파'
    - ticker: 'KODEX 2차전지산업'
      weight: 0.08
      role: '2차전지 성장'
    - ticker: 'TIGER Fn반도체TOP10'
      weight: 0.08
      role: '한국 반도체 집중'
    - ticker: 'TIGER 인도니프티50'
      weight: 0.07
      role: '인도 시장 성장'

  expected:
    annual_return: '10-12%'
    max_drawdown: '-25%'
    total_expense_ratio: '0.15%'

# 목표: 어떤 시장 환경에서도 양의 수익 추구
# 대상: 변동성을 극도로 싫어하는 투자자
# 참고: Ray Dalio의 All Weather 전략 변형
portfolio:
  name: '올웨더형'
  core_weight: 0.85
  satellite_weight: 0.15

  core:
    - ticker: 'TIGER 미국S&P500'
      weight: 0.25
      role: '경제 성장기 수익'
    - ticker: 'TIGER 미국채10년선물'
      weight: 0.25
      role: '경기 침체 방어'
    - ticker: 'KODEX 미국채울트라30년선물(H)'
      weight: 0.15
      role: '디플레이션 방어'
    - ticker: 'KODEX 종합채권(AA-이상)액티브'
      weight: 0.10
      role: '안정적 이자'
    - ticker: 'TIGER 금은선물(H)'
      weight: 0.10
      role: '인플레이션 헤지'

  satellite:
    - ticker: 'KODEX 200'
      weight: 0.10
      role: '한국 시장 노출'
    - ticker: 'TIGER 원유선물Enhanced(H)'
      weight: 0.05
      role: '원자재 인플레이션 대응'

  expected:
    annual_return: '5-7%'
    max_drawdown: '-10%'
    total_expense_ratio: '0.09%'

"""
코어-새틀라이트 분리 리밸런싱 엔진
- 코어: 연 2회 + 편차 5% 초과 시 긴급
- 새틀라이트: 분기 1회 + 편차 7% 초과 시 긴급
"""
from dataclasses import dataclass


@dataclass
class RebalanceRule:
    """자산 유형별 리밸런싱 규칙."""
    section: str            # "core" or "satellite"
    scheduled_frequency: str  # "semi-annual" or "quarterly"
    drift_threshold: float    # 편차 임계치
    min_trade_krw: int        # 최소 거래 금액


RULES = {
    "core": RebalanceRule(
        section="core",
        scheduled_frequency="semi-annual",
        drift_threshold=0.05,
        min_trade_krw=200_000,
    ),
    "satellite": RebalanceRule(
        section="satellite",
        scheduled_frequency="quarterly",
        drift_threshold=0.07,
        min_trade_krw=100_000,
    ),
}


def check_section(
    section: str,
    holdings: dict,
    targets: list[dict],
    total_value: int,
) -> dict:
    """특정 섹션의 리밸런싱 필요 여부를 판단한다."""
    rule = RULES[section]
    drift_alerts = []

    for target in targets:
        code = target["code"]
        current_value = holdings.get(code, {}).get("value_krw", 0)
        current_weight = current_value / total_value if total_value > 0 else 0
        target_weight = target["weight"]
        drift = abs(current_weight - target_weight)

        if drift > rule.drift_threshold:
            drift_alerts.append({
                "ticker": target["ticker"],
                "code": code,
                "target": target_weight,
                "current": round(current_weight, 4),
                "drift": round(drift, 4),
                "action_needed": True,
            })

    return {
        "section": section,
        "rule": rule,
        "needs_rebalancing": len(drift_alerts) > 0,
        "alerts": drift_alerts,
    }


def run_core_satellite_rebalance(portfolio_config: dict, holdings: dict):
    """코어와 새틀라이트를 분리하여 각각 리밸런싱을 실행한다."""
    total_value = sum(h["value_krw"] for h in holdings.values())

    print(f"총 자산: ₩{total_value:,}\n")

    for section in ["core", "satellite"]:
        targets = portfolio_config[section]
        result = check_section(section, holdings, targets, total_value)

        section_label = "코어" if section == "core" else "새틀라이트"
        print(f"=== {section_label} 점검 ===")
        print(f"리밸런싱 주기: {result['rule'].scheduled_frequency}")
        print(f"편차 임계치: ±{result['rule'].drift_threshold * 100}%")

        if result["needs_rebalancing"]:
            print(f"상태: 리밸런싱 필요")
            for alert in result["alerts"]:
                print(
                    f"  - {alert['ticker']}: "
                    f"목표 {alert['target']*100:.1f}% / "
                    f"현재 {alert['current']*100:.1f}% / "
                    f"편차 {alert['drift']*100:.1f}%p"
                )
        else:
            print("상태: 정상 범위 내")
        print()


# 사용 예시
config = {
    "core": [
        {"ticker": "TIGER 미국S&P500", "code": "360750", "weight": 0.35},
        {"ticker": "KODEX 200", "code": "069500", "weight": 0.15},
        {"ticker": "TIGER 미국채10년선물", "code": "305080", "weight": 0.15},
    ],
    "satellite": [
        {"ticker": "TIGER 반도체", "code": "091230", "weight": 0.12},
        {"ticker": "KODEX 2차전지산업", "code": "305720", "weight": 0.08},
        {"ticker": "TIGER 인도니프티50", "code": "453810", "weight": 0.07},
    ],
}

holdings = {
    "360750": {"value_krw": 4_500_000},
    "069500": {"value_krw": 1_500_000},
    "305080": {"value_krw": 1_200_000},
    "091230": {"value_krw": 1_800_000},
    "305720": {"value_krw": 600_000},
    "453810": {"value_krw": 400_000},
}

run_core_satellite_rebalance(config, holdings)

"""새틀라이트 ETF 성과 검토 및 교체 판단."""

def evaluate_satellite(
    ticker: str,
    quarter_return: float,
    benchmark_return: float,
    thesis_valid: bool,
    cheaper_alternative: str | None = None,
) -> dict:
    """새틀라이트 ETF의 교체 필요 여부를 판단한다."""
    excess_return = quarter_return - benchmark_return

    recommendation = "HOLD"
    reasons = []

    # 투자 논리가 무효화된 경우
    if not thesis_valid:
        recommendation = "REPLACE"
        reasons.append("투자 논리(thesis)가 더 이상 유효하지 않음")

    # 3분기 연속 벤치마크 대비 부진한 경우
    if excess_return < -0.05:
        recommendation = "REVIEW"
        reasons.append(
            f"벤치마크 대비 {excess_return*100:.1f}%p 부진"
        )

    # 더 저렴한 대안이 있는 경우
    if cheaper_alternative:
        reasons.append(f"보수가 더 낮은 대안 존재: {cheaper_alternative}")

    return {
        "ticker": ticker,
        "quarter_return": f"{quarter_return*100:.1f}%",
        "excess_return": f"{excess_return*100:.1f}%p",
        "recommendation": recommendation,
        "reasons": reasons,
    }


# 분기 검토 예시
reviews = [
    evaluate_satellite(
        ticker="TIGER 반도체",
        quarter_return=0.12,
        benchmark_return=0.08,
        thesis_valid=True,
    ),
    evaluate_satellite(
        ticker="KODEX 2차전지산업",
        quarter_return=-0.03,
        benchmark_return=0.08,
        thesis_valid=True,
    ),
    evaluate_satellite(
        ticker="TIGER 인도니프티50",
        quarter_return=0.06,
        benchmark_return=0.08,
        thesis_valid=True,
        cheaper_alternative="KODEX 인도Nifty50(합성)",
    ),
]

print("=== 새틀라이트 분기 검토 ===")
for r in reviews:
    print(f"\n{r['ticker']}")
    print(f"  분기 수익률: {r['quarter_return']}")
    print(f"  초과 수익: {r['excess_return']}")
    print(f"  판정: {r['recommendation']}")
    if r["reasons"]:
        for reason in r["reasons"]:
            print(f"  - {reason}")

"""포트폴리오 내 ETF 상관관계를 계산한다."""
import numpy as np


def check_correlation(returns_matrix: dict, threshold: float = 0.8) -> list:
    """높은 상관관계를 가진 ETF 쌍을 찾는다.

    Args:
        returns_matrix: {종목코드: [일별 수익률 리스트]}
        threshold: 경고 기준 상관계수

    Returns:
        상관계수가 threshold를 넘는 ETF 쌍 목록
    """
    tickers = list(returns_matrix.keys())
    data = np.array([returns_matrix[t] for t in tickers])
    corr = np.corrcoef(data)

    high_corr_pairs = []
    for i in range(len(tickers)):
        for j in range(i + 1, len(tickers)):
            if abs(corr[i][j]) > threshold:
                high_corr_pairs.append({
                    "pair": (tickers[i], tickers[j]),
                    "correlation": round(corr[i][j], 3),
                    "warning": "분산 효과 약화 - 한쪽 비중 축소 검토",
                })

    return high_corr_pairs


# 예시: 60일 일별 수익률 (시뮬레이션)
np.random.seed(42)
market = np.random.normal(0.0005, 0.01, 60)

sample_returns = {
    "S&P500": market + np.random.normal(0, 0.002, 60),
    "NASDAQ100": market * 1.3 + np.random.normal(0, 0.003, 60),
    "반도체": market * 1.5 + np.random.normal(0, 0.005, 60),
    "미국채10년": -market * 0.3 + np.random.normal(0, 0.003, 60),
    "금": np.random.normal(0.0002, 0.008, 60),
}

alerts = check_correlation(sample_returns, threshold=0.7)

print("=== 상관관계 경고 ===")
for alert in alerts:
    print(f"  {alert['pair'][0]} <-> {alert['pair'][1]}: "
          f"상관계수 {alert['correlation']}")
    print(f"  -> {alert['warning']}")