from __future__ import annotations

import argparse
import copy
from pathlib import Path
from typing import Any

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np

from prefix.data import load_harmbench, load_llm_lat, load_mmlu_pro, mmlu_exp2_subset
from prefix.judge import GeminiJudge, JudgeBlocked, judge_batch
from prefix.notify import notify_on_exit
from prefix.runner import (
    CaptureSink,
    DirectionRecord,
    SteeringSpec,
    append_jsonl,
    build_dim_directions,
    chat_prompt,
    completed_ids,
    condition_id,
    get_engine,
    load_config,
    load_directions,
    mmlu_prompt,
    parse_answer_letter,
    read_jsonl,
    require_complete,
    save_directions,
    steered_generate,
    tee_stdout,
    verify_manifest,
    write_json_atomic,
    write_manifest,
)
from prefix.steering import SteeringSchedule

CHECKPOINTS = Path("checkpoints")
FIGS = Path("figs")


def apply_limit(config: dict[str, Any], limit: int | None) -> dict[str, Any]:
    result = copy.deepcopy(config)
    if limit is not None and limit <= 8:
        result["steering"]["alphas"] = list(result["steering"]["alphas"])[:3]
        if "mmlu" in result:
            result["mmlu"]["n"] = min(int(result["mmlu"]["n"]), limit)
    return result


def direction_phase(config: dict[str, Any]) -> dict[int, DirectionRecord]:
    CHECKPOINTS.mkdir(parents=True, exist_ok=True)
    direction_path = CHECKPOINTS / "exp2_direction.json"
    manifest_path = CHECKPOINTS / "exp2_manifest.json"
    if direction_path.exists():
        verify_manifest(manifest_path, config)
        return load_directions(direction_path)
    model = config["model"]
    llm = get_engine(
        model["id"],
        max_model_len=model.get("max_model_len"),
        gpu_memory_utilization=float(model.get("gpu_memory_utilization", 0.9)),
    )
    direction = (
        config["direction"]
        if "direction" in config
        else {
            "pos_dataset": "LLM-LAT/benign-dataset",
            "neg_dataset": "LLM-LAT/harmful-dataset",
            "n_per_class": 100,
        }
    )
    pos = load_llm_lat(str(direction["pos_dataset"]), int(direction["n_per_class"]))
    neg = load_llm_lat(str(direction["neg_dataset"]), int(direction["n_per_class"]))
    records = build_dim_directions(llm, pos, neg, [int(model["layer"])])
    save_directions(direction_path, records)
    write_manifest(manifest_path, config)
    return records


def _tokenizer(llm: Any) -> Any:
    return llm.get_tokenizer() if hasattr(llm, "get_tokenizer") else None


def _condition_file(checkpoint_dir: Path, prefix: str, cond: str) -> Path:
    return checkpoint_dir / f"exp2_{prefix}_{cond.replace('/', '_')}.jsonl"


def _spec(alpha: float, direction: DirectionRecord, layer: int) -> SteeringSpec | None:
    if alpha == 0.0:
        return None
    return SteeringSpec(
        layer, direction.direction, alpha, direction.mean_norm, SteeringSchedule.full()
    )


def generate_harmbench(
    llm: Any,
    config: dict[str, Any],
    records: list[dict[str, Any]],
    alphas: list[float],
    direction: DirectionRecord,
    checkpoint_dir: Path,
    batch_prompts: int,
) -> None:
    tokenizer = _tokenizer(llm)
    layer = int(config["model"]["layer"])
    checkpoint_dir.mkdir(parents=True, exist_ok=True)
    expected = [str(index) for index in range(len(records))]
    for alpha in alphas:
        cond = condition_id("exp2", "hb", float(alpha))
        path = _condition_file(checkpoint_dir, "hb", cond)
        pending = sorted(set(expected) - completed_ids(path))
        while pending:
            chunk = pending[:batch_prompts]
            prompts = [
                chat_prompt(tokenizer, str(records[int(index)]["behavior"]), False)
                for index in chunk
            ]
            outputs = steered_generate(
                llm,
                prompts,
                max_tokens=int(config["harmbench"]["max_new_tokens"]),
                spec=_spec(float(alpha), direction, layer),
                batch_prompts=batch_prompts,
            )
            append_jsonl(
                path,
                [
                    {"id": index, "text": output.text}
                    for index, output in zip(chunk, outputs)
                ],
            )
            print(
                f"generate hb alpha={alpha}: completed {len(chunk)} records", flush=True
            )
            pending = sorted(set(expected) - completed_ids(path))


