#!/usr/bin/env python3
"""Fair speed bench for Qwen3-Embedding-8B MLX variants.

Runs one model per process. Measures cold load, warmup, and steady-state
encode latency/throughput at fixed token lengths using the same last-token
L2-normalized path as the retrieval smoke.
"""

from __future__ import annotations

import argparse
import json
import os
import resource
import statistics
import subprocess
import sys
import time
from pathlib import Path

import mlx.core as mx
import numpy as np
from mlx_lm import load


TASK = (
    "Given a natural-language search query, retrieve the single passage "
    "that best answers it"
)

DEFAULT_MODELS = {
    "bf16": "/Volumes/Models/models/Qwen/Qwen3-Embedding-8B-MLX-BF16",
    "oq8e": "/Volumes/Models/models/Qwen/Qwen3-Embedding-8B-MLX-oQ8e",
    "oq6e": "/Volumes/Models/models/Qwen/Qwen3-Embedding-8B-MLX-oQ6e",
    "oq4e": "/Volumes/Models/models/Qwen/Qwen3-Embedding-8B-MLX-oQ4e",
}


def detailed_instruction(query: str) -> str:
    return f"Instruct: {TASK}\nQuery:{query}"


def normalize(vector: mx.array) -> mx.array:
    vector = vector.astype(mx.float32)
    return vector / mx.maximum(mx.sqrt(mx.sum(vector * vector)), mx.array(1e-12))


def encode_tokens(model, token_ids: list[int]) -> np.ndarray:
    tokens = mx.array([token_ids])
    hidden = model.model(tokens)
    if isinstance(hidden, tuple):
        hidden = hidden[0]
    vector = normalize(hidden[0, -1])
    mx.eval(vector)
    return np.asarray(vector, dtype=np.float32)


def pad_or_trim(token_ids: list[int], length: int, pad_id: int) -> list[int]:
    if len(token_ids) >= length:
        return token_ids[:length]
    return token_ids + [pad_id] * (length - len(token_ids))


def percentile(values: list[float], pct: float) -> float:
    if not values:
        return float("nan")
    ordered = sorted(values)
    if len(ordered) == 1:
        return ordered[0]
    rank = (len(ordered) - 1) * (pct / 100.0)
    low = int(rank)
    high = min(low + 1, len(ordered) - 1)
    frac = rank - low
    return ordered[low] * (1.0 - frac) + ordered[high] * frac


def summarize(values: list[float]) -> dict:
    return {
        "n": len(values),
        "mean": float(statistics.fmean(values)),
        "median": float(statistics.median(values)),
        "stdev": float(statistics.stdev(values)) if len(values) > 1 else 0.0,
        "min": float(min(values)),
        "max": float(max(values)),
        "p90": float(percentile(values, 90)),
        "p95": float(percentile(values, 95)),
    }


def build_length_payloads(tokenizer, lengths: list[int]) -> dict[int, list[int]]:
    pad_id = getattr(tokenizer, "pad_token_id", None)
    if pad_id is None:
        pad_id = getattr(tokenizer, "eos_token_id", 0)
    seed_query = detailed_instruction(
        "Benchmark the steady-state embedding encode path for local retrieval "
        "over file paths, model metadata, and short technical passages."
    )
    seed_doc = (
        "Local File Intelligence Catalog indexes provenance-preserving file "
        "metadata and supports validator-controlled read-only text-to-SQL. "
        "Embeddings should remain stable under oQ quantization while load time "
        "and peak memory drop enough for interactive pilot use on Apple Silicon. "
    ) * 64
    base_ids = tokenizer.encode(seed_query) + tokenizer.encode(seed_doc)
    payloads = {}
    for length in lengths:
        payloads[length] = pad_or_trim(base_ids, length, int(pad_id))
    return payloads


