"""
MTG Corpus Fetcher — two-stage pipeline using Internet Archive.

Stage 1 (discover): enumerate URLs from IA CDX into state.db
Stage 2 (download): fetch content for pending URLs from Wayback Machine

Usage:
  python fetch.py discover
  python fetch.py discover --from-year 2024 --to-year 2025
  python fetch.py discover --dry-run

  python fetch.py download
  python fetch.py download --workers 16
  python fetch.py download --limit 500
  python fetch.py download --retry fetch_error
  python fetch.py download --dry-run
"""

import argparse
import hashlib
import sqlite3
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from datetime import datetime, timezone
from pathlib import Path

import cdx_toolkit
import trafilatura
import yaml

ROOT = Path(__file__).parent
DB_PATH = ROOT / "state.db"
CORPUS_DIR = ROOT / "corpus"
HTML_DIR = ROOT / "html"
SITES_FILE = ROOT / "sites.yaml"
MIN_LENGTH = 500


# ---------------------------------------------------------------------------
# Database
# ---------------------------------------------------------------------------

def open_db() -> sqlite3.Connection:
    conn = sqlite3.connect(str(DB_PATH), check_same_thread=False)
    conn.row_factory = sqlite3.Row
    conn.execute("PRAGMA journal_mode=WAL")
    conn.executescript("""
        CREATE TABLE IF NOT EXISTS crawl_runs (
            run_id       TEXT,
            site         TEXT,
            url_pattern  TEXT,
            status       TEXT,
            url_count    INTEGER,
            started_at   TEXT,
            completed_at TEXT,
            PRIMARY KEY (run_id, site)
        );
        CREATE TABLE IF NOT EXISTS pages (
            url              TEXT PRIMARY KEY,
            run_id           TEXT,
            site             TEXT,
            http_code        INTEGER,
            discovered_at    TEXT,
            download_status  TEXT,
            archive          TEXT,
            filename         TEXT,
            char_count       INTEGER,
            downloaded_at    TEXT
        );
        CREATE INDEX IF NOT EXISTS idx_pages_status ON pages(download_status);
    """)
    conn.commit()
    # Migrate old schema (crawl_id → run_id) if needed
    for table in ("crawl_runs", "pages"):
        try:
            conn.execute(f"ALTER TABLE {table} RENAME COLUMN crawl_id TO run_id")
            conn.commit()
        except Exception:
            pass
    return conn


# ---------------------------------------------------------------------------
# Utilities
# ---------------------------------------------------------------------------

def now_iso() -> str:
    return datetime.now(timezone.utc).isoformat()


def url_to_filename(url: str) -> str:
    slug = url.rstrip("/").split("/")[-1][:60] or "index"
    uid = hashlib.md5(url.encode()).hexdigest()[:8]
    return f"{slug}-{uid}.md"


def load_sites() -> list[dict]:
    with open(SITES_FILE, encoding="utf-8") as f:
        return yaml.safe_load(f)["sites"]


def make_run_id(from_year: int | None, to_year: int | None) -> str:
    if from_year and to_year:
        return f"ia-{from_year}-{to_year}"
    if from_year:
        return f"ia-from{from_year}"
    if to_year:
        return f"ia-to{to_year}"
    return "ia"


def year_to_ts(year: int, end: bool = False) -> str:
    return f"{year}1231235959" if end else f"{year}0101000000"


def extract_text_and_meta(html: bytes, url: str) -> tuple[str | None, object]:
    text = trafilatura.extract(
        html,
        url=url,
        output_format="markdown",
        include_comments=False,
        include_tables=True,
    )
    try:
        meta = trafilatura.extract_metadata(html.decode("utf-8", errors="replace"), default_url=url)
    except Exception:
        meta = None
    return text, meta


