"""使用 CSV 样例演示接收时间关联和盘口成交模拟，仅使用 Python 标准库。"""

import argparse
import csv
import hashlib
import json
import math
from bisect import bisect_right
from collections import defaultdict
from datetime import datetime, timezone
from pathlib import Path


def finite(value):
    number = float(value)
    if not math.isfinite(number):
        raise ValueError("数值必须有限")
    return number


def utc_ms(value):
    return datetime.fromtimestamp(value / 1000, timezone.utc).isoformat(timespec="milliseconds")


def load_sample(directory):
    manifest = json.loads((directory / "manifest.json").read_text(encoding="utf-8"))
    tables = {}
    checksums = {}
    for name in ("ticks", "depth", "outcomes"):
        filename = directory / (name + ".csv")
        with filename.open(encoding="utf-8", newline="") as stream:
            tables[name] = list(csv.DictReader(stream))
        checksums[filename.name] = hashlib.sha256(filename.read_bytes()).hexdigest()
        expected = next(item["rows"] for item in manifest["files"] if item["file"] == name + ".parquet")
        if len(tables[name]) != expected:
            raise ValueError("CSV 行数与样例清单不符")
    market = manifest["market"]
    if any(row["event_slug"] != market for table in tables.values() for row in table):
        raise ValueError("教程只接受清单指定的单市场")
    ticks = sorted(tables["ticks"], key=lambda row: (int(row["received_ts_ms"]), finite(row["ts"])))
    keys = {(row["event_slug"], row["ts"]) for row in ticks}
    if len(keys) != len(ticks):
        raise ValueError("报价关联键重复")
    depth = defaultdict(list)
    for row in tables["depth"]:
        key = (row["event_slug"], row["ts"])
        if key not in keys:
            raise ValueError("深度记录缺少对应报价")
        price, size = finite(row["price"]), finite(row["size"])
        if not 0 <= price <= 1 or size < 0:
            raise ValueError("盘口价格或数量无效")
        depth[key].append(row)
    return manifest, tables, ticks, depth, checksums


def consume_book(levels, side, quantity, size_fraction, fee_bps):
    """每档只使用指定比例的展示数量，不把剩余订单假定为已成交。"""
    chosen = [row for row in levels if row["outcome"] == "UP" and row["side"] == side]
    chosen.sort(key=lambda row: finite(row["price"]), reverse=side == "BID")
    remaining, notional = quantity, 0.0
    used = []
    for row in chosen:
        take = min(remaining, finite(row["size"]) * size_fraction)
        if take <= 0:
            continue
        price = finite(row["price"])
        used.append({"level": int(row["level"]), "price": price, "quantity": take})
        notional += take * price
        remaining -= take
        if remaining <= 1e-9:
            remaining = 0.0
            break
    filled = quantity - remaining
    return {"requested_quantity": quantity, "filled_quantity": filled,
            "unfilled_quantity": remaining, "vwap": notional / filled if filled else None,
            "notional_usd": notional, "fee_usd": notional * fee_bps / 10000, "levels": used}


def simulate(ticks, depth, quantity=100.0, latency_ms=250, hold_seconds=60,
             max_staleness_ms=2000, size_fraction=0.5, fee_bps=0.0):
    if not ticks:
        raise ValueError("缺少报价")
    start = int(ticks[0]["window_start_ts"]) * 1000
    end = int(ticks[0]["window_end_ts"]) * 1000
    # 决策只依赖盘中已接收的报价，不读取最终结算标签。
    eligible = [row for row in ticks if start <= int(row["received_ts_ms"]) < end
                and start <= finite(row["ts"]) * 1000 < end]
    if not eligible:
        raise ValueError("正式市场窗口内没有可用报价")
    received = [int(row["received_ts_ms"]) for row in eligible]
    decision = received[0]

    def snapshot(arrival):
        if arrival >= end:
            raise ValueError("模拟订单到达时间超出市场窗口")
        index = bisect_right(received, arrival) - 1
        if index < 0:
            raise ValueError("到达时没有已接收的盘口")
        row = eligible[index]
        age = arrival - int(row["received_ts_ms"])
        if age > max_staleness_ms:
            raise ValueError("最近盘口超过允许陈旧时间，拒绝填补缺口")
        levels = depth.get((row["event_slug"], row["ts"]), [])
        if not levels:
            raise ValueError("所选报价缺少对应深度")
        return row, levels, age

    entry_arrival = decision + latency_ms
    entry_row, entry_levels, entry_age = snapshot(entry_arrival)
    buy = consume_book(entry_levels, "ASK", quantity, size_fraction, fee_bps)
    if buy["filled_quantity"] <= 0:
        raise ValueError("买入时没有可用 UP 卖盘")
    exit_decision = entry_arrival + hold_seconds * 1000
    exit_arrival = exit_decision + latency_ms
    exit_row, exit_levels, exit_age = snapshot(exit_arrival)
    sell = consume_book(exit_levels, "BID", buy["filled_quantity"], size_fraction, fee_bps)
    residual = buy["filled_quantity"] - sell["filled_quantity"]
    return {
        "decision_utc": utc_ms(decision), "entry_arrival_utc": utc_ms(entry_arrival),
        "entry_snapshot_received_utc": utc_ms(int(entry_row["received_ts_ms"])),
        "entry_snapshot_age_ms": entry_age,
        "exit_decision_utc": utc_ms(exit_decision), "exit_arrival_utc": utc_ms(exit_arrival),
        "exit_snapshot_received_utc": utc_ms(int(exit_row["received_ts_ms"])),
        "exit_snapshot_age_ms": exit_age, "buy": buy, "sell": sell,
        "residual_quantity": residual,
        "net_cash_flow_usd": sell["notional_usd"] - sell["fee_usd"] - buy["notional_usd"] - buy["fee_usd"],
        "closed_position_pnl_usd": (sell["notional_usd"] - sell["fee_usd"] - buy["notional_usd"] - buy["fee_usd"])
        if residual < 1e-9 else None,
    }


