#!/usr/bin/env python3
"""
stocks_client.py - Stock market data CLI tool for the Hermes Agent project.
Zero external dependencies - Python stdlib only.
"""

import argparse
import json
import os
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from datetime import datetime, timezone
from http.cookiejar import CookieJar

# ---------------------------------------------------------------------------
# Constants
# ---------------------------------------------------------------------------

USER_AGENT = "Mozilla/5.0 (compatible; HermesAgent/1.0)"
YF_BASE = "https://query1.finance.yahoo.com"
YF_BASE2 = "https://query2.finance.yahoo.com"
AV_BASE = "https://www.alphavantage.co/query"

MAX_RETRIES = 3
BACKOFF_BASE = 1.5  # seconds

# Global cookie jar + opener (handles Yahoo Finance session cookies)
_cookie_jar = CookieJar()
_opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(_cookie_jar))
_crumb: str | None = None

# ---------------------------------------------------------------------------
# Utilities
# ---------------------------------------------------------------------------


def print_json(data: dict | list) -> None:
    print(json.dumps(data, indent=2, ensure_ascii=False))


def fmt_price(value) -> str | None:
    if value is None:
        return None
    try:
        return f"{float(value):.2f}"
    except (TypeError, ValueError):
        return None


def fmt_large(value) -> str | None:
    """Format large numbers with B/T suffix."""
    if value is None:
        return None
    try:
        v = float(value)
    except (TypeError, ValueError):
        return None
    if abs(v) >= 1e12:
        return f"{v / 1e12:.2f}T"
    if abs(v) >= 1e9:
        return f"{v / 1e9:.2f}B"
    if abs(v) >= 1e6:
        return f"{v / 1e6:.2f}M"
    return str(int(v))


def fmt_pct(value) -> str | None:
    if value is None:
        return None
    try:
        return f"{float(value):.2f}%"
    except (TypeError, ValueError):
        return None


def safe_get(d: dict, *keys, default=None):
    """Safely traverse nested dict."""
    cur = d
    for k in keys:
        if not isinstance(cur, dict):
            return default
        cur = cur.get(k, default)
        if cur is None:
            return default
    return cur


def ts_to_date(ts) -> str | None:
    """Convert Unix timestamp to ISO date string."""
    if ts is None:
        return None
    try:
        return datetime.fromtimestamp(int(ts), tz=timezone.utc).strftime("%Y-%m-%d")
    except (OSError, ValueError, TypeError):
        return None


# ---------------------------------------------------------------------------
# HTTP layer with retry + exponential backoff
# ---------------------------------------------------------------------------


def _build_request(url: str, headers: dict | None = None) -> urllib.request.Request:
    req = urllib.request.Request(url)
    req.add_header("User-Agent", USER_AGENT)
    req.add_header("Accept", "application/json, */*")
    req.add_header("Accept-Language", "en-US,en;q=0.9")
    if headers:
        for k, v in headers.items():
            req.add_header(k, v)
    return req


def fetch_url(url: str, headers: dict | None = None, retries: int = MAX_RETRIES) -> dict | list | None:
    """Fetch a URL, parse JSON, retry on transient errors."""
    last_err = None
    for attempt in range(retries):
        try:
            req = _build_request(url, headers)
            with _opener.open(req, timeout=15) as resp:
                raw = resp.read()
                return json.loads(raw.decode("utf-8", errors="replace"))
        except urllib.error.HTTPError as e:
            last_err = e
            if e.code in (404, 400):
                break  # no point retrying
            wait = BACKOFF_BASE ** attempt
            time.sleep(wait)
        except urllib.error.URLError as e:
            last_err = e
            wait = BACKOFF_BASE ** attempt
            time.sleep(wait)
        except json.JSONDecodeError as e:
            last_err = e
            break
    return None


# ---------------------------------------------------------------------------
# Yahoo Finance crumb / cookie management
# ---------------------------------------------------------------------------