def build_frontmatter(url: str, site: str, run_id: str, meta=None) -> str:
    fields: dict = {
        "source": url,
        "site": site,
        "archive": "ia",
        "run": run_id,
        "fetched": datetime.now(timezone.utc).date().isoformat(),
    }
    if meta:
        if getattr(meta, "title", None):
            fields["title"] = meta.title
        if getattr(meta, "date", None):
            fields["date"] = meta.date
        if getattr(meta, "author", None):
            fields["author"] = meta.author
    body = yaml.dump(fields, allow_unicode=True, default_flow_style=False, sort_keys=False).rstrip()
    return f"---\n{body}\n---"


# ---------------------------------------------------------------------------
# Stage 1: Discover
# ---------------------------------------------------------------------------

def cmd_discover(args: argparse.Namespace) -> None:
    sites = load_sites()
    run_id = make_run_id(args.from_year, args.to_year)

    cdx_kwargs: dict = {"collapse": "urlkey"}
    if args.from_year:
        cdx_kwargs["from_ts"] = year_to_ts(args.from_year)
    if args.to_year:
        cdx_kwargs["to"] = year_to_ts(args.to_year, end=True)

    if args.dry_run:
        print(f"Run: {run_id}")
        for s in sites:
            print(f"  {s['site']:20s} {s['url']}")
        return

    db = open_db()
    print(f"Run: {run_id}")

    for s in sites:
        site, pattern = s["site"], s["url"].rstrip("/*") + "/*"

        print(f"Searching {site} with {pattern}")

        row = db.execute(
            "SELECT status FROM crawl_runs WHERE run_id=? AND site=?",
            (run_id, site),
        ).fetchone()
        if row and row["status"] == "complete":
            print(f"  [skip] {site}")
            continue

        db.execute(
            "INSERT OR REPLACE INTO crawl_runs "
            "(run_id, site, url_pattern, status, started_at) VALUES (?,?,?,?,?)",
            (run_id, site, pattern, "in_progress", now_iso()),
        )
        db.commit()
        print(f"  {site}: {pattern}")
        print(f"  querying IA CDX... (may pause on retries)", flush=True)

        cdx = cdx_toolkit.CDXFetcher(source="ia")
        count = 0
        last_url = ""
        try:
            for obj in cdx.iter(pattern, **cdx_kwargs):
                url = obj["url"]
                last_url = url
                try:
                    http_code = int(obj.get("status") or 0)
                except (ValueError, TypeError):
                    http_code = 0
                db.execute(
                    "INSERT OR IGNORE INTO pages "
                    "(url, run_id, site, http_code, discovered_at) VALUES (?,?,?,?,?)",
                    (url, run_id, site, http_code, now_iso()),
                )
                count += 1
                if count % 100 == 0:
                    db.commit()
                    ts = datetime.now(timezone.utc).strftime("%H:%M:%S")
                    print(f"    [{ts}] {count:,} URLs  last: {last_url}", flush=True)
        except Exception as e:
            db.execute(
                "UPDATE crawl_runs SET status='error', completed_at=? WHERE run_id=? AND site=?",
                (now_iso(), run_id, site),
            )
            db.commit()
            print(f"  ERROR {site}: {e}")
            continue

        db.commit()
        db.execute(
            "UPDATE crawl_runs SET status='complete', url_count=?, completed_at=? "
            "WHERE run_id=? AND site=?",
            (count, now_iso(), run_id, site),
        )
        db.commit()
        print(f"  {site}: {count:,} URLs discovered")

    db.close()


# ---------------------------------------------------------------------------
# Stage 2: Download
# ---------------------------------------------------------------------------

