Stock Analyzer

#!/usr/bin/env python3
"""
Earnings Workflow Analyzer
Usage: analyze-earnings <TICKER> [--company "Company Name"] [--out report.md]
"""

import argparse
import datetime as dt
import json
import re
from pathlib import Path
from typing import Dict, Any, List, Optional

import requests


def _safe_get(d: Dict[str, Any], *keys, default=None):
    cur = d
    for k in keys:
        if not isinstance(cur, dict):
            return default
        cur = cur.get(k)
        if cur is None:
            return default
    return cur


def fetch_yahoo_block(ticker: str) -> Dict[str, Any]:
    try:
        from yahooquery import Ticker
    except ImportError as e:
        raise RuntimeError("yahooquery is required: pip install yahooquery") from e

    t = Ticker(ticker)
    price = t.price.get(ticker, {})
    profile = t.asset_profile.get(ticker, {})
    stats = t.key_stats.get(ticker, {})
    fin = t.financial_data.get(ticker, {})
    cal = t.calendar_events.get(ticker, {})
    trend = t.earnings_trend.get(ticker, {})

    earnings_date = _safe_get(cal, "earnings", "earningsDate", default=[])
    if isinstance(earnings_date, list):
        earnings_date = earnings_date[0] if earnings_date else None

    trend_items = trend.get("trend", []) if isinstance(trend, dict) else []

    return {
        "meta": {
            "company_name": price.get("longName") or price.get("shortName")
        },
        "price": {
            "current": price.get("regularMarketPrice"),
            "previous_close": price.get("regularMarketPreviousClose"),
            "day_high": price.get("regularMarketDayHigh"),
            "day_low": price.get("regularMarketDayLow"),
            "high_52w": price.get("fiftyTwoWeekHigh"),
            "low_52w": price.get("fiftyTwoWeekLow"),
            "market_cap": price.get("marketCap"),
            "currency": price.get("currency") or "USD",
        },
        "valuation": {
            "forward_pe": stats.get("forwardPE"),
            "trailing_pe": stats.get("trailingPE"),
            "price_to_book": stats.get("priceToBook"),
            "peg": stats.get("pegRatio"),
            "beta": stats.get("beta"),
        },
        "financial": {
            "revenue_growth": fin.get("revenueGrowth"),
            "gross_margin": fin.get("grossMargins"),
            "operating_margin": fin.get("operatingMargins"),
            "profit_margin": fin.get("profitMargins"),
            "free_cashflow": fin.get("freeCashflow"),
            "operating_cashflow": fin.get("operatingCashflow"),
            "total_cash": fin.get("totalCash"),
            "total_debt": fin.get("totalDebt"),
            "roe": fin.get("returnOnEquity"),
        },
        "earnings": {
            "earnings_date": earnings_date,
            "trend": trend_items,
        },
    }


def fetch_sec_block(ticker: str) -> Dict[str, Any]:
    headers = {"User-Agent": "openclaw-earnings-workflow/1.0 (contact: local-user)"}

    try:
        m = requests.get("https://www.sec.gov/files/company_tickers.json", headers=headers, timeout=30)
        m.raise_for_status()
        ticker_map = m.json()
    except Exception as e:
        return {"error": f"SEC ticker map fetch failed: {e}"}

    cik = None
    company = None
    for _, row in ticker_map.items():
        if str(row.get("ticker", "")).upper() == ticker.upper():
            cik = int(row["cik_str"])
            company = row.get("title")
            break

    if cik is None:
        return {"error": f"Ticker {ticker} not found in SEC ticker map"}

    cik_padded = str(cik).zfill(10)
    sub_url = f"https://data.sec.gov/submissions/CIK{cik_padded}.json"
    try:
        s = requests.get(sub_url, headers=headers, timeout=30)
        s.raise_for_status()
        sub = s.json()
    except Exception as e:
        return {
            "company": company,
            "cik": cik,
            "submissions_url": sub_url,
            "error": f"SEC submissions fetch failed: {e}",
        }

    recent = sub.get("filings", {}).get("recent", {})
    forms = recent.get("form", [])
    acc = recent.get("accessionNumber", [])
    filing_dates = recent.get("filingDate", [])
    report_dates = recent.get("reportDate", [])
    primary_docs = recent.get("primaryDocument", [])
    descriptions = recent.get("primaryDocDescription", [])

    wanted = {"8-K", "10-Q", "10-K", "6-K", "20-F"}
    rows: List[Dict[str, Any]] = []
    for i, f in enumerate(forms):
        if f not in wanted:
            continue
        accession = acc[i]
        accession_nodash = accession.replace("-", "")
        primary = primary_docs[i]
        filing_date = filing_dates[i]
        report_date = report_dates[i] if i < len(report_dates) else None
        desc = descriptions[i] if i < len(descriptions) else ""

        filing_link = f"https://www.sec.gov/ixviewer/ix.html?doc=/Archives/edgar/data/{cik}/{accession_nodash}/{primary}"
        archive_link = f"https://www.sec.gov/Archives/edgar/data/{cik}/{accession_nodash}/{primary}"

        rows.append(
            {
                "form": f,
                "filing_date": filing_date,
                "report_date": report_date,
                "description": desc,
                "filing_link": filing_link,
                "archive_link": archive_link,
            }
        )

    rows.sort(key=lambda x: x.get("filing_date") or "", reverse=True)

    return {
        "company": company,
        "cik": cik,
        "submissions_url": sub_url,
        "filings": rows[:15],
    }


