#!/usr/bin/env python3


from __future__ import annotations

import argparse
import importlib.util
import json
import os
import random
import shutil
import time
import urllib.error
import urllib.request
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any, Dict, Iterable, List, Optional, Tuple


REPO = Path(__file__).resolve().parents[1]
QA_SCRIPT = REPO / "scripts" / "run_gpt4o_visual_qa.py"
DIFFICULTIES = ("simple", "medium", "difficult")
SPLITS = ("train", "test")


def load_qa_module():
    spec = importlib.util.spec_from_file_location("visual_qa", QA_SCRIPT)
    if spec is None or spec.loader is None:
        raise RuntimeError(f"Could not load {QA_SCRIPT}")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


QA = load_qa_module()


DIFFICULT_EXTRA_PROMPT = """

Additional note for difficult samples:
- This sample is intentionally difficult. Be more tolerant of density, crossings, long routes, small but legible text, and local clutter.
- Still FAIL if the image is genuinely unusable or the graph structure is ambiguous.
- The final selection still requires overall PASS; do not mark a bad image as PASS.
"""


def sample_key(row: Dict[str, Any]) -> str:
    value = row.get("unified_sample_id") or row.get("sample_id")
    if not value:
        raise ValueError(f"Missing sample id in row: {row}")
    return str(value)


def read_jsonl(path: Path) -> List[Dict[str, Any]]:
    rows: List[Dict[str, Any]] = []
    if not path.exists():
        return rows
    with path.open("r", encoding="utf-8") as handle:
        for line in handle:
            if line.strip():
                rows.append(json.loads(line))
    return rows


def write_jsonl(path: Path, rows: Iterable[Dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        for row in rows:
            handle.write(json.dumps(row, ensure_ascii=False) + "\n")


def load_manifest(dataset_root: Path, manifest_path: Optional[Path]) -> List[Dict[str, Any]]:
    path = manifest_path or dataset_root / "manifest.jsonl"
    rows: List[Dict[str, Any]] = []
    for row in read_jsonl(path):
        row = dict(row)
        row["unified_sample_id"] = sample_key(row)
        row["image_path"] = str(dataset_root / row["image"])
        rows.append(row)
    return rows


def allocate_targets(counts: Dict[str, int], total_target: int) -> Dict[str, int]:
    total_source = sum(counts.values())
    if total_source <= 0:
        return {difficulty: 0 for difficulty in DIFFICULTIES}
    raw: Dict[str, float] = {
        difficulty: total_target * counts.get(difficulty, 0) / total_source
        for difficulty in DIFFICULTIES
    }
    targets = {difficulty: int(raw[difficulty]) for difficulty in DIFFICULTIES}
    remaining = total_target - sum(targets.values())
    order = sorted(DIFFICULTIES, key=lambda difficulty: (raw[difficulty] - targets[difficulty], difficulty), reverse=True)
    for difficulty in order[:remaining]:
        targets[difficulty] += 1
    return targets


def compute_targets(rows: List[Dict[str, Any]], target_train: int, target_test: int) -> Dict[Tuple[str, str, str], int]:
    source = Counter((row["domain"], row["split"], row["difficulty"]) for row in rows)
    domains = sorted({str(row["domain"]) for row in rows})
    targets: Dict[Tuple[str, str, str], int] = {}
    for domain in domains:
        for split, total_target in (("train", target_train), ("test", target_test)):
            diff_counts = {difficulty: source[(domain, split, difficulty)] for difficulty in DIFFICULTIES}
            for difficulty, count in allocate_targets(diff_counts, total_target).items():
                targets[(domain, split, difficulty)] = count
    return targets


def call_visual_qa(
    base_url: str,
    api_key: str,
    model: str,
    image_path: Path,
    difficulty: str,
    max_tokens: int,
    timeout: int,
) -> str:
    prompt = QA.VISUAL_QA_PROMPT
    if difficulty == "difficult":
        prompt += DIFFICULT_EXTRA_PROMPT
    payload = {
        "model": model,
        "messages": [
            {"role": "system", "content": "You are a strict but practical visual QA reviewer."},
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {"type": "image_url", "image_url": {"url": QA.image_data_url(image_path)}},
                ],
            },
        ],
        "temperature": 0,
        "max_tokens": max_tokens,
    }
    request = urllib.request.Request(
        base_url.rstrip("/") + "/chat/completions",
        data=json.dumps(payload).encode("utf-8"),
        headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
        method="POST",
    )
    try:
        with urllib.request.urlopen(request, timeout=timeout) as response:
            body = json.loads(response.read().decode("utf-8"))
    except urllib.error.HTTPError as exc:
        detail = exc.read().decode("utf-8", errors="replace")
        raise RuntimeError(f"HTTP {exc.code}: {detail[:2000]}") from exc
    return body["choices"][0]["message"]["content"]


