"""Bounded model generation, intended to run inside the Molab notebook.

Each completed batch is appended to JSONL and can be resumed by sample id.
Model weights and numerical work stay on the remote machine.
"""

from __future__ import annotations

import argparse
import importlib.metadata
import json
import os
from pathlib import Path
import subprocess
import time


def read_jsonl(path):
    with Path(path).open(encoding="utf-8") as handle:
        return [json.loads(line) for line in handle if line.strip()]


def emit(event, **fields):
    print(json.dumps({"event": event, **fields}, ensure_ascii=False), flush=True)


def package_versions():
    result = {}
    for name in ("torch", "vllm", "transformers", "tokenizers", "huggingface_hub"):
        try:
            result[name] = importlib.metadata.version(name)
        except importlib.metadata.PackageNotFoundError:
            result[name] = None
    return result


def split_response(text, thinking_enabled):
    if "</think>" in text:
        reasoning, response = text.split("</think>", 1)
        return response.strip(), reasoning.removeprefix("<think>").strip()
    # The Qwen thinking template may already end with an opening think token.
    # Preserve an unfinished thought rather than claiming it is a final answer.
    return ("", text) if thinking_enabled else (text, None)


class TransformersEngine:
    def __init__(self, args, sampling, thinking_enabled):
        import torch
        from transformers import AutoModelForImageTextToText, AutoTokenizer, LogitsProcessor

        self.torch = torch
        self.args = args
        self.sampling = sampling
        self.thinking_enabled = thinking_enabled
        self.tokenizer = AutoTokenizer.from_pretrained(args.model, cache_dir=args.cache_dir, revision=args.revision)
        self.tokenizer.padding_side = "left"
        self.model = AutoModelForImageTextToText.from_pretrained(
            args.model, dtype=torch.bfloat16, cache_dir=args.cache_dir, revision=args.revision,
            attn_implementation="sdpa").to("cuda").eval()
        self.model_revision = getattr(self.model.config, "_commit_hash", None)

        class PresencePenalty(LogitsProcessor):
            def __init__(self, prompt_length, penalty):
                self.prompt_length = prompt_length
                self.penalty = penalty
                self.seen = None

            def __call__(self, input_ids, scores):
                if self.seen is None:
                    self.seen = torch.zeros_like(scores, dtype=torch.bool)
                if input_ids.shape[1] > self.prompt_length:
                    self.seen.scatter_(1, input_ids[:, -1:], True)
                return scores - self.seen.to(scores.dtype) * self.penalty

        self.PresencePenalty = PresencePenalty

    def generate(self, batch):
        from transformers import LogitsProcessorList, set_seed
        if len({row["seed"] for row in batch}) != 1:
            raise ValueError("Transformers batches must use one shared seed.")
        set_seed(batch[0]["seed"])
        template_kwargs = {"tokenize": False, "add_generation_prompt": True}
        if self.args.thinking != "default":
            template_kwargs["enable_thinking"] = self.args.thinking == "on"
        prompts = [self.tokenizer.apply_chat_template(
            [{"role": "user", "content": row["prompt"]}], **template_kwargs) for row in batch]
        inputs = self.tokenizer(prompts, padding=True, return_tensors="pt").to("cuda")
        prompt_length = inputs["input_ids"].shape[1]
        if prompt_length + self.args.max_tokens > self.args.max_model_len:
            raise ValueError("Prompt plus generation budget exceeds configured context.")
        started = time.perf_counter()
        with self.torch.inference_mode():
            sequences = self.model.generate(
                **inputs, do_sample=True, max_new_tokens=self.args.max_tokens,
                temperature=self.sampling["temperature"], top_p=self.sampling["top_p"],
                top_k=self.sampling["top_k"], min_p=self.sampling["min_p"],
                repetition_penalty=self.sampling["repetition_penalty"],
                logits_processor=LogitsProcessorList([
                    self.PresencePenalty(prompt_length, self.sampling["presence_penalty"])]))
        elapsed = time.perf_counter() - started
        eos = self.model.generation_config.eos_token_id
        eos_ids = {eos} if isinstance(eos, int) else set(eos or [])
        outputs = []
        for index, sequence in enumerate(sequences[:, prompt_length:]):
            tokens = sequence.tolist()
            eos_position = next((i for i, token in enumerate(tokens) if token in eos_ids), None)
            if eos_position is not None:
                tokens = tokens[:eos_position + 1]
            text = self.tokenizer.decode(tokens, skip_special_tokens=False)
            # Keep think delimiters, remove only response terminators.
            for eos_id in eos_ids:
                text = text.replace(self.tokenizer.decode([eos_id]), "")
            outputs.append({"raw_response": text, "prompt_tokens": int(inputs["attention_mask"][index].sum()),
                            "output_tokens": len(tokens), "finish_reason": "stop" if eos_position is not None else "length",
                            "stop_reason": tokens[-1] if eos_position is not None else None,
                            "latency_seconds": elapsed, "seed_scope": "batch"})
        return outputs, elapsed