def _fetch_crumb() -> str | None:
    """
    Yahoo Finance v8 requires a crumb + consent cookie.
    We hit the consent page once to grab cookies, then fetch the crumb.
    """
    global _crumb
    if _crumb is not None:
        return _crumb

    # Step 1: touch Yahoo Finance to get cookies
    try:
        req = _build_request("https://finance.yahoo.com/")
        with _opener.open(req, timeout=10) as resp:
            resp.read()
    except Exception:
        pass

    # Step 2: fetch crumb
    crumb_url = f"{YF_BASE}/v1/test/getcrumb"
    try:
        req = _build_request(crumb_url)
        with _opener.open(req, timeout=10) as resp:
            crumb_raw = resp.read().decode("utf-8").strip()
            if crumb_raw and crumb_raw != "":
                _crumb = crumb_raw
                return _crumb
    except Exception:
        pass

    return None


def yf_url(path: str, params: dict | None = None) -> str:
    """Build a Yahoo Finance URL, injecting crumb if available."""
    crumb = _fetch_crumb()
    if params is None:
        params = {}
    if crumb:
        params["crumb"] = crumb
    qs = urllib.parse.urlencode(params)
    base = f"{YF_BASE}{path}"
    return f"{base}?{qs}" if qs else base


# ---------------------------------------------------------------------------
# Yahoo Finance API calls
# ---------------------------------------------------------------------------


def yf_chart(symbol: str, interval: str = "1d", range_: str = "1d") -> dict | None:
    params = {"interval": interval, "range": range_}
    crumb = _fetch_crumb()
    if crumb:
        params["crumb"] = crumb
    qs = urllib.parse.urlencode(params)
    url = f"{YF_BASE}/v8/finance/chart/{urllib.parse.quote(symbol)}?{qs}"
    data = fetch_url(url)
    if data is None:
        # fallback to query2
        url2 = f"{YF_BASE2}/v8/finance/chart/{urllib.parse.quote(symbol)}?{qs}"
        data = fetch_url(url2)
    return data


def yf_search(query: str, count: int = 5) -> dict | None:
    params = {"q": query, "quotesCount": count, "newsCount": 0}
    crumb = _fetch_crumb()
    if crumb:
        params["crumb"] = crumb
    qs = urllib.parse.urlencode(params)
    url = f"{YF_BASE}/v1/finance/search?{qs}"
    data = fetch_url(url)
    if data is None:
        url2 = f"{YF_BASE2}/v1/finance/search?{qs}"
        data = fetch_url(url2)
    return data


def yf_quote_summary(symbol: str) -> dict | None:
    """Fetch detailed quote summary (quoteSummary) for PE, market cap, etc."""
    modules = "summaryDetail,defaultKeyStatistics,price"
    params = {"modules": modules}
    crumb = _fetch_crumb()
    if crumb:
        params["crumb"] = crumb
    qs = urllib.parse.urlencode(params)
    url = f"{YF_BASE}/v11/finance/quoteSummary/{urllib.parse.quote(symbol)}?{qs}"
    data = fetch_url(url)
    if data is None:
        url2 = f"{YF_BASE2}/v11/finance/quoteSummary/{urllib.parse.quote(symbol)}?{qs}"
        data = fetch_url(url2)
    return data


# ---------------------------------------------------------------------------
# Alpha Vantage (optional, requires API key)
# ---------------------------------------------------------------------------


def av_overview(symbol: str) -> dict | None:
    key = os.environ.get("ALPHA_VANTAGE_KEY")
    if not key:
        return None
    params = {"function": "OVERVIEW", "symbol": symbol, "apikey": key}
    qs = urllib.parse.urlencode(params)
    url = f"{AV_BASE}?{qs}"
    data = fetch_url(url)
    if isinstance(data, dict) and data.get("Symbol"):
        return data
    return None


# ---------------------------------------------------------------------------
# Data extraction helpers
# ---------------------------------------------------------------------------