def result_passed(record: Dict[str, Any]) -> bool:
    result = record.get("result") if isinstance(record.get("result"), dict) else {}
    return record.get("status") == "OK" and result.get("overall") == "PASS"


def link_or_copy(src: Path, dst: Path) -> None:
    dst.parent.mkdir(parents=True, exist_ok=True)
    if dst.exists():
        dst.unlink()
    try:
        os.link(src, dst)
    except OSError:
        shutil.copy2(src, dst)


def summarize_progress(
    targets: Dict[Tuple[str, str, str], int],
    selected: Dict[str, Dict[str, Any]],
    reviewed: Dict[str, Dict[str, Any]],
) -> Dict[str, Any]:
    selected_counts = Counter()
    reviewed_counts = Counter()
    failed_counts = Counter()
    for row in selected.values():
        selected_counts[(row["domain"], row["split"], row["difficulty"])] += 1
    for row in reviewed.values():
        key = (row.get("domain"), row.get("split"), row.get("difficulty"))
        reviewed_counts[key] += 1
        if not result_passed(row):
            failed_counts[key] += 1
    groups: Dict[str, Dict[str, int]] = {}
    complete = True
    for key, target in sorted(targets.items()):
        selected_count = selected_counts[key]
        reviewed_count = reviewed_counts[key]
        if selected_count < target:
            complete = False
        groups["/".join(key)] = {
            "target": target,
            "selected": selected_count,
            "reviewed": reviewed_count,
            "failed_or_error": failed_counts[key],
            "remaining": max(0, target - selected_count),
        }
    return {
        "complete": complete,
        "selected_total": len(selected),
        "reviewed_total": len(reviewed),
        "failed_or_error_total": sum(1 for row in reviewed.values() if not result_passed(row)),
        "groups": groups,
    }


def write_outputs(
    dataset_root: Path,
    out_dir: Path,
    selected: Dict[str, Dict[str, Any]],
    reviewed: Dict[str, Dict[str, Any]],
    targets: Dict[Tuple[str, str, str], int],
) -> None:
    selected_rows = [row["manifest_row"] for row in sorted(selected.values(), key=lambda item: sample_key(item["manifest_row"]))]
    rejected_rows = [row for row in sorted(reviewed.values(), key=sample_key) if not result_passed(row)]
    write_jsonl(out_dir / "selected_manifest.jsonl", selected_rows)
    write_jsonl(out_dir / "rejected.jsonl", rejected_rows)
    (out_dir / "screening_state.json").write_text(
        json.dumps(summarize_progress(targets, selected, reviewed), ensure_ascii=False, indent=2),
        encoding="utf-8",
    )
    selected_root = out_dir / "selected_dataset"
    for row in selected_rows:
        image_rel = Path(row["image"])
        ann_rel = Path(row["annotation"])
        link_or_copy(dataset_root / image_rel, selected_root / image_rel)
        link_or_copy(dataset_root / ann_rel, selected_root / ann_rel)
    write_jsonl(selected_root / "manifest.jsonl", selected_rows)