class VllmEngine:
    def __init__(self, args, sampling, thinking_enabled):
        from vllm import LLM
        self.args = args
        self.sampling = sampling
        self.llm = LLM(model=args.model, dtype="bfloat16", language_model_only=True,
                       revision=args.revision, tokenizer_revision=args.revision,
                       max_model_len=args.max_model_len, max_num_seqs=args.batch_size,
                       gpu_memory_utilization=args.gpu_memory_utilization,
                       enforce_eager=args.enforce_eager,
                       download_dir=str(Path(args.cache_dir).resolve()))
        self.tokenizer = self.llm.get_tokenizer()
        engine_config = getattr(self.llm.llm_engine, "vllm_config", None)
        model_config = getattr(engine_config, "model_config", None)
        hf_config = getattr(model_config, "hf_config", None)
        self.model_revision = getattr(hf_config, "_commit_hash", None)

    def generate(self, batch):
        from vllm import SamplingParams
        prompts, settings = [], []
        for row in batch:
            template_kwargs = {"tokenize": False, "add_generation_prompt": True}
            if self.args.thinking != "default":
                template_kwargs["enable_thinking"] = self.args.thinking == "on"
            prompts.append(self.tokenizer.apply_chat_template(
                [{"role": "user", "content": row["prompt"]}], **template_kwargs))
            settings.append(SamplingParams(**self.sampling, seed=row["seed"], max_tokens=self.args.max_tokens,
                                           skip_special_tokens=False))
        started = time.perf_counter()
        results = self.llm.generate(prompts, settings, use_tqdm=False)
        elapsed = time.perf_counter() - started
        outputs = []
        for result in results:
            completion = result.outputs[0]
            metrics = getattr(result, "metrics", None)
            finished = getattr(metrics, "finished_time", None)
            arrival = getattr(metrics, "arrival_time", None)
            latency = finished - arrival if finished is not None and arrival is not None else elapsed
            outputs.append({"raw_response": completion.text, "prompt_tokens": len(result.prompt_token_ids),
                            "output_tokens": len(completion.token_ids), "finish_reason": completion.finish_reason,
                            "stop_reason": completion.stop_reason, "latency_seconds": latency, "seed_scope": "request"})
        return outputs, elapsed


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--input", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--model", required=True)
    parser.add_argument("--revision")
    parser.add_argument("--engine", choices=("transformers", "vllm"), default="transformers")
    parser.add_argument("--batch-size", type=int, default=8)
    parser.add_argument("--max-tokens", type=int, default=8192)
    parser.add_argument("--max-model-len", type=int, default=131072)
    parser.add_argument("--gpu-memory-utilization", type=float, default=0.85)
    parser.add_argument("--thinking", choices=("default", "on", "off"), default="default")
    parser.add_argument("--limit", type=int)
    parser.add_argument("--cache-dir", default="cache/huggingface")
    parser.add_argument("--enforce-eager", action="store_true")
    args = parser.parse_args()

    Path(args.cache_dir).mkdir(parents=True, exist_ok=True)
    os.environ.setdefault("HF_HOME", str(Path(args.cache_dir).resolve()))
    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")

    import torch

    if not torch.cuda.is_available():
        raise RuntimeError("This experiment requires the Molab RTX PRO 6000 GPU.")

    output_path = Path(args.output)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    completed = {row["id"] for row in read_jsonl(output_path)} if output_path.exists() else set()
    requests = [row for row in read_jsonl(args.input) if row["model"] == args.model and row["id"] not in completed]
    if args.limit is not None:
        requests = requests[:args.limit]
    if args.engine == "transformers":
        requests.sort(key=lambda row: row["seed"])
    if not requests:
        emit("nothing_pending", model=args.model, completed=len(completed))
        return

    actual_thinking = args.thinking == "on" or (args.thinking == "default" and args.model != "Qwen/Qwen3.5-2B")
    started = time.time()
    metadata_path = output_path.with_suffix(output_path.suffix + ".runtime.json")
    attempt_metadata_path = output_path.with_suffix(output_path.suffix + f".runtime.{int(started * 1000)}.json")
    metadata = {
        "model": args.model, "packages": package_versions(), "args": vars(args),
        "engine_environment": {"VLLM_USE_FLASHINFER_SAMPLER": os.environ.get("VLLM_USE_FLASHINFER_SAMPLER")},
        "started_unix": started, "pending_samples": len(requests),
        "thinking_enabled": actual_thinking,
        "completed_samples_before_run": len(completed), "dtype": "bfloat16",
        "hardware": {"cuda": torch.version.cuda, "device": torch.cuda.get_device_name(0),
                     "total_memory_bytes": torch.cuda.get_device_properties(0).total_memory,
                     "nvidia_smi": subprocess.run(["nvidia-smi"], capture_output=True, text=True).stdout},
        "sampling": {"temperature": 1.0, "top_p": 0.95, "top_k": 20,
                     "min_p": 0.0, "presence_penalty": 1.5, "repetition_penalty": 1.0},
        "latency_definition": "vLLM finished_time minus arrival_time when exposed; otherwise batch wall time",
        "load_mode": "language_model_only" if args.engine == "vllm" else "conditional_generation_text_inputs_only",
    }
    if args.model == "Qwen/Qwen3.5-2B" and not actual_thinking:
        metadata["sampling"].update(temperature=1.0, top_p=1.0, presence_penalty=2.0)
    elif not actual_thinking:
        metadata["sampling"].update(temperature=0.7, top_p=0.8)
    metadata["sampling_profile"] = "official_model_mode"

    def save_metadata():
        content = json.dumps(metadata, ensure_ascii=False, indent=2)
        metadata_path.write_text(content, encoding="utf-8")
        attempt_metadata_path.write_text(content, encoding="utf-8")

    save_metadata()
    emit("loading", model=args.model, samples=len(requests), hardware=metadata["hardware"]["device"])
    load_started = time.perf_counter()
    engine_class = VllmEngine if args.engine == "vllm" else TransformersEngine
    engine = engine_class(args, metadata["sampling"], actual_thinking)
    metadata["model_revision"] = engine.model_revision
    if metadata["model_revision"] is None:
        from huggingface_hub import try_to_load_from_cache
        for cache_root in (Path(args.cache_dir), Path(args.cache_dir) / "hub"):
            cached_config = try_to_load_from_cache(args.model, "config.json", cache_dir=str(cache_root),
                                                   revision=args.revision)
            if isinstance(cached_config, str) and "/snapshots/" in cached_config:
                metadata["model_revision"] = cached_config.split("/snapshots/", 1)[1].split("/", 1)[0]
                metadata["revision_source"] = "loaded config cache snapshot identifier"
                break
    metadata["decoding"] = {"skip_special_tokens": False, "preserve_think_delimiters": True}
    metadata["model_load_seconds"] = time.perf_counter() - load_started
    save_metadata()
    emit("loaded", model=args.model, load_seconds=metadata["model_load_seconds"])

    generated = 0
    output_tokens = 0
    generation_started = time.perf_counter()
    with output_path.open("a", encoding="utf-8") as handle:
        offset = 0
        while offset < len(requests):
            batch = requests[offset:offset + args.batch_size]
            if args.engine == "transformers":
                batch = [row for row in batch if row["seed"] == batch[0]["seed"]]
            emit("batch_started", model=args.model, completed=generated, batch_size=len(batch))
            results, batch_seconds = engine.generate(batch)
            for row, result in zip(batch, results):
                response, reasoning = split_response(result["raw_response"], actual_thinking)
                record = {**row, **result, "response": response, "reasoning": reasoning,
                          "engine": args.engine, "batch_seconds": batch_seconds,
                          "thinking_mode": args.thinking, "thinking_enabled": actual_thinking,
                          "max_tokens": args.max_tokens,
                          "sampling_profile": metadata["sampling_profile"],
                          "sampling": metadata["sampling"]}
                handle.write(json.dumps(record, ensure_ascii=False) + "\n")
                generated += 1
                output_tokens += record["output_tokens"]
            handle.flush()
            os.fsync(handle.fileno())
            metadata.update(generated_samples=generated, generated_tokens=output_tokens,
                            generation_seconds=time.perf_counter() - generation_started,
                            last_batch_seconds=batch_seconds, elapsed_seconds=time.time() - started)
            metadata["tokens_per_second"] = output_tokens / metadata["generation_seconds"]
            metadata["seconds_per_sample"] = metadata["generation_seconds"] / generated
            save_metadata()
            emit("batch_complete", model=args.model, completed=generated, total=len(requests),
                 batch_seconds=batch_seconds,
                 tokens_per_second=sum(result["output_tokens"] for result in results) / batch_seconds,
                 tokens=[result["output_tokens"] for result in results],
                 finish_reasons=[result["finish_reason"] for result in results])
            offset += len(batch)
    metadata["completed_unix"] = time.time()
    save_metadata()
    emit("complete", model=args.model, generated_samples=generated,
         generation_seconds=metadata["generation_seconds"], output_tokens=output_tokens)


if __name__ == "__main__":
    main()