"""Process one IMPACT year: download, enrich, embed, push to HF Hub.

Runs on Modal GPU — no local disk used. Each year is ~4-5GB of images,
~2GB of text. Modal ephemeral storage handles it; everything is deleted
when the job exits.

Pipeline per year:
  1. Download IMPACT year.zip + CSV from HF (images + metadata)
  2. Download PatentsView text TSVs from S3 (draw_desc, detail_desc, patent meta)
  3. Extract text TSVs with 7za (handles deflate64)
  4. Join: IMPACT metadata × PatentsView text → enriched parquet
  5. Run CLIP ViT-L/14 on GPU → embeddings parquet
  6. Push both parquets to midah/patent-wireframes on HF Hub
  7. Exit — ephemeral storage is cleared automatically

Safety:
  - Idempotent: checks HF Hub before downloading anything
  - One year at a time — run sequentially to verify, then parallelize
  - Never touches local machine disk

Setup (one-time on any networked machine):
    pip install modal
    modal setup
    modal secret create hf-secret HF_TOKEN=hf_...

Run one year (verify first):
    modal run scripts/cloud/process_year_modal.py --year 2021

Run all years sequentially:
    for year in 2022 2021 2020 2019 2018 2017 2016 2015 2014 2013 2012 2011 2010 2009 2008 2007; do
        modal run scripts/cloud/process_year_modal.py --year $year
    done

Run all years in parallel (after verifying one year works):
    modal run scripts/cloud/process_year_modal.py --all-years
"""

import io
import os
import re
import subprocess
from pathlib import Path

import modal

# ── Modal image ───────────────────────────────────────────────────────────────

image = (
    modal.Image.debian_slim(python_version="3.11")
    .apt_install("p7zip-full")        # for deflate64 extraction
    .pip_install(
        "open_clip_torch",
        "huggingface_hub>=0.23",
        "datasets",
        "Pillow",
        "pandas",
        "numpy",
        "tqdm",
        "requests",
    )
)

app = modal.App("patent-process-year", image=image)
hf_secret = modal.Secret.from_name("hf-secret")

PATENTSVIEW_URLS = {
    "draw_desc":   "https://s3.amazonaws.com/data.patentsview.org/draw-description-text/g_draw_desc_text_{year}.tsv.zip",
    "detail_desc": "https://s3.amazonaws.com/data.patentsview.org/detail-description-text/g_detail_desc_text_{year}.tsv.zip",
    "brf_sum":     "https://s3.amazonaws.com/data.patentsview.org/brief-summary-text/g_brf_sum_text_{year}.tsv.zip",
    "claims":      "https://s3.amazonaws.com/data.patentsview.org/claims/g_claims_{year}.tsv.zip",
}
PATENT_META_URL = "https://s3.amazonaws.com/data.patentsview.org/download/g_patent.tsv.zip"

HF_REPO = "midah/patent-wireframes"
BATCH_SIZE = 64


# ── helpers ───────────────────────────────────────────────────────────────────

def already_on_hub(year: int, token: str) -> bool:
    """Check if this year's outputs are already on HF Hub."""
    from huggingface_hub import list_repo_files
    files = set(list_repo_files(HF_REPO, repo_type="dataset", token=token))
    enriched = f"data/enriched_{year}.parquet"
    embeddings = f"embeddings/embeddings_{year}_vitl14.parquet"
    if enriched in files and embeddings in files:
        print(f"Year {year}: already on Hub, skipping.")
        return True
    return False


def download_file(url: str, dest: Path, chunk_size: int = 8 * 1024 * 1024) -> Path:
    import requests
    print(f"  Downloading {url.split('/')[-1]}...")
    r = requests.get(url, stream=True, timeout=120)
    r.raise_for_status()
    with open(dest, "wb") as f:
        for chunk in r.iter_content(chunk_size=chunk_size):
            f.write(chunk)
    size_mb = dest.stat().st_size / 1e6
    print(f"  → {dest.name} ({size_mb:.0f}MB)")
    return dest