def process_page(row: sqlite3.Row, db: sqlite3.Connection, db_lock: threading.Lock) -> str:
    url = row["url"]
    run_id = row["run_id"]
    site = row["site"]
    http_code = row["http_code"]

    def update(status: str, filename=None, char_count=None) -> None:
        with db_lock:
            db.execute(
                "UPDATE pages SET download_status=?, archive=?, filename=?, char_count=?, "
                "downloaded_at=? WHERE url=?",
                (status, "ia" if filename else None, filename, char_count, now_iso(), url),
            )
            db.commit()

    def save_file(text: str, meta, html: bytes) -> str:
        filename = url_to_filename(url)
        out_dir = CORPUS_DIR / site
        out_dir.mkdir(parents=True, exist_ok=True)
        fm = build_frontmatter(url, site, run_id, meta)
        (out_dir / filename).write_text(f"{fm}\n\n{text}", encoding="utf-8")
        html_dir = HTML_DIR / site
        html_dir.mkdir(parents=True, exist_ok=True)
        (html_dir / filename).with_suffix(".html").write_bytes(html)
        return filename

    # Fetch from Wayback Machine via cdx_toolkit
    html: bytes | None = None
    fetch_err: str | None = None

    if http_code not in (0, 200):
        fetch_err = "http_error"
    else:
        try:
            cdx = cdx_toolkit.CDXFetcher(source="ia")
            for obj in cdx.iter(url, limit=1):
                html = obj.content
                break
            if html is None:
                fetch_err = "not_found"
        except Exception:
            fetch_err = "fetch_error"

    if html is None:
        update(fetch_err or "not_found")
        return f"[{fetch_err or 'not_found'}] {url}"

    text, meta = extract_text_and_meta(html, url)

    if text and len(text) >= MIN_LENGTH:
        fn = save_file(text, meta, html)
        update("saved", fn, len(text))
        return f"[saved] {fn} ({len(text):,})"

    if text:
        fn = save_file(text, meta, html)
        update("too_short", fn, len(text))
        return f"[too_short] {fn} ({len(text):,})"

    update("no_text")
    return f"[no_text] {url}"


def cmd_download(args: argparse.Namespace) -> None:
    db = open_db()
    db_lock = threading.Lock()

    limit_clause = f" LIMIT {args.limit}" if args.limit else ""
    if args.retry:
        rows = db.execute(
            f"SELECT url, run_id, site, http_code FROM pages WHERE download_status=?{limit_clause}",
            (args.retry,),
        ).fetchall()
    else:
        rows = db.execute(
            f"SELECT url, run_id, site, http_code FROM pages WHERE download_status IS NULL{limit_clause}"
        ).fetchall()

    if args.dry_run:
        print(f"Pending: {len(rows):,} URLs")
        db.close()
        return

    CORPUS_DIR.mkdir(exist_ok=True)
    HTML_DIR.mkdir(exist_ok=True)
    total = len(rows)
    done = 0
    print(f"Downloading {total:,} URLs ({args.workers} workers)...")

    with ThreadPoolExecutor(max_workers=args.workers) as pool:
        futures = {pool.submit(process_page, row, db, db_lock): row["url"] for row in rows}
        for future in as_completed(futures):
            done += 1
            try:
                result = future.result()
                print(f"  [{done}/{total}] {result}")
            except Exception as e:
                print(f"  [{done}/{total}] ERROR {futures[future]}: {e}")

    db.close()
    print(f"\nDone. {done:,} URLs processed.")


# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------

def main() -> None:
    parser = argparse.ArgumentParser(prog="fetch.py", description="MTG corpus fetcher")
    sub = parser.add_subparsers(dest="command", required=True)

    disc = sub.add_parser("discover", help="Enumerate URLs from IA CDX into state.db")
    disc.add_argument("--from-year", type=int, dest="from_year", help="Only captures from this year onwards")
    disc.add_argument("--to-year", type=int, dest="to_year", help="Only captures up to end of this year")
    disc.add_argument("--dry-run", action="store_true")

    dl = sub.add_parser("download", help="Fetch content for pending URLs from Wayback Machine")
    dl.add_argument("--workers", type=int, default=8)
    dl.add_argument("--limit", type=int)
    dl.add_argument("--retry", metavar="STATUS")
    dl.add_argument("--dry-run", action="store_true")

    args = parser.parse_args()
    {"discover": cmd_discover, "download": cmd_download}[args.command](args)


if __name__ == "__main__":
    main()