"""模拟盘 API 路由（spec §10）。

create 建 paper_account（持久化配置）；GET 查询净值/成交/状态。
回放执行（engine.run）由 orchestrator 异步触发或容器内同步跑，端到端冒烟在容器
（本机无 NAS parquet + vnpy 完整依赖），本模块只做 account 管理 + 查询。
"""
import json
import sqlite3
import time

from fastapi import APIRouter, Depends, Header, HTTPException
from pydantic import BaseModel

from .auth import verify_token as verify_token_impl
from . import instance_store
from .validation import validate_backtest_range

router = APIRouter()
_db_path = {"path": None}


def set_db_path(p):
    _db_path["path"] = p
    if p:
        from sanguo_trader.persistence import init_db
        init_db(p)   # app 启动建表（幂等），保证 GET 查询不报 no such table


async def verify_token(authorization: str | None = Header(None)):
    if authorization is None or not authorization.startswith("Bearer "):
        raise HTTPException(401, "Missing/invalid authorization")
    return verify_token_impl(authorization.split(" ", 1)[1])


class StrategyCfg(BaseModel):
    name: str
    params: dict = {}
    match_session: str = "next_open"
    symbol: str
    listing_days: int = 0
    max_allocation: float | None = None   # 软限额（spec §195），None=用 initial_capital


class PaperCreateRequest(BaseModel):
    name: str = "paper"
    mode: str = "replay"
    interval: str = "d"
    symbols: list[str]
    strategies: list[StrategyCfg]
    initial_capital: float = 1_000_000
    rate: float = 0.0003
    slippage: float = 0.0
    pricetick: float = 0.01
    stamp_duty_rate: float = 0.0005
    transfer_fee_rate: float = 0.00001
    min_commission: float = 5.0
    start: str
    end: str
    # 组合策略实走（E1）：strategy_type=portfolio 时 mode 必须 live，
    # strategies[0].name=组合策略名，pool/max_pool/benchmark 进 params
    strategy_type: str = "cta"
    # 撮合引擎（影子柜台 P1）：eod_replay=日终回放(NAS 20:30) / shadow=影子柜台(VPS 盘中实时)
    engine: str = "eod_replay"
    pool: str = "all"
    max_pool: int = 0
    benchmark: str = "000300.XSHG"
    # §12.6 实例做实：账户绑档案；空=发起即建档（自动创建实例再发起）
    instance_id: int | None = None


def _resolve_file_by_class(class_name: str) -> str:
    """类名 → 策略文件名（发起即建档时反查 code_file；查不到返回空）。"""
    try:
        from .strategy_registry import list_strategy_files

        for f in list_strategy_files()["files"]:
            if f.get("class_name") == class_name:
                return f.get("name", "")
    except Exception:
        pass
    return ""


def _ensure_instance_for_paper(req: PaperCreateRequest) -> int:
    """§12.6 D1/D5：发起时绑档案。带合法 instance_id 用之；否则发起即建档。"""
    from . import instance_store

    if req.instance_id and instance_store.get_instance_params_snapshot(req.instance_id):
        return req.instance_id
    strat = req.strategies[0] if req.strategies else None
    cls = strat.name if strat else ""
    sym = req.pool if req.strategy_type == "portfolio" else ",".join(req.symbols)
    return instance_store.create_instance({
        "code_file": _resolve_file_by_class(cls),
        "name": f"{cls}·{req.mode}·{time.strftime('%m%d')}",
        "type": req.strategy_type,
        "params": dict(strat.params) if strat else {},
        "symbol_or_pool": sym,
        "interval": req.interval,
        "match_session": strat.match_session if strat else "next_open",
    })