def worker_main(args: argparse.Namespace) -> int:
    lengths = [int(item) for item in args.lengths.split(",") if item.strip()]
    if hasattr(mx, "reset_peak_memory"):
        mx.reset_peak_memory()

    load_started = time.perf_counter()
    model, tokenizer = load(args.model)
    # Force weight materialization before calling load complete.
    probe = tokenizer.encode("warmup")
    encode_tokens(model, probe)
    load_seconds = time.perf_counter() - load_started
    load_peak = int(mx.get_peak_memory()) if hasattr(mx, "get_peak_memory") else 0

    payloads = build_length_payloads(tokenizer, lengths)
    if hasattr(mx, "reset_peak_memory"):
        mx.reset_peak_memory()

    # Warmup excluded from timed stats.
    for length in lengths:
        for _ in range(args.warmup):
            encode_tokens(model, payloads[length])

    length_results = {}
    for length in lengths:
        token_ids = payloads[length]
        samples_s = []
        samples_tps = []
        for _ in range(args.repeats):
            started = time.perf_counter()
            encode_tokens(model, token_ids)
            elapsed = time.perf_counter() - started
            samples_s.append(elapsed)
            samples_tps.append(length / elapsed)
        length_results[str(length)] = {
            "token_length": length,
            "latency_seconds": summarize(samples_s),
            "tokens_per_second": summarize(samples_tps),
            "texts_per_second": summarize([1.0 / value for value in samples_s]),
        }

    # Short fixed corpus pass: 24 instruct queries + 24 docs from retrieval set.
    corpus = json.loads(Path(args.dataset).read_text())
    texts = [detailed_instruction(item["query"]) for item in corpus] + [
        item["document"] for item in corpus
    ]
    # Warm one full pass, then time repeats of the full corpus.
    for text in texts:
        encode_tokens(model, tokenizer.encode(text))
    corpus_seconds = []
    for _ in range(args.corpus_repeats):
        started = time.perf_counter()
        for text in texts:
            encode_tokens(model, tokenizer.encode(text))
        corpus_seconds.append(time.perf_counter() - started)

    encode_peak = int(mx.get_peak_memory()) if hasattr(mx, "get_peak_memory") else 0
    result = {
        "label": args.label,
        "model": args.model,
        "pid": os.getpid(),
        "load_seconds": load_seconds,
        "load_mlx_peak_bytes": load_peak,
        "encode_mlx_peak_bytes": encode_peak,
        "process_peak_rss": int(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss),
        "warmup_per_length": args.warmup,
        "repeats_per_length": args.repeats,
        "lengths": length_results,
        "corpus": {
            "text_count": len(texts),
            "repeats": args.corpus_repeats,
            "seconds": summarize(corpus_seconds),
            "texts_per_second": summarize(
                [len(texts) / value for value in corpus_seconds]
            ),
        },
    }
    Path(args.output).write_text(json.dumps(result, indent=2) + "\n")
    print(json.dumps(result, indent=2), flush=True)
    return 0