def choose_next_group(
    targets: Dict[Tuple[str, str, str], int],
    selected_counts: Counter,
    available: Dict[Tuple[str, str, str], List[Dict[str, Any]]],
    rng: random.Random,
) -> Optional[Tuple[str, str, str]]:
    pending = [
        key
        for key, target in targets.items()
        if selected_counts[key] < target and available.get(key)
    ]
    if not pending:
        return None
    weights = [max(1, targets[key] - selected_counts[key]) for key in pending]
    return rng.choices(pending, weights=weights, k=1)[0]


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", type=Path, default=Path("api_config.yaml"))
    parser.add_argument("--dataset-root", type=Path, default=Path("outputs/final-before-screen-data"))
    parser.add_argument("--manifest", type=Path, default=None)
    parser.add_argument("--output-dir", type=Path, default=Path("outputs/final-before-screen-balanced-screening"))
    parser.add_argument("--cache-dir", type=Path, default=Path("outputs/gpt4o_visual_qa/final_before_screen_balanced_cache"))
    parser.add_argument("--model", default="gpt-4o")
    parser.add_argument("--target-train", type=int, default=3000)
    parser.add_argument("--target-test", type=int, default=200)
    parser.add_argument("--seed", type=int, default=20260610)
    parser.add_argument("--max-tokens", type=int, default=700)
    parser.add_argument("--timeout", type=int, default=120)
    parser.add_argument("--sleep", type=float, default=0.1)
    parser.add_argument("--report-every", type=int, default=100)
    parser.add_argument("--max-reviews", type=int, default=0, help="Stop after this many new reviews. Use 0 for unlimited.")
    parser.add_argument("--max-api-errors", type=int, default=5)
    parser.add_argument("--dry-run", action="store_true")
    args = parser.parse_args()

    rows = load_manifest(args.dataset_root, args.manifest)
    targets = compute_targets(rows, args.target_train, args.target_test)

    groups: Dict[Tuple[str, str, str], List[Dict[str, Any]]] = defaultdict(list)
    for row in rows:
        groups[(row["domain"], row["split"], row["difficulty"])].append(row)

    rng = random.Random(args.seed)
    for key, group_rows in groups.items():
        rng.shuffle(group_rows)

    args.output_dir.mkdir(parents=True, exist_ok=True)
    results_path = args.output_dir / "screening_results.jsonl"
    raw_dir = args.output_dir / "raw"
    raw_dir.mkdir(parents=True, exist_ok=True)
    args.cache_dir.mkdir(parents=True, exist_ok=True)

    reviewed: Dict[str, Dict[str, Any]] = {sample_key(row): row for row in read_jsonl(results_path)}
    selected: Dict[str, Dict[str, Any]] = {}
    for record in reviewed.values():
        if result_passed(record):
            manifest_row = record.get("manifest_row")
            if isinstance(manifest_row, dict):
                selected[sample_key(manifest_row)] = record

    selected_counts = Counter()
    for record in selected.values():
        row = record["manifest_row"]
        selected_counts[(row["domain"], row["split"], row["difficulty"])] += 1

    available: Dict[Tuple[str, str, str], List[Dict[str, Any]]] = {}
    for key, group_rows in groups.items():
        available[key] = [row for row in group_rows if sample_key(row) not in reviewed]

    target_report = {
        "/".join(key): {
            "target": target,
            "source_candidates": len(groups.get(key, [])),
        }
        for key, target in sorted(targets.items())
    }
    print(json.dumps({"targets": target_report}, ensure_ascii=False, indent=2), flush=True)
    if args.dry_run:
        return 0

    cfg = QA.parse_simple_yaml(args.config)
    api_cfg = cfg.get("api") or cfg
    api_key = api_cfg.get("key") or cfg.get("key")
    base_url = api_cfg.get("base") or cfg.get("base")
    if not api_key or not base_url:
        raise ValueError("Could not find api.key and api.base in config")

    new_reviews = 0
    transient_error_samples: set[str] = set()
    consecutive_api_errors = 0
    api_error_path = args.output_dir / "api_errors.jsonl"
    with results_path.open("a", encoding="utf-8") as out, api_error_path.open("a", encoding="utf-8") as api_error_out:
        while True:
            filtered_available = {
                group_key: [row for row in group_rows if sample_key(row) not in transient_error_samples]
                for group_key, group_rows in available.items()
            }
            key = choose_next_group(targets, selected_counts, filtered_available, rng)
            if key is None:
                break
            domain, split, difficulty = key
            while available[key]:
                sample = available[key].pop()
                if sample_key(sample) not in transient_error_samples:
                    break
            else:
                continue
            sample_id = sample_key(sample)
            image_path = Path(sample["image_path"])
            image_hash = QA.image_sha256(image_path)
            cache_path = args.cache_dir / f"{sample_id}.json"
            record: Dict[str, Any]
            used_cache = False

            if cache_path.exists():
                cached = json.loads(cache_path.read_text(encoding="utf-8"))
                if cached.get("image_sha256") == image_hash:
                    record = cached
                    used_cache = True
                    print(f"[cache] {sample_id} {domain}/{split}/{difficulty}", flush=True)
                else:
                    cache_path.unlink()
                    record = {}
            else:
                record = {}

            if not record:
                print(
                    f"[review] {sample_id} {domain}/{split}/{difficulty} "
                    f"need={targets[key] - selected_counts[key]}",
                    flush=True,
                )
                raw_text = ""
                parse_error = None
                warnings: List[str] = []
                try:
                    raw_text = call_visual_qa(
                        str(base_url),
                        str(api_key),
                        args.model,
                        image_path,
                        difficulty,
                        args.max_tokens,
                        args.timeout,
                    )
                    (raw_dir / f"{sample_id}.raw.txt").write_text(raw_text, encoding="utf-8")
                    obj, parse_error = QA.extract_json_object(raw_text)
                    if obj is None:
                        status = "PARSE_ERROR"
                        result = {
                            "overall": "FAIL",
                            "checks": {name: "FAIL" for name in QA.CHECK_NAMES},
                            "failure_reasons": [str(parse_error)],
                            "quality_score": 1,
                        }
                    else:
                        status = "OK"
                        result, warnings = QA.normalize_result(obj)
                except Exception as exc:
                    parse_error = f"api_error:{exc}"
                    error_record = {
                        "unified_sample_id": sample_id,
                        "sample_id": sample.get("sample_id", sample_id),
                        "source_sample_id": sample.get("source_sample_id"),
                        "domain": domain,
                        "difficulty": difficulty,
                        "split": split,
                        "image": sample.get("image"),
                        "annotation": sample.get("annotation"),
                        "image_sha256": image_hash,
                        "manifest_row": {k: v for k, v in sample.items() if k != "image_path"},
                        "status": "API_ERROR",
                        "parse_error": parse_error,
                    }
                    api_error_out.write(json.dumps(error_record, ensure_ascii=False) + "\n")
                    api_error_out.flush()
                    transient_error_samples.add(sample_id)
                    consecutive_api_errors += 1
                    print(f"  API_ERROR {parse_error}", flush=True)
                    if consecutive_api_errors >= args.max_api_errors:
                        raise RuntimeError(f"Stopped after {consecutive_api_errors} consecutive API errors")
                    continue

                record = {
                    "unified_sample_id": sample_id,
                    "sample_id": sample.get("sample_id", sample_id),
                    "source_sample_id": sample.get("source_sample_id"),
                    "domain": domain,
                    "difficulty": difficulty,
                    "split": split,
                    "image": sample.get("image"),
                    "annotation": sample.get("annotation"),
                    "image_sha256": image_hash,
                    "manifest_row": {k: v for k, v in sample.items() if k != "image_path"},
                    "result": result,
                    "status": status,
                    "parse_error": parse_error,
                    "normalization_warnings": warnings,
                }
                cache_path.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
                new_reviews += 1
                consecutive_api_errors = 0

            reviewed[sample_id] = record
            out.write(json.dumps(record, ensure_ascii=False) + "\n")
            out.flush()
            if result_passed(record):
                selected[sample_id] = record
                selected_counts[key] += 1
                print(f"  PASS selected={selected_counts[key]}/{targets[key]}", flush=True)
            else:
                result = record.get("result") or {}
                reasons = "; ".join(result.get("failure_reasons") or []) or record.get("parse_error") or "-"
                print(f"  FAIL/ERROR reasons={reasons}", flush=True)

            if args.report_every and len(reviewed) % args.report_every == 0:
                summary = summarize_progress(targets, selected, reviewed)
                print(json.dumps({k: summary[k] for k in ("selected_total", "reviewed_total", "failed_or_error_total", "complete")}, ensure_ascii=False), flush=True)
                write_outputs(args.dataset_root, args.output_dir, selected, reviewed, targets)
            if args.max_reviews and new_reviews >= args.max_reviews:
                break
            if args.sleep and not used_cache:
                time.sleep(args.sleep)

    write_outputs(args.dataset_root, args.output_dir, selected, reviewed, targets)
    summary = summarize_progress(targets, selected, reviewed)
    print(json.dumps(summary, ensure_ascii=False, indent=2), flush=True)
    return 0 if summary["complete"] else 2


if __name__ == "__main__":
    raise SystemExit(main())