@router.post("/paper/create", dependencies=[Depends(verify_token)])
def create_paper(req: PaperCreateRequest):
    from sanguo_trader.persistence import init_db, save_account
    import threading

    db = _db_path["path"] or ":memory:"
    init_db(db)
    # 实例绑定先于日期归一(model_dump 要带上 instance_id 落库)
    req.instance_id = _ensure_instance_for_paper(req)
    # §12.6 D1 发起时快照：绑已有档案 → 账户参数用档案当时的参数（复印件），
    # 后续改档案不影响本账户（漂移可见，手动同步）
    snap = instance_store.get_instance_params_snapshot(req.instance_id) if req.instance_id else None
    if snap and req.strategies:
        req.strategies[0].params = dict(snap.get("params") or {})
    # §12.6 补：发起时代码版本快照（运行可回溯当时跑的哪版代码）
    from .code_versions import snapshot_code

    code_snap = snapshot_code((snap or {}).get("code_file") or "")
    code_hash = code_snap["code_hash"] if code_snap else None
    # 实走/影子是开放账户:起止日期无意义,开始=创建当天(组合日终重放依赖 start_date,
    # 空值会崩),结束留空;仅回放保留用户填的历史区间
    if req.mode in ("live", "shadow"):
        from datetime import date

        req.start = date.today().isoformat()
        req.end = ""
    elif req.mode == "replay":
        # 回放保留用户填的历史区间 → 校验(未来日期/超数据范围等 400,同回测口径)
        validate_backtest_range(req.start, req.end)
    if req.strategy_type == "portfolio":
        if req.mode not in ("live", "shadow"):
            raise HTTPException(400, "组合策略模拟盘仅支持实走(live)/影子(shadow)模式；历史回放请用「组合回测」")
        payload = req.model_dump()
        payload["code_hash"] = code_hash
        payload["engine"] = "shadow" if req.mode == "shadow" else "eod_replay"
        payload["symbols"] = [req.pool]
        payload["strategies"] = [{
            "name": (req.strategies[0].name if req.strategies else "all_weather"),
            "params": {"max_pool": req.max_pool, "benchmark": req.benchmark},
        }]
        aid = save_account(db, payload)
        from sanguo_trader.persistence import update_account_status
        update_account_status(db, aid, "running")
        return {"account_id": aid, "status": "running"}

    cta_payload = req.model_dump()
    cta_payload["code_hash"] = code_hash
    cta_payload["engine"] = "shadow" if req.mode == "shadow" else "eod_replay"
    aid = save_account(db, cta_payload)
    status = "created"
    if req.mode == "replay":   # 回放后台线程跑，create 立即返回（避免阻塞 worker 502）
        def _bg():
            from sanguo_trader.persistence import update_account_status
            from .instance_store import update_instance_run
            try:
                _run_replay(db, aid, req)
                update_account_status(db, aid, "done")
                # §12.6 回放完成回写档案（收益=末次净值/初始-1）
                if req.instance_id:
                    from sanguo_trader.persistence import load_last_balance
                    last = load_last_balance(db, aid)
                    ret = None
                    if last and req.initial_capital:
                        ret = (last.get("total_equity", 0) - req.initial_capital) / req.initial_capital
                    update_instance_run(req.instance_id, "replay", "done", ret, {"account_id": aid})
            except Exception as e:  # noqa: BLE001
                update_account_status(db, aid, "failed", str(e))
                if req.instance_id:
                    update_instance_run(req.instance_id, "replay", "failed")
        threading.Thread(target=_bg, daemon=True).start()
        status = "running"
    elif req.mode in ("live", "shadow"):  # 实走:每日 20:30 step;影子:等 VPS 影子柜台进程接管
        from sanguo_trader.persistence import update_account_status
        update_account_status(db, aid, "running")
        status = "running"
    return {"account_id": aid, "status": status}


@router.post("/paper/sync/{instance_id}", dependencies=[Depends(verify_token)])
def sync_instance_params(instance_id: int):
    """§12.6 D2/D3 参数同步：档案当前参数 → 该档案全部运行中模拟账户。

    实走+影子一起换（影子与实盘/对照账户参数必须锁死，否则双轨对账失效）。
    实盘不在此列（D2：实盘不提供在线改参，停了重发）。
    生效时机（2026-08-15 实证）：实走(CTA/组合)每日结算从 DB 重读 strategies
    → 次日 20:30 生效；影子柜台进程常驻内存 → 需重启影子进程生效。
    """
    from . import instance_store

    snap = instance_store.get_instance_params_snapshot(instance_id)
    if snap is None:
        raise HTTPException(404, "实例不存在")
    db = _db_path["path"] or ":memory:"
    synced = 0
    with sqlite3.connect(db) as conn:
        rows = conn.execute(
            "SELECT id, strategies FROM paper_accounts "
            "WHERE instance_id=? AND status='running'",
            (instance_id,),
        ).fetchall()
        for aid, raw in rows:
            try:
                strats = json.loads(raw) if isinstance(raw, str) else (raw or [])
            except (ValueError, TypeError):
                continue
            if not strats:
                continue
            strats[0]["params"] = dict(snap["params"])
            conn.execute(
                "UPDATE paper_accounts SET strategies=?, updated_at=? WHERE id=?",
                (json.dumps(strats, ensure_ascii=False), time.strftime("%Y-%m-%d %H:%M:%S"), aid),
            )
            synced += 1
        conn.commit()
    return {"synced": synced}