def extract_quote_from_chart(symbol: str, chart_data: dict) -> dict:
    """Extract current quote info from v8 chart response."""
    result = {
        "symbol": symbol.upper(),
        "price": None,
        "change": None,
        "change_pct": None,
        "volume": None,
        "market_cap": None,
        "pe_ratio": None,
        "52w_high": None,
        "52w_low": None,
        "currency": None,
        "exchange": None,
        "short_name": None,
    }

    chart = safe_get(chart_data, "chart", "result")
    if not chart or not isinstance(chart, list) or len(chart) == 0:
        return result

    r = chart[0]
    meta = r.get("meta", {})

    result["currency"] = meta.get("currency")
    result["exchange"] = meta.get("exchangeName")
    result["short_name"] = meta.get("shortName") or meta.get("longName")

    # Price
    price = meta.get("regularMarketPrice") or meta.get("chartPreviousClose")
    result["price"] = fmt_price(price)

    # Change
    prev_close = meta.get("previousClose") or meta.get("chartPreviousClose")
    if price and prev_close:
        chg = float(price) - float(prev_close)
        chg_pct = (chg / float(prev_close)) * 100
        result["change"] = fmt_price(chg)
        result["change_pct"] = fmt_pct(chg_pct)

    result["volume"] = meta.get("regularMarketVolume")
    result["52w_high"] = fmt_price(meta.get("fiftyTwoWeekHigh"))
    result["52w_low"] = fmt_price(meta.get("fiftyTwoWeekLow"))

    return result


def extract_quote_summary_fields(qs_data: dict) -> dict:
    """Extract PE, market cap, etc. from quoteSummary response."""
    out = {
        "market_cap": None,
        "pe_ratio": None,
        "52w_high": None,
        "52w_low": None,
        "volume": None,
        "short_name": None,
    }

    result = safe_get(qs_data, "quoteSummary", "result")
    if not result or not isinstance(result, list) or len(result) == 0:
        return out

    r = result[0]

    # price module
    price_mod = r.get("price", {})
    out["market_cap"] = fmt_large(safe_get(price_mod, "marketCap", "raw"))
    out["short_name"] = price_mod.get("shortName") or price_mod.get("longName")

    # summaryDetail
    sd = r.get("summaryDetail", {})
    pe_raw = safe_get(sd, "trailingPE", "raw")
    out["pe_ratio"] = fmt_price(pe_raw) if pe_raw else None
    out["52w_high"] = fmt_price(safe_get(sd, "fiftyTwoWeekHigh", "raw"))
    out["52w_low"] = fmt_price(safe_get(sd, "fiftyTwoWeekLow", "raw"))
    out["volume"] = safe_get(sd, "volume", "raw") or safe_get(sd, "regularMarketVolume", "raw")

    # defaultKeyStatistics
    ks = r.get("defaultKeyStatistics", {})
    if out["pe_ratio"] is None:
        pe_raw = safe_get(ks, "trailingEps", "raw")
        # can't compute PE from EPS alone without price, skip

    return out


# ---------------------------------------------------------------------------
# Command: quote
# ---------------------------------------------------------------------------


def cmd_quote(symbols: list[str]) -> None:
    results = []

    for sym in symbols:
        sym = sym.upper().strip()
        entry = {"symbol": sym, "data_source": "Yahoo Finance"}

        # Fetch chart for price data
        chart_data = yf_chart(sym, interval="1d", range_="1d")
        if chart_data:
            q = extract_quote_from_chart(sym, chart_data)
            entry.update(q)

        # Fetch quoteSummary for enriched data
        qs_data = yf_quote_summary(sym)
        if qs_data:
            qs_fields = extract_quote_summary_fields(qs_data)
            # Prefer quoteSummary values if chart didn't have them
            for field in ("market_cap", "pe_ratio", "52w_high", "52w_low", "volume", "short_name"):
                if entry.get(field) is None and qs_fields.get(field) is not None:
                    entry[field] = qs_fields[field]
                elif field == "market_cap" and qs_fields.get(field) is not None:
                    # Always prefer formatted market cap from quoteSummary
                    entry[field] = qs_fields[field]

        # Optionally enrich with Alpha Vantage
        av_key = os.environ.get("ALPHA_VANTAGE_KEY")
        if av_key:
            av_data = av_overview(sym)
            if av_data:
                entry["data_source"] = "Yahoo Finance + Alpha Vantage"
                if entry.get("pe_ratio") is None:
                    pe = av_data.get("PERatio")
                    entry["pe_ratio"] = pe if pe and pe != "None" and pe != "-" else None
                if entry.get("market_cap") is None:
                    mc = av_data.get("MarketCapitalization")
                    entry["market_cap"] = fmt_large(mc)
                if entry.get("52w_high") is None:
                    entry["52w_high"] = av_data.get("52WeekHigh")
                if entry.get("52w_low") is None:
                    entry["52w_low"] = av_data.get("52WeekLow")

        results.append(entry)

    if len(results) == 1:
        print_json(results[0])
    else:
        print_json(results)