def extract_zip(zip_path: Path, out_dir: Path) -> Path | None:
    """Extract using 7za (handles deflate64 that Python zipfile can't)."""
    out_dir.mkdir(parents=True, exist_ok=True)
    result = subprocess.run(
        ["7za", "x", str(zip_path), f"-o{out_dir}", "-y"],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        print(f"  7za error: {result.stderr[:200]}")
        return None
    tsv_files = list(out_dir.glob("*.tsv"))
    if tsv_files:
        print(f"  Extracted: {tsv_files[0].name} ({tsv_files[0].stat().st_size/1e6:.0f}MB)")
        return tsv_files[0]
    return None


# ── core processing ───────────────────────────────────────────────────────────

@app.function(
    gpu="A10G",
    timeout=7200,           # 2 hours max per year
    memory=32768,           # 32GB RAM
    ephemeral_disk=51200,   # 50GB ephemeral disk
    secrets=[hf_secret],
)
def process_year(year: int) -> dict:
    import ast
    import csv
    import zipfile

    import numpy as np
    import open_clip
    import pandas as pd
    import torch
    from huggingface_hub import HfApi, hf_hub_download
    from PIL import Image
    from tqdm import tqdm

    token = os.environ["HF_TOKEN"]
    api = HfApi(token=token)
    work = Path(f"/tmp/patent_{year}")
    work.mkdir(exist_ok=True)

    print(f"\n{'='*50}")
    print(f"Processing year {year}")
    print(f"{'='*50}")

    # ── 0. Idempotency check ─────────────────────────────────────────────────
    if already_on_hub(year, token):
        return {"year": year, "status": "skipped"}

    # ── 1. Download IMPACT metadata CSV ─────────────────────────────────────
    print("\n[1/5] IMPACT metadata...")
    csv_path = hf_hub_download(
        repo_id="AI4Patents/IMPACT", filename=f"{year}.csv",
        repo_type="dataset", token=token, local_dir=str(work)
    )
    impact_df = pd.read_csv(csv_path)
    print(f"  {len(impact_df):,} patents")

    # Explode to figure level
    rows = []
    for _, row in impact_df.iterrows():
        try:
            fnames = ast.literal_eval(str(row["file_names"]))
            fig_descs = ast.literal_eval(str(row["fig_desc"])) if pd.notna(row.get("fig_desc")) else []
        except Exception:
            continue
        for i, fname in enumerate(fnames):
            rows.append({
                "patent_id": "D" + str(row["id"]).replace("D","").lstrip("0").zfill(7),
                "figure_number": i,
                "image_filename": fname,
                "patent_title": row.get("title",""),
                "caption": row.get("caption",""),
                "class": row.get("class",""),
                "year": year,
            })
    df = pd.DataFrame(rows)
    print(f"  Exploded to {len(df):,} figures")

    # ── 2. Download PatentsView text TSVs ────────────────────────────────────
    print("\n[2/5] PatentsView text tables...")
    pv_dir = work / "patentsview"
    pv_dir.mkdir(exist_ok=True)

    text_dfs = {}
    for table, url_template in PATENTSVIEW_URLS.items():
        url = url_template.format(year=year)
        zip_path = pv_dir / url.split("/")[-1]
        try:
            download_file(url, zip_path)
            tsv_path = extract_zip(zip_path, pv_dir / table)
            if tsv_path:
                tdf = pd.read_csv(tsv_path, sep="\t", dtype=str, low_memory=False)
                tdf["patent_id"] = tdf["patent_id"].apply(
                    lambda x: "D" + str(x).replace("D","").lstrip("0").zfill(7)
                )
                text_dfs[table] = tdf
                zip_path.unlink()  # free space immediately
        except Exception as e:
            print(f"  {table}: skipped ({e})")

    # Patent metadata (year-independent, check if already fetched)
    meta_path = pv_dir / "g_patent.tsv"
    if not meta_path.exists():
        try:
            zip_path = pv_dir / "g_patent.tsv.zip"
            download_file(PATENT_META_URL, zip_path)
            extract_zip(zip_path, pv_dir)
            zip_path.unlink()
        except Exception as e:
            print(f"  patent meta: skipped ({e})")

    # ── 3. Join ──────────────────────────────────────────────────────────────
    print("\n[3/5] Joining text tables...")
    col_map = {
        "draw_desc":   ("draw_desc_text",   "drawing_description"),
        "detail_desc": ("detail_desc_text",  "detailed_description"),
        "brf_sum":     ("brf_sum_text",      "brief_summary"),
        "claims":      ("claims_text",        "claims"),
    }
    for table, (src_col, dst_col) in col_map.items():
        tdf = text_dfs.get(table, pd.DataFrame())
        if not tdf.empty and src_col in tdf.columns:
            agg = (tdf.groupby("patent_id")[src_col]
                   .apply(lambda x: "\n".join(x.dropna().astype(str)))
                   .reset_index().rename(columns={src_col: dst_col}))
            df = df.merge(agg, on="patent_id", how="left")
            df[dst_col] = df[dst_col].fillna("")
        else:
            df[dst_col] = ""
        filled = (df[dst_col] != "").sum()
        print(f"  {dst_col}: {filled:,}/{len(df):,} filled")

    # Merge patent metadata
    meta_path = pv_dir / "g_patent.tsv"
    if meta_path.exists():
        meta = pd.read_csv(meta_path, sep="\t", dtype=str, low_memory=False)
        meta["patent_id"] = meta["patent_id"].apply(
            lambda x: "D" + str(x).replace("D","").lstrip("0").zfill(7)
        )
        for col in ["patent_date", "patent_type"]:
            if col in meta.columns:
                df = df.merge(meta[["patent_id", col]].drop_duplicates("patent_id"),
                              on="patent_id", how="left")

    # Figure ID + siblings
    df["figure_id"] = df["patent_id"] + "_" + df["figure_number"].astype(str)
    patent_groups = df.groupby("patent_id")["figure_id"].apply(list).to_dict()
    df["n_figures_in_patent"] = df["patent_id"].map(df.groupby("patent_id").size())
    df["sibling_figure_ids"] = df.apply(
        lambda r: [f for f in patent_groups[r["patent_id"]] if f != r["figure_id"]],
        axis=1
    )

    # ── 4. CLIP embeddings ───────────────────────────────────────────────────
    print("\n[4/5] CLIP embeddings...")
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"  Device: {device}")

    model, _, preprocess = open_clip.create_model_and_transforms(
        "ViT-L-14", pretrained="openai"
    )
    model = model.to(device).eval()

    # Download IMPACT zip
    print("  Downloading IMPACT images (~4-5GB)...")
    zip_path = hf_hub_download(
        repo_id="AI4Patents/IMPACT", filename=f"{year}.zip",
        repo_type="dataset", token=token, local_dir=str(work)
    )
    print(f"  Zip: {Path(zip_path).stat().st_size/1e9:.1f}GB")

    all_ids, all_vecs = [], []

    def load_image(fname: str) -> Image.Image | None:
        parts = fname.split("-D0")
        if len(parts) < 2:
            return None
        inner = f"{year}/{parts[0]}/{fname}"
        try:
            with zipfile.ZipFile(zip_path) as z:
                with z.open(inner) as f:
                    return Image.open(io.BytesIO(f.read())).convert("RGB")
        except Exception:
            return None

    batch_imgs, batch_ids = [], []

    def flush():
        if not batch_imgs:
            return
        tensors = torch.stack([preprocess(im) for im in batch_imgs]).to(device)
        with torch.no_grad():
            feats = model.encode_image(tensors)
            feats = feats / feats.norm(dim=-1, keepdim=True)
        all_vecs.append(feats.cpu().numpy())
        all_ids.extend(batch_ids)
        batch_imgs.clear()
        batch_ids.clear()

    for _, row in tqdm(df.iterrows(), total=len(df), desc="  Embedding"):
        img = load_image(row["image_filename"])
        if img is None:
            continue
        batch_imgs.append(img)
        batch_ids.append(row["figure_id"])
        if len(batch_imgs) >= BATCH_SIZE:
            flush()
    flush()

    vecs = np.vstack(all_vecs).astype(np.float32)
    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
    vecs /= np.maximum(norms, 1e-8)
    print(f"  Embedded {len(all_ids):,} figures, shape {vecs.shape}")

    emb_df = pd.DataFrame({"figure_id": all_ids, "embedding": list(vecs)})

    # ── 5. Push to Hub ───────────────────────────────────────────────────────
    print("\n[5/5] Pushing to HF Hub...")

    enriched_path = work / f"enriched_{year}.parquet"
    df.to_parquet(enriched_path, index=False)
    api.upload_file(
        path_or_fileobj=str(enriched_path),
        path_in_repo=f"data/enriched_{year}.parquet",
        repo_id=HF_REPO, repo_type="dataset",
        commit_message=f"Add enriched_{year}.parquet ({len(df):,} figures)"
    )
    print(f"  Pushed data/enriched_{year}.parquet")

    emb_path = work / f"embeddings_{year}_vitl14.parquet"
    emb_df.to_parquet(emb_path, index=False)
    api.upload_file(
        path_or_fileobj=str(emb_path),
        path_in_repo=f"embeddings/embeddings_{year}_vitl14.parquet",
        repo_id=HF_REPO, repo_type="dataset",
        commit_message=f"Add embeddings_{year}_vitl14.parquet"
    )
    print(f"  Pushed embeddings/embeddings_{year}_vitl14.parquet")

    return {
        "year": year,
        "status": "done",
        "n_figures": len(df),
        "n_embedded": len(all_ids),
    }


# ── entrypoints ───────────────────────────────────────────────────────────────

@app.local_entrypoint()
def main(year: int = 2021, all_years: bool = False):
    """
    Test with one year first:
        modal run scripts/cloud/process_year_modal.py --year 2021

    Then run all years:
        modal run scripts/cloud/process_year_modal.py --all-years
    """
    if all_years:
        years = list(range(2007, 2023))  # 2007–2022
        print(f"Processing all {len(years)} years: {years}")
        # Sequential for safety — can switch to .map() after verifying one year
        for y in years:
            result = process_year.remote(y)
            print(f"Year {y}: {result}")
    else:
        print(f"Processing year {year} (test run)...")
        result = process_year.remote(year)
        print(f"Result: {result}")