@router.get("/paper", dependencies=[Depends(verify_token)])
def list_papers():
    """模拟盘列表（启用聚宽级模拟交易列表页）。每行带最新净值 + 收益率。"""
    from sanguo_trader.persistence import load_last_balance

    db = _db_path["path"]
    with sqlite3.connect(db) as conn:
        conn.row_factory = sqlite3.Row
        rows = conn.execute(
            "SELECT * FROM paper_accounts ORDER BY id DESC"
        ).fetchall()
        # #71 持仓数（volume>0 的持仓行，对齐实盘列表）
        pos_counts = {
            r[0]: r[1] for r in conn.execute(
                "SELECT account_id, COUNT(*) FROM paper_positions "
                "WHERE volume > 0 GROUP BY account_id"
            ).fetchall()
        }
    out = []
    for r in rows:
        item = dict(r)
        item["position_count"] = pos_counts.get(item["id"], 0)
        cap = item.get("initial_capital") or 0
        last = load_last_balance(db, item["id"])
        if last and cap:
            item["latest_equity"] = last.get("total_equity")
            item["latest_date"] = last.get("date")
            item["total_return"] = (last.get("total_equity", 0) - cap) / cap
        else:
            item["latest_equity"] = None
            item["latest_date"] = None
            item["total_return"] = None
        out.append(item)
    return {"accounts": out}


# ===== 双轨对账（影子柜台 vs 实盘模拟，设计 §8.2 / 影子 P3 前半）=====
# 注意:须注册在 /paper/{aid} 之前,否则 "reconcile" 被当作 aid → 422

@router.get("/paper/reconcile", dependencies=[Depends(verify_token)])
def list_reconcile_pairs(date: str | None = None):
    """双轨配对列表 + 各配对对账报告(按需现算并落库)。

    自动配对:运行中影子账户(mode=shadow)按策略名匹配 live_accounts。
    date 缺省 = 今天。
    """
    from sanguo_trader.shadow.reconcile_report import (
        build_reconcile_report, find_dual_track_pairs, load_reconcile_report,
        save_reconcile_report,
    )

    db = _db_path["path"]
    out = []
    for pair in find_dual_track_pairs(db):
        saved = load_reconcile_report(
            db, pair["live_account_id"], pair["shadow_account_id"], date or "")
        report = saved or build_reconcile_report(
            db, pair["live_account_id"], pair["shadow_account_id"], date)
        save_reconcile_report(db, report)
        # §12.6 补：双轨代码版本一致性（对账 FAIL 先查这行——两边代码不同价差必然大）
        with sqlite3.connect(db) as conn:
            hashes = dict(conn.execute(
                "SELECT id, code_hash FROM paper_accounts WHERE id IN (?,?)",
                (pair["live_account_id"], pair["shadow_account_id"]),
            ).fetchall())
        h1 = hashes.get(pair["live_account_id"])
        h2 = hashes.get(pair["shadow_account_id"])
        code_match = None if not (h1 and h2) else h1 == h2
        out.append({**pair, "code_match": code_match, "report": report})
    return {"pairs": out}


@router.get("/paper/reconcile/{live_id}/{shadow_id}", dependencies=[Depends(verify_token)])
def get_reconcile(live_id: int, shadow_id: int, date: str | None = None,
                  refresh: bool = False):
    """单配对对账报告。refresh=true 强制重算(缺省读已存,无则现算)。"""
    from sanguo_trader.shadow.reconcile_report import (
        build_reconcile_report, load_reconcile_report, save_reconcile_report,
    )

    db = _db_path["path"]
    if not refresh:
        saved = load_reconcile_report(db, live_id, shadow_id, date or "")
        if saved is not None:
            return saved
    report = build_reconcile_report(db, live_id, shadow_id, date)
    save_reconcile_report(db, report)
    return report