# ---------------------------------------------------------------------------
# Command: search
# ---------------------------------------------------------------------------


def cmd_search(query: str) -> None:
    data = yf_search(query, count=5)
    if not data:
        print_json({"error": "Search failed or no results", "query": query, "data_source": "Yahoo Finance"})
        return

    quotes = data.get("quotes") or []
    if not quotes:
        print_json({"error": "No matches found", "query": query, "data_source": "Yahoo Finance"})
        return

    results = []
    for q in quotes[:5]:
        results.append({
            "symbol": q.get("symbol"),
            "name": q.get("longname") or q.get("shortname"),
            "exchange": q.get("exchange") or q.get("exchDisp"),
            "type": q.get("quoteType"),
            "sector": q.get("sector"),
        })

    output = {
        "query": query,
        "matches": results,
        "data_source": "Yahoo Finance",
    }
    print_json(output)


# ---------------------------------------------------------------------------
# Command: history
# ---------------------------------------------------------------------------


def cmd_history(symbol: str, range_: str = "1mo") -> None:
    valid_ranges = ("1mo", "3mo", "6mo", "1y", "5y")
    if range_ not in valid_ranges:
        print_json({"error": f"Invalid range '{range_}'. Valid: {', '.join(valid_ranges)}"})
        return

    sym = symbol.upper().strip()
    chart_data = yf_chart(sym, interval="1d", range_=range_)

    if not chart_data:
        print_json({"error": f"Failed to fetch history for {sym}", "data_source": "Yahoo Finance"})
        return

    chart = safe_get(chart_data, "chart", "result")
    if not chart or not isinstance(chart, list) or len(chart) == 0:
        err = safe_get(chart_data, "chart", "error", "description") or "Unknown error"
        print_json({"error": err, "symbol": sym, "data_source": "Yahoo Finance"})
        return

    r = chart[0]
    timestamps = r.get("timestamp") or []
    indicators = r.get("indicators", {})
    quote_list = indicators.get("quote") or [{}]
    ohlcv = quote_list[0] if quote_list else {}

    opens = ohlcv.get("open") or []
    closes = ohlcv.get("close") or []
    highs = ohlcv.get("high") or []
    lows = ohlcv.get("low") or []
    volumes = ohlcv.get("volume") or []

    history = []
    for i, ts in enumerate(timestamps):
        def _v(lst, idx):
            try:
                val = lst[idx]
                return round(val, 2) if val is not None else None
            except IndexError:
                return None

        entry = {
            "date": ts_to_date(ts),
            "open": _v(opens, i),
            "close": _v(closes, i),
            "high": _v(highs, i),
            "low": _v(lows, i),
            "volume": _v(volumes, i),
        }
        history.append(entry)

    # Stats
    valid_closes = [c["close"] for c in history if c["close"] is not None]
    stats = {}
    if valid_closes:
        stats["min"] = fmt_price(min(valid_closes))
        stats["max"] = fmt_price(max(valid_closes))
        stats["avg"] = fmt_price(sum(valid_closes) / len(valid_closes))
        if len(valid_closes) >= 2:
            total_return = ((valid_closes[-1] - valid_closes[0]) / valid_closes[0]) * 100
            stats["total_return_pct"] = fmt_pct(total_return)
        else:
            stats["total_return_pct"] = None

    meta = r.get("meta", {})
    output = {
        "symbol": sym,
        "range": range_,
        "currency": meta.get("currency"),
        "exchange": meta.get("exchangeName"),
        "data_points": len(history),
        "stats": stats,
        "history": history,
        "data_source": "Yahoo Finance",
    }
    print_json(output)