def generate_mmlu(
    llm: Any,
    config: dict[str, Any],
    records: list[dict[str, Any]],
    alphas: list[float],
    direction: DirectionRecord,
    checkpoint_dir: Path,
    batch_prompts: int,
) -> None:
    tokenizer = _tokenizer(llm)
    layer = int(config["model"]["layer"])
    indices = mmlu_exp2_subset(
        int(config["mmlu"]["n"]), int(config["seed"]), n_total=len(records)
    )
    expected = [str(index) for index in indices]
    for alpha in alphas:
        cond = condition_id("exp2", "mmlu", float(alpha))
        path = _condition_file(checkpoint_dir, "mmlu", cond)
        pending = sorted(set(expected) - completed_ids(path))
        while pending:
            chunk = pending[:batch_prompts]
            prompts = [
                chat_prompt(
                    tokenizer,
                    mmlu_prompt(
                        str(records[int(index)]["question"]),
                        list(records[int(index)]["options"]),
                    ),
                    True,
                )
                for index in chunk
            ]
            outputs = steered_generate(
                llm,
                prompts,
                int(config["mmlu"]["max_new_tokens"]),
                _spec(float(alpha), direction, layer),
                batch_prompts=batch_prompts,
            )
            append_jsonl(
                path,
                [
                    {
                        "id": index,
                        "text": output.text,
                        "pred": parse_answer_letter(output.text),
                    }
                    for index, output in zip(chunk, outputs)
                ],
            )
            print(
                f"generate mmlu alpha={alpha}: completed {len(chunk)} records",
                flush=True,
            )
            pending = sorted(set(expected) - completed_ids(path))


def judge_harmbench(
    generation_dir: Path,
    judge_path: Path,
    records: list[dict[str, Any]],
    alphas: list[float],
    judge: Any,
) -> None:
    expected = [str(index) for index in range(len(records))]
    jobs: list[tuple[str, float, str, str]] = []
    for alpha in alphas:
        cond = condition_id("exp2", "hb", float(alpha))
        path = _condition_file(generation_dir, "hb", cond)
        require_complete(path, expected, label=f"generations {cond}")
        for row in read_jsonl(path):
            jobs.append(
                (f"{cond}/{row['id']}", float(alpha), str(row["id"]), str(row["text"]))
            )
    pending = [job for job in jobs if job[0] not in completed_ids(judge_path)]
    if pending:

        def one(job: tuple[str, float, str, str]) -> tuple[bool | None, bool]:
            try:
                return (
                    bool(
                        judge.judge_safety(
                            str(records[int(job[2])]["behavior"]), job[3]
                        )
                    ),
                    False,
                )
            except JudgeBlocked:
                return None, True
            except RuntimeError:
                return None, False

        for start in range(0, len(pending), 64):
            chunk = pending[start : start + 64]
            values = judge_batch(one, chunk)
            append_jsonl(
                judge_path,
                [
                    {
                        "id": job[0],
                        "alpha": job[1],
                        "i": int(job[2]),
                        "safe": safe,
                        "blocked": blocked,
                    }
                    for job, (safe, blocked) in zip(chunk, values)
                ],
            )
    require_complete(
        judge_path,
        [
            f"{condition_id('exp2', 'hb', float(alpha))}/{index}"
            for alpha in alphas
            for index in expected
        ],
        label="judge",
    )
    print(f"judge: completed {len(pending)} records", flush=True)