@router.get("/paper/{aid}", dependencies=[Depends(verify_token)])
def get_paper(aid: int):
    db = _db_path["path"]
    with sqlite3.connect(db) as conn:
        conn.row_factory = sqlite3.Row
        row = conn.execute(
            "SELECT * FROM paper_accounts WHERE id=?", (aid,)
        ).fetchone()
    if not row:
        raise HTTPException(404, "account not found")
    return dict(row)


@router.get("/paper/{aid}/equity", dependencies=[Depends(verify_token)])
def get_equity(aid: int):
    from sanguo_trader.persistence import list_daily_balance

    return list_daily_balance(_db_path["path"], aid)


@router.get("/paper/{aid}/trades", dependencies=[Depends(verify_token)])
def get_trades(aid: int):
    from sanguo_trader.persistence import list_trades

    return list_trades(_db_path["path"], aid)


@router.get("/paper/{aid}/strategies", dependencies=[Depends(verify_token)])
def get_strategies(aid: int):
    """分策略归因：成交/拒单/费用聚合（spec §7）。"""
    from sanguo_trader.persistence import list_strategy_summary

    return list_strategy_summary(_db_path["path"], aid)


@router.get("/paper/{aid}/positions", dependencies=[Depends(verify_token)])
def get_positions(aid: int):
    """当前持仓快照（实走监控，Phase 3c）。{symbol:{volume,frozen,avg_price}} → list。"""
    from sanguo_trader.persistence import load_positions

    pos = load_positions(_db_path["path"], aid, "account")
    return [
        {"symbol": sym, "volume": p["volume"], "frozen": p.get("frozen", 0),
         "avg_price": p["avg_price"]}
        for sym, p in pos.items()
    ]


@router.get("/paper/{aid}/pending", dependencies=[Depends(verify_token)])
def get_pending(aid: int):
    """跨日 pending 订单（实走监控，Phase 3c）。"""
    from sanguo_trader.persistence import load_pending_orders

    return load_pending_orders(_db_path["path"], aid)


# ===== 生命周期管理（spec §10 补全：停止/恢复/删除/编辑）=====

def _get_account_row(db, aid: int) -> dict:
    with sqlite3.connect(db) as conn:
        conn.row_factory = sqlite3.Row
        row = conn.execute("SELECT * FROM paper_accounts WHERE id=?", (aid,)).fetchone()
    if not row:
        raise HTTPException(404, "account not found")
    return dict(row)


@router.post("/paper/{aid}/stop", dependencies=[Depends(verify_token)])
def stop_paper(aid: int):
    """停止实走/影子：置 status=stopped，日终 step 与影子柜台都只选 running → 自动跳过。"""
    from sanguo_trader.persistence import update_account_status

    db = _db_path["path"]
    acc = _get_account_row(db, aid)
    if acc.get("mode") not in ("live", "shadow"):
        raise HTTPException(400, "仅实走/影子账户支持停止；回放账户为一次性任务")
    update_account_status(db, aid, "stopped")
    return {"account_id": aid, "status": "stopped"}


@router.post("/paper/{aid}/resume", dependencies=[Depends(verify_token)])
def resume_paper(aid: int):
    """恢复实走/影子：次日 20:30 起继续 step / 影子柜台继续接管。"""
    from sanguo_trader.persistence import update_account_status

    db = _db_path["path"]
    acc = _get_account_row(db, aid)
    if acc.get("mode") not in ("live", "shadow"):
        raise HTTPException(400, "仅实走/影子账户支持恢复")
    update_account_status(db, aid, "running")
    return {"account_id": aid, "status": "running"}


@router.delete("/paper/{aid}", dependencies=[Depends(verify_token)])
def delete_paper(aid: int):
    """删除模拟盘账户及其全部数据（净值/成交/持仓/挂单，不可恢复）。"""
    db = _db_path["path"]
    _get_account_row(db, aid)
    tables = ("paper_accounts", "paper_daily_balance", "paper_trades",
              "paper_positions", "paper_pending_orders", "paper_shadow_orders")
    with sqlite3.connect(db) as conn:
        for t in tables:
            if t == "paper_accounts":
                conn.execute("DELETE FROM paper_accounts WHERE id=?", (aid,))
            else:
                conn.execute(f"DELETE FROM {t} WHERE account_id=?", (aid,))
        conn.commit()
    return {"account_id": aid, "deleted": True}


class PaperUpdateRequest(BaseModel):
    """可编辑字段（其余字段沿用原值；策略参数/标的改动自下次 step 生效）。"""
    name: str | None = None
    symbols: list[str] | None = None
    strategies: list[StrategyCfg] | None = None
    initial_capital: float | None = None


