from __future__ import annotations

import argparse
import datetime as dt
import os
import re
import sys
import time
import urllib.error
import urllib.request
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass
from pathlib import Path

BASE_URL_DEFAULT = "https://axavier.org/UnitCommitment.jl/0.4/instances"


@dataclass(frozen=True)
class Task:
    case: str
    date: dt.date
    url: str
    out_path: Path


def _iter_dates(start: dt.date, end: dt.date):
    if end < start:
        raise ValueError("end_date must be >= start_date")
    cur = start
    one = dt.timedelta(days=1)
    while cur <= end:
        yield cur
        cur += one


def _default_instances_md_path() -> Path:
    here = Path(__file__).resolve()
    project_root = here.parents[2]
    return project_root / "docs" / "src" / "guides" / "instances.md"


def _parse_matpower_cases_from_instances_md(instances_md_path: Path) -> list[str]:
    text = instances_md_path.read_text(encoding="utf-8")
    pattern = re.compile(r"matpower/(case[^/\s`]+)/\d{4}-\d{2}-\d{2}")
    cases = sorted(set(pattern.findall(text)))
    if not cases:
        raise RuntimeError(f"No MATPOWER cases found in {instances_md_path}")
    return cases


def _download_one(task: Task, timeout_s: float, retries: int, force: bool) -> tuple[str, str | None]:
    task.out_path.parent.mkdir(parents=True, exist_ok=True)

    if task.out_path.exists() and not force and task.out_path.stat().st_size > 0:
        return ("skipped", None)

    tmp_path = task.out_path.with_suffix(task.out_path.suffix + ".part")
    req = urllib.request.Request(task.url, headers={"User-Agent": "UnitCommitment downloader"})

    last_err = None
    for attempt in range(retries + 1):
        try:
            with urllib.request.urlopen(req, timeout=timeout_s) as resp:
                with open(tmp_path, "wb") as f:
                    while True:
                        chunk = resp.read(1024 * 256)
                        if not chunk:
                            break
                        f.write(chunk)
            os.replace(tmp_path, task.out_path)
            return ("downloaded", None)
        except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, OSError) as e:
            last_err = e
            try:
                if tmp_path.exists():
                    tmp_path.unlink()
            except OSError:
                pass
            if attempt < retries:
                time.sleep(min(10.0, 0.5 * (2**attempt)))
                continue
            return ("failed", f"{type(last_err).__name__}: {last_err}")

    return ("failed", f"{type(last_err).__name__}: {last_err}")


def _build_tasks(
    base_url: str,
    out_dir: Path,
    cases: list[str],
    start_date: dt.date,
    end_date: dt.date,
) -> list[Task]:
    tasks: list[Task] = []
    for case in cases:
        for d in _iter_dates(start_date, end_date):
            date_str = d.isoformat()
            url = f"{base_url}/matpower/{case}/{date_str}.json.gz"
            out_path = out_dir / case / f"{date_str}.json.gz"
            tasks.append(Task(case=case, date=d, url=url, out_path=out_path))
    return tasks


def _parse_date(s: str) -> dt.date:
    return dt.date.fromisoformat(s)


def main(argv: list[str]) -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--instances-md", type=Path, default=_default_instances_md_path())
    parser.add_argument("--base-url", type=str, default=BASE_URL_DEFAULT)
    parser.add_argument(
        "--out-dir",
        type=Path,
        default=(Path(__file__).resolve().parents[2] / "instances" / "matpower"),
    )
    parser.add_argument("--start-date", type=_parse_date, default=dt.date(2017, 1, 1))
    parser.add_argument("--end-date", type=_parse_date, default=dt.date(2017, 12, 31))
    parser.add_argument("--workers", type=int, default=min(32, (os.cpu_count() or 4) * 4))
    parser.add_argument("--timeout", type=float, default=60.0)
    parser.add_argument("--retries", type=int, default=3)
    parser.add_argument("--force", action="store_true")
    parser.add_argument("--dry-run", action="store_true")
    parser.add_argument("--list-cases", action="store_true")
    args = parser.parse_args(argv)

    instances_md_path: Path = args.instances_md
    if not instances_md_path.exists():
        raise FileNotFoundError(str(instances_md_path))

    cases = _parse_matpower_cases_from_instances_md(instances_md_path)
    if args.list_cases:
        for c in cases:
            print(c)
        return 0

    out_dir: Path = args.out_dir
    tasks = _build_tasks(
        base_url=args.base_url.rstrip("/"),
        out_dir=out_dir,
        cases=cases,
        start_date=args.start_date,
        end_date=args.end_date,
    )

    print(f"cases={len(cases)} files={len(tasks)} out_dir={out_dir}")
    if args.dry_run:
        for t in tasks[:10]:
            print(f"{t.url} -> {t.out_path}")
        if len(tasks) > 10:
            print("...")
        return 0

    downloaded = 0
    skipped = 0
    failed = 0
    total = len(tasks)
    t0 = time.time()
    last_print = 0.0

    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as ex:
        fut_to_task = {
            ex.submit(_download_one, t, args.timeout, args.retries, args.force): t for t in tasks
        }
        for i, fut in enumerate(as_completed(fut_to_task), start=1):
            status, err = fut.result()
            if status == "downloaded":
                downloaded += 1
            elif status == "skipped":
                skipped += 1
            else:
                failed += 1
                task = fut_to_task[fut]
                sys.stderr.write(f"FAILED {task.url} -> {task.out_path} ({err})\n")

            now = time.time()
            if now - last_print >= 1.0 or i == total:
                elapsed = max(0.001, now - t0)
                rate = i / elapsed
                print(
                    f"{i}/{total} downloaded={downloaded} skipped={skipped} failed={failed} rate={rate:.1f}/s"
                )
                last_print = now

    if failed:
        return 2
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1:]))