def run(args):
    manifest, tables, ticks, depth, checksums = load_sample(args.data_dir)
    params = {"quantity": args.quantity, "latency_ms": args.latency_ms,
              "hold_seconds": args.hold_seconds, "max_staleness_ms": args.max_staleness_ms,
              "size_fraction": args.size_fraction, "fee_bps": args.fee_bps}
    result = simulate(ticks, depth, **params)
    in_window = [row for row in ticks if finite(row["offset_s"]) >= 0
                 and finite(row["ts"]) < int(row["window_end_ts"])]
    intervals = [int(b["received_ts_ms"]) - int(a["received_ts_ms"]) for a, b in zip(in_window, in_window[1:])]
    report = {"market": manifest["market"], "parameters": params,
              "quality": {"rows": {name: len(rows) for name, rows in tables.items()},
                          "pre_open_ticks": sum(finite(row["offset_s"]) < 0 for row in ticks),
                          "in_window_ticks": len(in_window),
                          "max_depth_level": max(int(row["level"]) for row in tables["depth"]),
                          "first_in_window_received_utc": utc_ms(int(in_window[0]["received_ts_ms"])),
                          "last_in_window_received_utc": utc_ms(int(in_window[-1]["received_ts_ms"])),
                          "max_in_window_record_interval_ms": max(intervals, default=0),
                          "csv_sha256": checksums},
              "simulation": result,
              "limitations": ["只演示单市场一次买卖，不能证明策略盈利。",
                              "历史盘口是订单到达时市场状态的近似，未模拟真实订单对市场的影响。",
                              "记录间隔不等于断线时长，历史存储不保证覆盖每次深度变化。",
                              "费率是输入参数，默认零仅用于演示，不代表平台费率。",
                              "不模拟挂单排队，不补缺口，不用结算标签生成信号。"]}
    payload = json.dumps(report, ensure_ascii=False, indent=2, allow_nan=False) + "\n"
    if args.output:
        args.output.write_text(payload, encoding="utf-8")
    print(payload, end="")


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--data-dir", type=Path, required=True)
    parser.add_argument("--quantity", type=finite, default=100.0)
    parser.add_argument("--latency-ms", type=int, default=250)
    parser.add_argument("--hold-seconds", type=int, default=60)
    parser.add_argument("--max-staleness-ms", type=int, default=2000)
    parser.add_argument("--size-fraction", type=finite, default=0.5)
    parser.add_argument("--fee-bps", type=finite, default=0.0)
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()
    if args.quantity <= 0 or not 0 < args.size_fraction <= 1 or args.fee_bps < 0:
        parser.error("数量须为正、展示数量比例须在 (0, 1] 内，费用不得为负")
    if min(args.latency_ms, args.max_staleness_ms) < 0 or args.hold_seconds <= 0:
        parser.error("延迟和陈旧阈值不得为负，持有时间须为正")
    try:
        run(args)
    except (ValueError, KeyError, OSError, StopIteration) as error:
        parser.exit(1, "无法运行教程：" + str(error) + "\n")


if __name__ == "__main__":
    main()