# ---------------------------------------------------------------------------
# Command: compare
# ---------------------------------------------------------------------------


def cmd_compare(symbols: list[str]) -> None:
    if len(symbols) < 2:
        print_json({"error": "compare requires at least 2 symbols"})
        return

    comparisons = []

    for sym in symbols:
        sym = sym.upper().strip()
        entry = {
            "symbol": sym,
            "name": None,
            "price": None,
            "change_pct": None,
            "market_cap": None,
            "pe_ratio": None,
            "52w_high": None,
            "52w_low": None,
            "52w_performance_pct": None,
        }

        # Chart data
        chart_data = yf_chart(sym, interval="1d", range_="1d")
        if chart_data:
            q = extract_quote_from_chart(sym, chart_data)
            entry["name"] = q.get("short_name")
            entry["price"] = q.get("price")
            entry["change_pct"] = q.get("change_pct")
            entry["52w_high"] = q.get("52w_high")
            entry["52w_low"] = q.get("52w_low")

        # quoteSummary for enrichment
        qs_data = yf_quote_summary(sym)
        if qs_data:
            qs = extract_quote_summary_fields(qs_data)
            if qs.get("market_cap"):
                entry["market_cap"] = qs["market_cap"]
            if qs.get("pe_ratio"):
                entry["pe_ratio"] = qs["pe_ratio"]
            if entry["52w_high"] is None and qs.get("52w_high"):
                entry["52w_high"] = qs["52w_high"]
            if entry["52w_low"] is None and qs.get("52w_low"):
                entry["52w_low"] = qs["52w_low"]
            if entry["name"] is None and qs.get("short_name"):
                entry["name"] = qs["short_name"]

        # 52w performance: (current - 52w_low) / (52w_high - 52w_low)
        try:
            price_f = float(entry["price"]) if entry["price"] else None
            high_f = float(entry["52w_high"]) if entry["52w_high"] else None
            low_f = float(entry["52w_low"]) if entry["52w_low"] else None
            if price_f and low_f and price_f > 0 and low_f > 0:
                perf = ((price_f - low_f) / low_f) * 100
                entry["52w_performance_pct"] = fmt_pct(perf)
        except (ValueError, TypeError, ZeroDivisionError):
            pass

        comparisons.append(entry)

    output = {
        "comparison": comparisons,
        "symbols": [s.upper() for s in symbols],
        "data_source": "Yahoo Finance",
    }
    print_json(output)


# ---------------------------------------------------------------------------
# Command: crypto
# ---------------------------------------------------------------------------


def cmd_crypto(symbol: str, vs: str = "USD") -> None:
    sym = symbol.upper().strip()
    vs = vs.upper().strip()

    # If user already passed BTC-USD, keep as-is; otherwise append
    if "-" not in sym:
        ticker = f"{sym}-{vs}"
    else:
        ticker = sym

    chart_data = yf_chart(ticker, interval="1d", range_="1d")

    if not chart_data:
        print_json({
            "error": f"Failed to fetch crypto data for {ticker}",
            "symbol": ticker,
            "data_source": "Yahoo Finance",
        })
        return

    chart = safe_get(chart_data, "chart", "result")
    if not chart or not isinstance(chart, list) or len(chart) == 0:
        err = safe_get(chart_data, "chart", "error", "description") or "Symbol not found"
        print_json({"error": err, "symbol": ticker, "data_source": "Yahoo Finance"})
        return

    r = chart[0]
    meta = r.get("meta", {})

    price = meta.get("regularMarketPrice") or meta.get("chartPreviousClose")
    prev_close = meta.get("previousClose") or meta.get("chartPreviousClose")

    change = None
    change_pct = None
    if price and prev_close:
        try:
            chg = float(price) - float(prev_close)
            chg_pct = (chg / float(prev_close)) * 100
            change = fmt_price(chg)
            change_pct = fmt_pct(chg_pct)
        except (TypeError, ValueError, ZeroDivisionError):
            pass

    # 24h stats from indicators
    indicators = r.get("indicators", {})
    quote_list = indicators.get("quote") or [{}]
    ohlcv = quote_list[0] if quote_list else {}
    highs = [h for h in (ohlcv.get("high") or []) if h is not None]
    lows = [l for l in (ohlcv.get("low") or []) if l is not None]
    volumes = [v for v in (ohlcv.get("volume") or []) if v is not None]

    output = {
        "symbol": ticker,
        "base": sym if "-" not in sym else sym.split("-")[0],
        "quote_currency": vs,
        "price": fmt_price(price),
        "change": change,
        "change_pct": change_pct,
        "day_high": fmt_price(max(highs)) if highs else None,
        "day_low": fmt_price(min(lows)) if lows else None,
        "volume": fmt_large(sum(volumes)) if volumes else None,
        "52w_high": fmt_price(meta.get("fiftyTwoWeekHigh")),
        "52w_low": fmt_price(meta.get("fiftyTwoWeekLow")),
        "exchange": meta.get("exchangeName"),
        "short_name": meta.get("shortName") or meta.get("longName"),
        "data_source": "Yahoo Finance",
    }
    print_json(output)