@router.put("/paper/{aid}", dependencies=[Depends(verify_token)])
def update_paper(aid: int, req: PaperUpdateRequest):
    db = _db_path["path"]
    _get_account_row(db, aid)
    sets, args = [], []
    if req.name is not None:
        sets.append("name=?"); args.append(req.name)
    if req.symbols is not None:
        sets.append("symbols=?"); args.append(json.dumps(req.symbols))
    if req.strategies is not None:
        sets.append("strategies=?")
        args.append(json.dumps([s.model_dump() for s in req.strategies]))
    if req.initial_capital is not None:
        sets.append("initial_capital=?"); args.append(req.initial_capital)
    if not sets:
        return {"account_id": aid, "updated": False}
    with sqlite3.connect(db) as conn:
        conn.execute(f"UPDATE paper_accounts SET {', '.join(sets)} WHERE id=?", (*args, aid))
        conn.commit()
    return {"account_id": aid, "updated": True}


class _DataSourceWrapper:
    """包装 iter_bars/fetch_day 给 PaperEngine/live_orchestrator。"""

    def __init__(self, cfg):
        self.cfg = cfg

    def iter_bars(self, symbols, start, end, interval, adjust="qfq", cfg=None):
        from sanguo_trader.data_source import iter_bars

        return iter_bars(symbols, start, end, interval, adjust, cfg or self.cfg)

    def fetch_day(self, symbol, date, interval, adjust="qfq", cfg=None):
        from sanguo_trader.data_source import fetch_day

        return fetch_day(symbol, date, interval, adjust, cfg or self.cfg)


def _run_replay(db, aid, req: PaperCreateRequest):
    """构造引擎 + 跑回放（容器内有 vnpy_ctastrategy + NAS parquet，本机仅空转）。"""
    from sanguo_trader.account import Account
    from sanguo_trader.cta_adapter import PaperCtaEngine
    from sanguo_trader.engine import PaperEngine
    from sanguo_trader.models import AccountConfig
    from sanguo_trader.strategy_runner import StrategyRunner
    from sanguo_data.config import find_config_path, load_config
    from sanguo_data.datareader import guess_exchange
    from .strategy_registry import get_strategy_class

    data_cfg = load_config(find_config_path())
    acc_cfg = AccountConfig(
        initial_capital=req.initial_capital, rate=req.rate, slippage=req.slippage,
        pricetick=req.pricetick, stamp_duty_rate=req.stamp_duty_rate,
        transfer_fee_rate=req.transfer_fee_rate, min_commission=req.min_commission,
    )
    account = Account(req.initial_capital)
    runners: list = []
    for s in req.strategies:
        cls = get_strategy_class(s.name)
        if cls is None:
            continue   # 策略不可用（本机无 vnpy_ctastrategy）→ 跳过
        from sanguo_trader.limit import lot_size_for
        cta = PaperCtaEngine(s.name, match_session=s.match_session,
                             listing_days=s.listing_days,
                             size=lot_size_for(s.symbol))   # 主板 100 / 科创 200 股一手
        vt_symbol = f"{s.symbol}.{guess_exchange(s.symbol).value}"
        strat = cls(cta, s.name, vt_symbol, s.params)   # CtaTemplate(cta_engine, name, vt_symbol, setting)
        strat.trading = True   # 允许 send_order（等价 on_start）
        try:
            from vnpy.trader.utility import ArrayManager
            if not hasattr(strat, "am"):
                strat.am = ArrayManager(20)   # 默认 100 根才 inited，短区间不够；用 20 兼容
        except Exception:
            pass
        cta.set_strategy(strat)
        runners.append(StrategyRunner(
            s.name, strategy=strat, paper_cta_engine=cta, symbol=s.symbol,
            max_allocation=(s.max_allocation if s.max_allocation is not None
                            else req.initial_capital)))
    from sanguo_data.dividend_source import build_dividend_calendar
    div_calendar = build_dividend_calendar(req.symbols, req.start, req.end)
    pe = PaperEngine(account, runners, _DataSourceWrapper(data_cfg), acc_cfg,
                     db, aid, req.symbols, req.start, req.end, req.interval,
                     risk_free_rate=getattr(data_cfg, "risk_free_rate", 0.0),
                     dividends_by_date=div_calendar)
    pe.run()