def run_all(args: argparse.Namespace) -> int:
    out_dir = Path(args.output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    models = {}
    for item in args.models:
        if "=" not in item:
            raise SystemExit(f"model entry must be label=path, got: {item}")
        label, path = item.split("=", 1)
        models[label] = path

    python = args.python or sys.executable
    script = str(Path(__file__).resolve())
    per_model = {}
    for label, path in models.items():
        if not Path(path).exists():
            raise FileNotFoundError(path)
        output = out_dir / f"speed-{label}.json"
        log_path = out_dir / f"speed-{label}.log"
        if args.resume and output.is_file():
            per_model[label] = json.loads(output.read_text())
            print(
                f"[speed] reused {label}: "
                f"load={per_model[label]['load_seconds']:.3f}s "
                f"corpus_tps={per_model[label]['corpus']['texts_per_second']['median']:.3f}",
                flush=True,
            )
            continue
        cmd = [
            python,
            script,
            "worker",
            "--label",
            label,
            "--model",
            path,
            "--dataset",
            args.dataset,
            "--output",
            str(output),
            "--lengths",
            args.lengths,
            "--warmup",
            str(args.warmup),
            "--repeats",
            str(args.repeats),
            "--corpus-repeats",
            str(args.corpus_repeats),
        ]
        print(f"[speed] starting {label}", flush=True)
        with log_path.open("w") as log_file:
            completed = subprocess.run(
                cmd,
                stdout=log_file,
                stderr=subprocess.STDOUT,
                check=False,
            )
        if completed.returncode != 0:
            raise RuntimeError(
                f"{label} speed worker failed with {completed.returncode}; see {log_path}"
            )
        per_model[label] = json.loads(output.read_text())
        print(
            f"[speed] finished {label}: load={per_model[label]['load_seconds']:.3f}s "
            f"corpus_tps={per_model[label]['corpus']['texts_per_second']['median']:.3f}",
            flush=True,
        )

    # Relative to BF16 when present, else first model.
    baseline_label = "bf16" if "bf16" in per_model else next(iter(per_model))
    baseline = per_model[baseline_label]
    comparison = {
        "created_unix": time.time(),
        "baseline": baseline_label,
        "config": {
            "lengths": args.lengths,
            "warmup": args.warmup,
            "repeats": args.repeats,
            "corpus_repeats": args.corpus_repeats,
            "dataset": args.dataset,
            "python": python,
        },
        "models": per_model,
        "relative_to_baseline": {},
    }
    for label, result in per_model.items():
        relative = {
            "load_speedup": baseline["load_seconds"] / result["load_seconds"],
            "corpus_throughput_ratio": (
                result["corpus"]["texts_per_second"]["median"]
                / baseline["corpus"]["texts_per_second"]["median"]
            ),
            "encode_peak_memory_ratio": (
                result["encode_mlx_peak_bytes"] / baseline["encode_mlx_peak_bytes"]
                if baseline["encode_mlx_peak_bytes"]
                else None
            ),
            "lengths": {},
        }
        for length, payload in result["lengths"].items():
            base_len = baseline["lengths"][length]
            relative["lengths"][length] = {
                "latency_ratio_median": (
                    payload["latency_seconds"]["median"]
                    / base_len["latency_seconds"]["median"]
                ),
                "tokens_per_second_ratio_median": (
                    payload["tokens_per_second"]["median"]
                    / base_len["tokens_per_second"]["median"]
                ),
            }
        comparison["relative_to_baseline"][label] = relative

    summary_path = out_dir / "speed-comparison.json"
    summary_path.write_text(json.dumps(comparison, indent=2) + "\n")
    write_markdown(comparison, out_dir / "SPEED_RESULTS.md")
    print(json.dumps({"summary": str(summary_path)}, indent=2), flush=True)
    return 0


def write_markdown(comparison: dict, path: Path) -> None:
    models = comparison["models"]
    order = [label for label in ("bf16", "oq8e", "oq6e", "oq4e") if label in models]
    order.extend(label for label in models if label not in order)
    lines = [
        "# Qwen3-Embedding-8B speed bench",
        "",
        f"Baseline: `{comparison['baseline']}`",
        "",
        "Method: one model per process; cold load includes first encode; "
        "warmup excluded; steady-state latency from repeated single-text encodes "
        "at fixed token lengths; corpus pass re-encodes the frozen 24+24 "
        "retrieval texts.",
        "",
        "## Load and corpus throughput",
        "",
        "| Model | Cold load (s) | Load speedup vs BF16 | Corpus texts/s (median) | Throughput vs BF16 | Encode peak MLX |",
        "| --- | ---: | ---: | ---: | ---: | ---: |",
    ]
    for label in order:
        result = models[label]
        rel = comparison["relative_to_baseline"][label]
        peak = result["encode_mlx_peak_bytes"]
        lines.append(
            f"| {label} | {result['load_seconds']:.3f} | "
            f"{rel['load_speedup']:.3f}x | "
            f"{result['corpus']['texts_per_second']['median']:.3f} | "
            f"{rel['corpus_throughput_ratio']:.3f}x | "
            f"{peak:,} B |"
        )

    # Pick a representative mid length if present.
    sample_lengths = []
    first = models[order[0]]["lengths"]
    sample_lengths = sorted(first.keys(), key=int)
    for length in sample_lengths:
        lines.extend(
            [
                "",
                f"## Fixed length {length} tokens",
                "",
                "| Model | Latency median (ms) | p95 (ms) | Tokens/s median | Latency vs BF16 |",
                "| --- | ---: | ---: | ---: | ---: |",
            ]
        )
        for label in order:
            payload = models[label]["lengths"][length]
            rel = comparison["relative_to_baseline"][label]["lengths"][length]
            lat = payload["latency_seconds"]
            lines.append(
                f"| {label} | {lat['median'] * 1000:.2f} | {lat['p95'] * 1000:.2f} | "
                f"{payload['tokens_per_second']['median']:.1f} | "
                f"{rel['latency_ratio_median']:.3f}x |"
            )

    lines.extend(
        [
            "",
            "## Config",
            "",
            "```json",
            json.dumps(comparison["config"], indent=2),
            "```",
            "",
            "Single-host engineering bench only. Not a claim about server QPS,",
            "batch throughput, or multi-user serving.",
            "",
        ]
    )
    path.write_text("\n".join(lines))


def parser() -> argparse.ArgumentParser:
    root = argparse.ArgumentParser()
    commands = root.add_subparsers(dest="command", required=True)

    worker = commands.add_parser("worker")
    worker.add_argument("--label", required=True)
    worker.add_argument("--model", required=True)
    worker.add_argument("--dataset", required=True)
    worker.add_argument("--output", required=True)
    worker.add_argument("--lengths", default="64,128,256,512,1024")
    worker.add_argument("--warmup", type=int, default=3)
    worker.add_argument("--repeats", type=int, default=12)
    worker.add_argument("--corpus-repeats", type=int, default=3)
    worker.set_defaults(func=worker_main)

    all_cmd = commands.add_parser("all")
    all_cmd.add_argument("--output-dir", required=True)
    all_cmd.add_argument("--dataset", required=True)
    all_cmd.add_argument(
        "--models",
        nargs="+",
        default=[f"{label}={path}" for label, path in DEFAULT_MODELS.items()],
    )
    all_cmd.add_argument("--lengths", default="64,128,256,512,1024")
    all_cmd.add_argument("--warmup", type=int, default=3)
    all_cmd.add_argument("--repeats", type=int, default=12)
    all_cmd.add_argument("--corpus-repeats", type=int, default=3)
    all_cmd.add_argument("--python", default="")
    all_cmd.add_argument(
        "--resume",
        action="store_true",
        help="Reuse a completed per-model JSON result instead of rerunning it.",
    )
    all_cmd.set_defaults(func=run_all)
    return root


if __name__ == "__main__":
    arguments = parser().parse_args()
    raise SystemExit(arguments.func(arguments))