# ---------------------------------------------------------------------------
# CLI entry point
# ---------------------------------------------------------------------------


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="stocks_client",
        description="Stock & crypto market data CLI — Hermes Agent",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  stocks_client.py quote AAPL MSFT GOOGL
  stocks_client.py search "Tesla"
  stocks_client.py history AAPL --range 3mo
  stocks_client.py compare AAPL MSFT GOOGL AMZN
  stocks_client.py crypto BTC
  stocks_client.py crypto ETH --vs EUR
  ALPHA_VANTAGE_KEY=yourkey stocks_client.py quote AAPL
        """,
    )

    sub = parser.add_subparsers(dest="command", required=True)

    # quote
    p_quote = sub.add_parser("quote", help="Get current quote for one or more symbols")
    p_quote.add_argument("symbols", nargs="+", metavar="SYMBOL", help="Stock ticker symbol(s)")

    # search
    p_search = sub.add_parser("search", help="Search for stocks by name or symbol")
    p_search.add_argument("query", help="Search query (company name or partial symbol)")

    # history
    p_history = sub.add_parser("history", help="Price history for a symbol")
    p_history.add_argument("symbol", metavar="SYMBOL", help="Stock ticker symbol")
    p_history.add_argument(
        "--range",
        dest="range_",
        default="1mo",
        choices=["1mo", "3mo", "6mo", "1y", "5y"],
        help="Date range (default: 1mo)",
    )

    # compare
    p_compare = sub.add_parser("compare", help="Compare multiple stocks side by side")
    p_compare.add_argument("symbols", nargs="+", metavar="SYMBOL", help="At least 2 stock symbols")

    # crypto
    p_crypto = sub.add_parser("crypto", help="Crypto price (BTC, ETH, SOL, etc.)")
    p_crypto.add_argument("symbol", metavar="SYMBOL", help="Crypto symbol (e.g. BTC, ETH, SOL)")
    p_crypto.add_argument(
        "--vs",
        default="USD",
        metavar="CURRENCY",
        help="Quote currency (default: USD)",
    )

    return parser


def main() -> None:
    parser = build_parser()
    args = parser.parse_args()

    try:
        if args.command == "quote":
            cmd_quote(args.symbols)
        elif args.command == "search":
            cmd_search(args.query)
        elif args.command == "history":
            cmd_history(args.symbol, range_=args.range_)
        elif args.command == "compare":
            cmd_compare(args.symbols)
        elif args.command == "crypto":
            cmd_crypto(args.symbol, vs=args.vs)
        else:
            parser.print_help()
            sys.exit(1)
    except KeyboardInterrupt:
        print_json({"error": "Interrupted by user"})
        sys.exit(130)
    except Exception as e:
        print_json({"error": f"Unexpected error: {e}", "type": type(e).__name__})
        sys.exit(1)


if __name__ == "__main__":
    main()