def analyze(
    config: dict[str, Any],
    generation_dir: Path,
    judge_path: Path,
    mmlu_records: list[dict[str, Any]],
    alphas: list[float],
    results_path: Path,
) -> dict[str, Any]:
    judge_rows = read_jsonl(judge_path)
    p_safe: dict[str, float] = {}
    blocked: dict[str, int] = {}
    for alpha in alphas:
        values = [
            bool(row["safe"])
            for row in judge_rows
            if float(row["alpha"]) == float(alpha) and row["safe"] is not None
        ]
        blocked[str(alpha)] = sum(
            1
            for row in judge_rows
            if float(row["alpha"]) == float(alpha) and row.get("blocked", False)
        )
        p_safe[str(alpha)] = float(np.mean(values)) if values else float("nan")
    blocked_total = sum(blocked.values())
    if blocked_total:
        print(
            f"analyze: warning, excluding {blocked_total} blocked judge records",
            flush=True,
        )
    indices = mmlu_exp2_subset(
        int(config["mmlu"]["n"]), int(config["seed"]), n_total=len(mmlu_records)
    )
    expected = [str(index) for index in indices]
    a_mmlu: dict[str, float] = {}
    for alpha in alphas:
        cond = condition_id("exp2", "mmlu", float(alpha))
        rows = read_jsonl(_condition_file(generation_dir, "mmlu", cond))
        require_complete(
            _condition_file(generation_dir, "mmlu", cond),
            expected,
            label=f"mmlu {cond}",
        )
        correct = [
            row.get("pred") == mmlu_records[int(row["id"])]["answer_letter"]
            for row in rows
        ]
        a_mmlu[str(alpha)] = float(np.mean(correct)) if correct else float("nan")
    result = {"alpha": alphas, "p_safe": p_safe, "a_mmlu": a_mmlu, "blocked": blocked}
    write_json_atomic(results_path, result)
    FIGS.mkdir(parents=True, exist_ok=True)
    x = np.asarray(alphas, dtype=float)
    plot_x = np.where(x == 0, np.finfo(float).tiny, x)
    plt.plot(
        plot_x, [p_safe[str(alpha)] for alpha in alphas], marker="o", label="P_safe"
    )
    plt.plot(
        plot_x, [a_mmlu[str(alpha)] for alpha in alphas], marker="o", label="A_MMLU"
    )
    plt.xscale("log")
    plt.xlabel("alpha")
    plt.legend()
    plt.tight_layout()
    plt.savefig(FIGS / "exp2_tradeoff.pdf")
    plt.close()
    return result


def main(argv: list[str] | None = None) -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", default="configs/exp2.yaml")
    parser.add_argument(
        "--phase",
        nargs="+",
        choices=["direction", "generate", "judge", "analyze", "all"],
        default=["all"],
    )
    parser.add_argument("--limit", type=int, default=None)
    parser.add_argument("--batch-prompts", type=int, default=256)
    args = parser.parse_args(argv)
    config = apply_limit(load_config(args.config), args.limit)
    phases = (
        ["direction", "generate", "judge", "analyze"]
        if "all" in args.phase
        else args.phase
    )
    with notify_on_exit("exp2", log_file="logs/exp2.log"):
        with tee_stdout("logs/exp2.log"):
            direction = (
                direction_phase(config)[int(config["model"]["layer"])]
                if "direction" in phases
                else None
            )
            alphas = [float(value) for value in config["steering"]["alphas"]]
            records = (
                load_harmbench()[: args.limit]
                if args.limit is not None
                else load_harmbench()
            )
            if "generate" in phases:
                if direction is None:
                    direction = load_directions(CHECKPOINTS / "exp2_direction.json")[
                        int(config["model"]["layer"])
                    ]
                llm = get_engine(
                    config["model"]["id"],
                    max_model_len=config["model"].get("max_model_len"),
                    gpu_memory_utilization=float(
                        config["model"].get("gpu_memory_utilization", 0.9)
                    ),
                )
                generate_harmbench(
                    llm,
                    config,
                    records,
                    alphas,
                    direction,
                    CHECKPOINTS,
                    args.batch_prompts,
                )
                mmlu_records = load_mmlu_pro(config["mmlu"]["source"])
                if args.limit is not None:
                    mmlu_records = mmlu_records[: args.limit]
                generate_mmlu(
                    llm,
                    config,
                    mmlu_records,
                    alphas,
                    direction,
                    CHECKPOINTS,
                    args.batch_prompts,
                )
            if "judge" in phases:
                judge_harmbench(
                    CHECKPOINTS,
                    CHECKPOINTS / "exp2_judge.jsonl",
                    records,
                    alphas,
                    GeminiJudge(
                        model=config["judge"]["model"], region=config["judge"]["region"]
                    ),
                )
            if "analyze" in phases:
                mmlu_records = load_mmlu_pro(config["mmlu"]["source"])
                if args.limit is not None:
                    mmlu_records = mmlu_records[: args.limit]
                analyze(
                    config,
                    CHECKPOINTS,
                    CHECKPOINTS / "exp2_judge.jsonl",
                    mmlu_records,
                    alphas,
                    CHECKPOINTS / "exp2_results.json",
                )


if __name__ == "__main__":
    main()