def _fmt_num(v: Optional[float], pct=False, bn=False) -> str:
    if v is None:
        return "N/A"
    if pct:
        return f"{v * 100:.1f}%"
    if bn:
        return f"${v / 1e9:.2f}B"
    if isinstance(v, (int, float)):
        return f"{v:.2f}" if abs(v) < 1000 else f"{v:,.0f}"
    return str(v)


def _ir_candidates(ticker: str, company_name: Optional[str]) -> List[str]:
    base = (company_name or ticker).lower()
    base = re.sub(r"[^a-z0-9]+", "-", base).strip("-")
    return [
        f"https://investor.{base}.com",
        f"https://ir.{base}.com",
        f"https://www.{base}.com/investors",
        f"https://www.{base}.com/investor-relations",
    ]


def build_report(ticker: str, company_name: Optional[str], yb: Dict[str, Any], sec: Dict[str, Any]) -> str:
    now = dt.datetime.now().strftime("%Y-%m-%d %H:%M")
    resolved_name = company_name or _safe_get(yb, "meta", "company_name") or sec.get("company") or ticker

    lines = []
    lines.append(f"# {resolved_name} ({ticker.upper()}) Earnings Analysis Workflow Report")
    lines.append("")
    lines.append(f"Generated: {now}")
    lines.append("")

    lines.append("## 1) Market Snapshot")
    p = yb.get("price", {})
    v = yb.get("valuation", {})
    lines += [
        f"- Price: {_fmt_num(p.get('current'))} {p.get('currency', 'USD')}",
        f"- Previous Close: {_fmt_num(p.get('previous_close'))}",
        f"- Day Range: {_fmt_num(p.get('day_low'))} - {_fmt_num(p.get('day_high'))}",
        f"- 52W Range: {_fmt_num(p.get('low_52w'))} - {_fmt_num(p.get('high_52w'))}",
        f"- Market Cap: {_fmt_num(p.get('market_cap'), bn=True)}",
        f"- Forward P/E: {_fmt_num(v.get('forward_pe'))}",
        f"- Trailing P/E: {_fmt_num(v.get('trailing_pe'))}",
        f"- PEG: {_fmt_num(v.get('peg'))}",
        f"- Beta: {_fmt_num(v.get('beta'))}",
    ]
    lines.append("")

    lines.append("## 2) Latest Earnings Timing & Street Expectations")
    e = yb.get("earnings", {})
    lines.append(f"- Latest/Next Earnings Date (Yahoo feed): {e.get('earnings_date') or 'N/A'}")
    trend = e.get("trend", [])
    for t in trend[:3]:
        period = t.get("period")
        ee = t.get("earningsEstimate", {})
        re = t.get("revenueEstimate", {})
        lines.append(
            f"- {period}: EPS est avg {ee.get('avg', 'N/A')} | Revenue est avg {_fmt_num(re.get('avg'))}"
        )
    lines.append("")

    lines.append("## 3) Official Filings (Primary Source)")
    if sec.get("error"):
        lines.append(f"- SEC lookup error: {sec['error']}")
    else:
        lines.append(f"- SEC Submissions API: {sec.get('submissions_url')}")
        for r in sec.get("filings", [])[:10]:
            lines.append(
                f"- {r['filing_date']} | {r['form']} | {r.get('description') or 'N/A'} | report date: {r.get('report_date') or 'N/A'}"
            )
            lines.append(f"  - ixviewer: {r['filing_link']}")
            lines.append(f"  - archive: {r['archive_link']}")
    lines.append("")

    lines.append("## 4) Investor Relations Source Discovery (Manual Verification)")
    lines.append("Use browser to verify the latest shareholder letter / earnings release / webcast deck:")
    for u in _ir_candidates(ticker, resolved_name):
        lines.append(f"- {u}")
    lines.append("")

    lines.append("## 5) Financial Quality Quick Checks")
    f = yb.get("financial", {})
    lines += [
        f"- Revenue Growth: {_fmt_num(f.get('revenue_growth'), pct=True)}",
        f"- Gross Margin: {_fmt_num(f.get('gross_margin'), pct=True)}",
        f"- Operating Margin: {_fmt_num(f.get('operating_margin'), pct=True)}",
        f"- Profit Margin: {_fmt_num(f.get('profit_margin'), pct=True)}",
        f"- ROE: {_fmt_num(f.get('roe'), pct=True)}",
        f"- Operating Cash Flow: {_fmt_num(f.get('operating_cashflow'), bn=True)}",
        f"- Free Cash Flow: {_fmt_num(f.get('free_cashflow'), bn=True)}",
        f"- Total Cash: {_fmt_num(f.get('total_cash'), bn=True)}",
        f"- Total Debt: {_fmt_num(f.get('total_debt'), bn=True)}",
    ]
    lines.append("")

    lines.append("## 6) Standardized Earnings Interpretation Checklist")
    lines.append("- [ ] Revenue vs consensus (beat/miss, quality of growth)")
    lines.append("- [ ] EPS vs consensus (GAAP / non-GAAP split)")
    lines.append("- [ ] Gross / Operating margin trend and drivers")
    lines.append("- [ ] FCF / OCF quality (one-off adjustments?)")
    lines.append("- [ ] Guidance (next quarter + full year) and confidence")
    lines.append("- [ ] Capital allocation (buyback, debt, M&A, dilution)")
    lines.append("- [ ] Management commentary & risk flags")
    lines.append("- [ ] Valuation reset after earnings (P/E, PEG, DCF impact)")
    lines.append("")

    lines.append("## 7) Final Output Template")
    lines.append("- Investment Rating: BUY / HOLD / AVOID + stars")
    lines.append("- Left-side entry plan: 4 tranches with price zones")
    lines.append("- Options plan: Sell Put / Vertical / Covered Call")
    lines.append("- 3-year target range + key assumptions")
    lines.append("- Risks that can invalidate thesis")
    lines.append("")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Run a reusable earnings-analysis workflow for any listed company")
    parser.add_argument("ticker", help="Ticker, e.g. COIN, AAPL, MSFT")
    parser.add_argument("--company", help="Optional company name override", default=None)
    parser.add_argument("--out", help="Output markdown path", default=None)
    parser.add_argument("--json", help="Also dump raw json next to report", action="store_true")
    args = parser.parse_args()

    ticker = args.ticker.upper().strip()
    yahoo_block = fetch_yahoo_block(ticker)
    sec_block = fetch_sec_block(ticker)

    report = build_report(ticker, args.company, yahoo_block, sec_block)

    if args.out:
        out_path = Path(args.out).expanduser().resolve()
    else:
        out_path = Path.cwd() / f"{ticker.lower()}-earnings-workflow.md"

    out_path.write_text(report, encoding="utf-8")
    print(f"✅ Report generated: {out_path}")

    if args.json:
        raw = {
            "ticker": ticker,
            "yahoo": yahoo_block,
            "sec": sec_block,
        }
        json_path = out_path.with_suffix(".json")
        json_path.write_text(json.dumps(raw, ensure_ascii=False, indent=2), encoding="utf-8")
        print(f"✅ Raw JSON generated: {json_path}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Stock Analyzer - 自动化股票五维投资价值分析
Usage: analyze-stock <TICKER> [options]
"""

import sys
import json
from datetime import datetime
from typing import Dict, Optional


def summarize_short_term_options(option_chain, current_price: float) -> Dict:
    """汇总近端到期（最短期限）期权成交量与隐含波动率"""
    try:
        if option_chain is None or getattr(option_chain, 'empty', True):
            return {"available": False}

        df = option_chain.reset_index().copy()
        if df.empty or 'expiration' not in df.columns:
            return {"available": False}

        # 选最近到期
        exp_dates = sorted(df['expiration'].dropna().unique())
        if not exp_dates:
            return {"available": False}
        nearest_exp = exp_dates[0]
        near_df = df[df['expiration'] == nearest_exp].copy()

        if near_df.empty:
            return {"available": False}

        near_df['volume'] = near_df['volume'].fillna(0)
        near_df['openInterest'] = near_df['openInterest'].fillna(0)
        near_df['impliedVolatility'] = near_df['impliedVolatility'].fillna(0)

        calls = near_df[near_df['optionType'] == 'calls']
        puts = near_df[near_df['optionType'] == 'puts']

        call_vol = float(calls['volume'].sum()) if not calls.empty else 0.0
        put_vol = float(puts['volume'].sum()) if not puts.empty else 0.0
        call_oi = float(calls['openInterest'].sum()) if not calls.empty else 0.0
        put_oi = float(puts['openInterest'].sum()) if not puts.empty else 0.0

        # ATM附近IV（距离现价最近的5个合约）
        near_df['moneyness_dist'] = (near_df['strike'] - current_price).abs()
        atm = near_df.nsmallest(5, 'moneyness_dist')
        atm_iv = float(atm['impliedVolatility'].mean()) if not atm.empty else 0.0

        # 成交量最大合约
        top = near_df.sort_values('volume', ascending=False).head(3)
        top_contracts = []
        for _, r in top.iterrows():
            top_contracts.append({
                'contract': r.get('contractSymbol'),
                'type': r.get('optionType'),
                'strike': float(r.get('strike', 0) or 0),
                'volume': int(r.get('volume', 0) or 0),
                'iv': float(r.get('impliedVolatility', 0) or 0),
            })

        return {
            'available': True,
            'nearest_expiration': str(nearest_exp),
            'call_volume': int(call_vol),
            'put_volume': int(put_vol),
            'put_call_volume_ratio': round((put_vol / call_vol), 2) if call_vol > 0 else None,
            'call_open_interest': int(call_oi),
            'put_open_interest': int(put_oi),
            'put_call_oi_ratio': round((put_oi / call_oi), 2) if call_oi > 0 else None,
            'atm_iv': round(atm_iv, 4),
            'top_contracts': top_contracts,
        }
    except Exception:
        return {"available": False}

def analyze_stock(ticker: str, save: bool = False, format_type: str = "text") -> Dict:
    """分析股票并返回结果字典"""
    
    try:
        from yahooquery import Ticker
    except ImportError:
        print("Error: yahooquery not installed. Run: pip install yahooquery")
        sys.exit(1)
    
    print(f"🔍 正在分析 {ticker}...")
    
    # 获取数据
    stock = Ticker(ticker)
    
    price_data = stock.price.get(ticker, {})
    stats_data = stock.key_stats.get(ticker, {})
    financial = stock.financial_data.get(ticker, {})
    profile = stock.asset_profile.get(ticker, {})
    cashflow = stock.cash_flow(frequency='a')
    earnings_trend = stock.earnings_trend
    recommendations = stock.recommendation_trend
    option_chain = stock.option_chain
    
    # 基础数据
    current_price = price_data.get('regularMarketPrice', 0)
    market_cap = price_data.get('marketCap', 0)
    shares = stats_data.get('sharesOutstanding', 0)
    
    high_52w = price_data.get('fiftyTwoWeekHigh', current_price * 1.2)
    low_52w = price_data.get('fiftyTwoWeekLow', current_price * 0.8)

    # 短期期权情绪与波动
    options_summary = summarize_short_term_options(option_chain, current_price)
    
    # 估值指标
    forward_pe = stats_data.get('forwardPE', 0)
    trailing_pe = stats_data.get('trailingPE', 0)
    pb = stats_data.get('priceToBook', 0)
    ev_ebitda = stats_data.get('enterpriseToEbitda', 0)
    
    # 盈利能力
    gross_margin = financial.get('grossMargins', 0)
    operating_margin = financial.get('operatingMargins', 0)
    net_margin = financial.get('profitMargins', 0)
    roe = financial.get('returnOnEquity', 0)
    roa = financial.get('returnOnAssets', 0)
    
    # FCF
    fcf = 0
    if cashflow is not None and not cashflow.empty:
        for col in cashflow.columns:
            fcf_val = cashflow.loc['FreeCashFlow', col] if 'FreeCashFlow' in cashflow.index else None
            if fcf_val and fcf_val == fcf_val:  # not NaN
                fcf = fcf_val
                break
    
    fcf_per_share = fcf / shares if shares else 0
    p_fcf = current_price / fcf_per_share if fcf_per_share else 0
    
    # 盈利预测
    eps_growth = 0
    revenue_growth = 0
    if earnings_trend:
        trend_data = earnings_trend.get(ticker, {}).get('trend', [])
        for item in trend_data:
            if item.get('period') == '0y':
                eps_growth = item.get('growth', 0)
                revenue_growth = item.get('revenueEstimate', {}).get('growth', 0)
                break
    
    # PEG
    peg = forward_pe / (eps_growth * 100) if eps_growth else 0
    
    # 分析师评级
    target_mean = financial.get('targetMeanPrice', 0)
    target_high = financial.get('targetHighPrice', 0)
    target_low = financial.get('targetLowPrice', 0)
    
    # 52周位置
    position_pct = ((current_price - low_52w) / (high_52w - low_52w) * 100) if high_52w != low_52w else 0
    drop_from_high = ((high_52w - current_price) / high_52w * 100) if high_52w else 0
    
    # DCF 简化计算
    fcf_current = fcf if fcf else market_cap * 0.02  # 估算
    wacc = 0.09
    growth_5y = 0.15
    growth_terminal = 0.025
    
    # 简化DCF: 5年增长 + 终值
    pv_5y = 0
    fcf_proj = fcf_current
    for year in range(1, 6):
        fcf_proj *= (1 + growth_5y)
        pv_5y += fcf_proj / ((1 + wacc) ** year)
    
    terminal_fcf = fcf_proj * (1 + growth_terminal)
    terminal_value = terminal_fcf / (wacc - growth_terminal)
    pv_terminal = terminal_value / ((1 + wacc) ** 5)
    
    intrinsic_value = (pv_5y + pv_terminal) / shares if shares else 0
    upside = ((intrinsic_value - current_price) / current_price * 100) if current_price else 0
    
    # 五维评分
    score_valuation = 4 if position_pct < 50 else 3  # 估值位置
    score_fundamental = 5 if roe > 0.2 else 4 if roe > 0.15 else 3  # 基本面
    score_fcf = 4 if fcf > 0 else 3  # FCF
    score_peg = 5 if peg < 1 else 4 if peg < 1.5 else 3  # PEG
    score_dcf = 4 if upside > 15 else 3 if upside > 0 else 2  # DCF
    
    total_score = (score_valuation + score_fundamental + score_fcf + score_peg + score_dcf) / 5
    
    # 投资评级
    if total_score >= 4.5:
        rating = "STRONG BUY ⭐⭐⭐⭐⭐"
    elif total_score >= 4:
        rating = "BUY ⭐⭐⭐⭐"
    elif total_score >= 3:
        rating = "HOLD ⭐⭐⭐"
    else:
        rating = "SELL ⭐⭐"
    
    # 构建结果
    result = {
        "ticker": ticker,
        "name": profile.get('shortName', ticker),
        "date": datetime.now().strftime("%Y-%m-%d"),
        
        "price": {
            "current": round(current_price, 2),
            "market_cap_b": round(market_cap / 1e9, 2),
            "week_52_high": high_52w,
            "week_52_low": low_52w,
            "position_pct": round(position_pct, 1),
            "drop_from_high": round(drop_from_high, 1),
        },
        
        "valuation": {
            "forward_pe": round(forward_pe, 1),
            "trailing_pe": round(trailing_pe, 1) if trailing_pe else None,
            "pb": round(pb, 2),
            "ev_ebitda": round(ev_ebitda, 1),
            "peg": round(peg, 2),
        },
        
        "profitability": {
            "gross_margin": round(gross_margin * 100, 1) if gross_margin else None,
            "operating_margin": round(operating_margin * 100, 1) if operating_margin else None,
            "net_margin": round(net_margin * 100, 1) if net_margin else None,
            "roe": round(roe * 100, 1) if roe else None,
            "roa": round(roa * 100, 1) if roa else None,
        },
        
        "cashflow": {
            "fcf_b": round(fcf / 1e9, 2) if fcf else None,
            "fcf_per_share": round(fcf_per_share, 2),
            "p_fcf": round(p_fcf, 1),
        },
        
        "growth": {
            "eps_growth": round(eps_growth * 100, 1),
            "revenue_growth": round(revenue_growth * 100, 1),
        },
        
        "analyst": {
            "target_mean": round(target_mean, 2),
            "target_high": round(target_high, 2),
            "target_low": round(target_low, 2),
            "upside": round((target_mean - current_price) / current_price * 100, 1) if target_mean else None,
        },

        "options": options_summary,
        
        "dcf": {
            "intrinsic_value": round(intrinsic_value, 2),
            "upside": round(upside, 1),
        },
        
        "scores": {
            "valuation": score_valuation,
            "fundamental": score_fundamental,
            "fcf": score_fcf,
            "peg": score_peg,
            "dcf": score_dcf,
            "total": round(total_score, 1),
        },
        
        "rating": rating,
        "sector": profile.get('sector', 'N/A'),
        "industry": profile.get('industry', 'N/A'),
    }
    
    return result


def print_report(data: Dict):
    """打印文本格式报告"""
    print("\n" + "=" * 70)
    print(f"📊 {data['name']} ({data['ticker']}) 投资分析报告")
    print("=" * 70)
    
    # 核心数据
    print("\n【核心数据】")
    print(f"• 股价: ${data['price']['current']}")
    print(f"• 市值: ${data['price']['market_cap_b']:.1f}B")
    print(f"• 52周位置: {data['price']['position_pct']}% (距高点 -{data['price']['drop_from_high']}%)")
    print(f"• Forward P/E: {data['valuation']['forward_pe']}x")
    print(f"• PEG: {data['valuation']['peg']}")
    
    if data['analyst']['target_mean']:
        print(f"• 分析师目标价: ${data['analyst']['target_mean']} ({data['analyst']['upside']:+.1f}%)")

    # 短期期权与IV
    if data.get('options', {}).get('available'):
        o = data['options']
        print(f"\n【短期期权与隐含波动率】(最近到期: {o.get('nearest_expiration')})")
        print(f"• Call成交量: {o.get('call_volume')} | Put成交量: {o.get('put_volume')} | P/C成交量比: {o.get('put_call_volume_ratio')}")
        print(f"• Call持仓量: {o.get('call_open_interest')} | Put持仓量: {o.get('put_open_interest')} | P/C持仓比: {o.get('put_call_oi_ratio')}")
        print(f"• ATM附近平均IV: {round(o.get('atm_iv', 0) * 100, 2)}%")
    
    # 五维评分
    print("\n【五维评分】")
    print(f"1. 投资点位: {'⭐' * data['scores']['valuation']}")
    print(f"2. 基本面/护城河: {'⭐' * data['scores']['fundamental']}")
    print(f"3. FCF: {'⭐' * data['scores']['fcf']}")
    print(f"4. PEG: {'⭐' * data['scores']['peg']}")
    print(f"5. DCF: {'⭐' * data['scores']['dcf']}")
    
    # 投资评级
    print("\n【投资评级】")
    print(f"🎯 {data['rating']}")
    print(f"📈 DCF内在价值: ${data['dcf']['intrinsic_value']} (Upside: {data['dcf']['upside']:+.1f}%)")
    
    # 入场策略
    print("\n【左侧交易建议】")
    current = data['price']['current']
    low = data['price']['week_52_low']
    
    if data['price']['position_pct'] < 30:
        print(f"✅ 当前处于低位区域，建议建仓")
    elif data['price']['position_pct'] < 60:
        print(f"⏸️ 当前处于合理区间，可分批建仓")
    else:
        print(f"⚠️ 当前处于高位区域，建议等待回调")
    
    print(f"• 第一批: ${current*0.95:.0f}-${current*1.02:.0f} (试仓20%)")
    print(f"• 第二批: ${current*0.85:.0f}-${current*0.95:.0f} (加仓30%)")
    print(f"• 重仓区: ${low:.0f}-${low*1.1:.0f} (重仓35%)")
    
    print("\n" + "=" * 70)


def save_report(data: Dict, filename: str = None):
    """保存为Markdown报告"""
    if not filename:
        filename = f"./{data['ticker']}-analysis-{data['date']}.md"
    
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(f"# {data['name']} ({data['ticker']}) 投资分析报告\n\n")
        f.write(f"**分析日期**: {data['date']}\n\n")
        
        f.write("## 核心数据\n\n")
        f.write(f"- **股价**: ${data['price']['current']}\n")
        f.write(f"- **市值**: ${data['price']['market_cap_b']:.1f}B\n")
        f.write(f"- **行业**: {data['industry']}\n")
        f.write(f"- **Forward P/E**: {data['valuation']['forward_pe']}x\n")
        f.write(f"- **ROE**: {data['profitability']['roe']}%\n")
        if data.get('options', {}).get('available'):
            f.write(f"- **短期期权P/C成交量比**: {data['options'].get('put_call_volume_ratio')}\n")
            f.write(f"- **短期期权ATM IV**: {round(data['options'].get('atm_iv', 0) * 100, 2)}%\n")
        f.write("\n")
        
        f.write("## 五维评分\n\n")
        f.write(f"| 维度 | 评分 |\n")
        f.write(f"|------|------|\n")
        f.write(f"| 投资点位 | {'⭐' * data['scores']['valuation']} |\n")
        f.write(f"| 基本面/护城河 | {'⭐' * data['scores']['fundamental']} |\n")
        f.write(f"| FCF | {'⭐' * data['scores']['fcf']} |\n")
        f.write(f"| PEG | {'⭐' * data['scores']['peg']} |\n")
        f.write(f"| DCF | {'⭐' * data['scores']['dcf']} |\n")
        f.write(f"| **综合** | **{data['scores']['total']}** |\n\n")
        
        f.write(f"## 投资评级\n\n")
        f.write(f"**{data['rating']}**\n\n")
        f.write(f"- DCF内在价值: ${data['dcf']['intrinsic_value']} ({data['dcf']['upside']:+.1f}%)\n")
        if data['analyst']['target_mean']:
            f.write(f"- 分析师目标价: ${data['analyst']['target_mean']} ({data['analyst']['upside']:+.1f}%)\n")
    
    print(f"\n💾 报告已保存: {filename}")


def main():
    if len(sys.argv) < 2:
        print("Usage: analyze-stock <TICKER> [options]")
        print("Options:")
        print("  --save       Save report to file")
        print("  --format md  Output as markdown")
        print("  --format json Output as JSON")
        print("\nExamples:")
        print("  analyze-stock AAPL")
        print("  analyze-stock 1810.HK --save")
        print("  analyze-stock AMZN --format json")
        sys.exit(1)
    
    ticker = sys.argv[1].upper()
    save = '--save' in sys.argv
    format_md = '--format md' in sys.argv or '-f md' in sys.argv
    format_json = '--format json' in sys.argv or '-f json' in sys.argv
    
    try:
        result = analyze_stock(ticker, save=save)
        
        if format_json:
            print(json.dumps(result, indent=2, ensure_ascii=False))
        elif format_md:
            save_report(result, f"{ticker}-analysis.md")
        else:
            print_report(result)
            if save:
                save_report(result)
    
    except Exception as e:
        print(f"Error analyzing {ticker}: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()