"""
Record one LoL event's main winner markets in a single CLOB orderbook session.

Default targets are inferred from the event:
    moneyline plus direct game winner markets game1 through game4.
"""
from __future__ import annotations

import asyncio
import os
import signal
import sys
from pathlib import Path

import click
from dotenv import load_dotenv
from loguru import logger

ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if ROOT not in sys.path:
    sys.path.insert(0, ROOT)

from analysis.lpl_orderbook.recorder import LplEventOrderbookRecorder  # noqa: E402


def _setup_logging() -> None:
    logger.remove()
    logger.add(
        sys.stderr,
        level=os.environ.get("LOG_LEVEL", "INFO").upper(),
        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level:<7}</level> | {message}",
        colorize=True,
    )


def _market_set(raw: str) -> set[str] | None:
    if raw.strip().lower() == "auto":
        return None
    values = {item.strip().lower() for item in raw.split(",") if item.strip()}
    aliases = {"series": "moneyline", "match": "moneyline"}
    normalized = {aliases.get(item, item) for item in values}
    allowed = {"moneyline", *{f"game{i}" for i in range(1, 5)}}
    unknown = normalized - allowed
    if unknown:
        raise click.BadParameter(f"unsupported markets: {','.join(sorted(unknown))}")
    return normalized


@click.command()
@click.option("--event-slug", required=True, help="Polymarket event slug")
@click.option(
    "--markets",
    default="auto",
    show_default=True,
    help="auto, or comma-separated target markets through game4",
)
@click.option(
    "--output-root",
    default="data/lpl",
    show_default=True,
    type=click.Path(file_okay=False, path_type=Path),
)
@click.option(
    "--snapshot-interval-seconds",
    default=0.5,
    show_default=True,
    type=float,
    help="Periodic full local-book snapshot interval",
)
@click.option("--insecure-ssl", is_flag=True, help="Disable SSL verification for debugging")
@click.option("--status-interval-seconds", default=5.0, show_default=True, type=float)
@click.option("--jsonl-flush-every", default=100, show_default=True, type=int)
@click.option("--jsonl-flush-interval-seconds", default=0.5, show_default=True, type=float)
def main(
    event_slug: str,
    markets: str,
    output_root: Path,
    snapshot_interval_seconds: float,
    insecure_ssl: bool,
    status_interval_seconds: float,
    jsonl_flush_every: int,
    jsonl_flush_interval_seconds: float,
) -> None:
    load_dotenv()
    _setup_logging()
    recorder = LplEventOrderbookRecorder(
        event_slug=event_slug,
        markets=_market_set(markets),
        output_root=output_root,
        snapshot_interval_seconds=snapshot_interval_seconds,
        insecure_ssl=insecure_ssl,
        status_interval_seconds=status_interval_seconds,
        jsonl_flush_every=jsonl_flush_every,
        jsonl_flush_interval_seconds=jsonl_flush_interval_seconds,
    )

    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    for sig in (signal.SIGINT, signal.SIGTERM):
        loop.add_signal_handler(sig, recorder.stop)

    logger.info(f"开始录制 LoL event orderbook: event_slug={event_slug} markets={markets}")
    try:
        loop.run_until_complete(recorder.run())
    finally:
        loop.close()
    logger.info(f"录制已停止: event_slug={event_slug}")


if __name__ == "__main__":
    main()