#!/usr/bin/env python3
"""
Download SPY/VXX/VIX option prices at ~10:00 AM ET from local Theta Terminal.

This wraps ``build_theta_dataset.py`` but overrides the target time from 15:45
to 10:00, and writes monthly parquet files as:

    RenTech/data/theta_chunks/{root}_1000_YYYY_MM.parquet

Default mode is quote-only (no greeks), which matches your request for option
"prices" around the open and avoids extra API volume.

Examples::

    # Default: last 10 years, SPY+VXX+VIX, quote-only @ 10:00 ET
    python RenTech/data_pipeline/download_theta_1000_options_quotes.py

    # Custom roots and date window
    python RenTech/data_pipeline/download_theta_1000_options_quotes.py \
      --roots SPY,VXX,VIX --start-date 2018-01-01 --end-date 2026-04-09

    # Include greeks near 10:00 ET as well
    python RenTech/data_pipeline/download_theta_1000_options_quotes.py \
      --include-greeks
"""

from __future__ import annotations

import argparse
import sys
from datetime import date, timedelta
from pathlib import Path

_DATA_PIPE = Path(__file__).resolve().parent
if str(_DATA_PIPE) not in sys.path:
    sys.path.insert(0, str(_DATA_PIPE))

import build_theta_dataset as btd  # noqa: E402


def _parse_roots(s: str) -> list[str]:
    out = [x.strip().upper() for x in s.split(",") if x.strip()]
    return out or ["SPY", "VXX", "VIX"]


def _configure_time_1000() -> None:
    """Override build_theta_dataset globals from 15:45 to 10:00 ET."""
    at_time_ms = (10 * 60 * 60) * 1000
    btd.AT_TIME_MS = at_time_ms
    btd.GREEKS_WINDOW_START_MS = at_time_ms - 60_000
    btd.GREEKS_WINDOW_END_MS = at_time_ms + 119_999


def _patch_month_file_naming() -> None:
    """Write monthly chunks with *_1000_YYYY_MM.parquet suffix."""

    def _month_file_path_1000(m: btd.MonthWindow, root: str) -> Path:
        r = str(root).strip().upper()
        return btd.OUT_DIR / f"{r.lower()}_1000_{m.start.year:04d}_{m.start.month:02d}.parquet"

    btd._month_file_path = _month_file_path_1000


def main() -> None:
    ap = argparse.ArgumentParser(
        description="Theta Terminal: SPY/VXX/VIX options @ 10:00 ET, monthly parquet."
    )
    ap.add_argument(
        "--roots",
        type=str,
        default="SPY,VXX,VIX",
        help="Comma-separated option roots (default: SPY,VXX,VIX).",
    )
    ap.add_argument(
        "--years",
        type=int,
        default=10,
        help="If --start-date omitted: calendar span ending today (default 10).",
    )
    ap.add_argument(
        "--start-date",
        type=str,
        default=None,
        help="YYYY-MM-DD start (default: today minus --years).",
    )
    ap.add_argument(
        "--end-date",
        type=str,
        default=None,
        help="YYYY-MM-DD end inclusive (default: today).",
    )
    ap.add_argument(
        "--workers",
        type=int,
        default=1,
        help="Parallel months (default 1).",
    )
    ap.add_argument(
        "--timeout-sec",
        type=float,
        default=btd.REQUEST_TIMEOUT_SEC,
        help=f"HTTP read timeout to Terminal (default {btd.REQUEST_TIMEOUT_SEC}).",
    )
    ap.add_argument(
        "--include-greeks",
        action="store_true",
        help="If set, also fetch greeks near 10:00 ET (slower). Default is quote-only.",
    )
    args = ap.parse_args()

    end_d = date.fromisoformat(args.end_date) if args.end_date else date.today()
    if args.start_date:
        start_d = date.fromisoformat(args.start_date)
    else:
        start_d = end_d - timedelta(days=int(args.years) * 365)

    roots = _parse_roots(args.roots)

    _configure_time_1000()
    _patch_month_file_naming()

    for i, root in enumerate(roots):
        print(
            f"\n=== [{i + 1}/{len(roots)}] root={root} {start_d} -> {end_d} @10:00 ET "
            f"skip_greeks={not args.include_greeks} ===\n",
            flush=True,
        )
        btd.build_dataset(
            root=root,
            start_date=start_d,
            end_date=end_d,
            workers=max(1, int(args.workers)),
            allow_quote_only=False,
            skip_greeks=not args.include_greeks,
            request_timeout_sec=float(args.timeout_sec),
        )


if __name__ == "__main__":
    main()