"""Bounded CPU Coder390 BF16 -> MLX affine q4 conversion; never loads a model.

Sanitization is delegated to a SHA-pinned upstream mlx-vlm implementation.
Each source is fully hashed before use; source weights are never modified.
MTP remains in the source for a separate native sidecar extraction.
"""
from __future__ import annotations

import argparse
import gc
import hashlib
import importlib.util
import json
import math
from pathlib import Path
import shutil
import struct
import time
from types import SimpleNamespace

import mlx.core as mx
import numpy as np

ROOT = Path(__file__).resolve().parent
SANITIZER = ROOT / "raw/upstream/qwen3_5.py"
SANITIZER_SHA = "7c0e360a35e1f5d3819677cd6f7e4d7349f4f3dd2fad5fc8f1e374bd514e8f1b"
SANITIZER_REV = "952d4f6bc65bd5095e74abe71c78038764ee08aa"
DTYPES = {"BF16": (np.dtype("<u2"), mx.bfloat16),
          "F32": (np.dtype("<f4"), mx.float32),
          "F16": (np.dtype("<f2"), mx.float16)}
LINEAR_SUFFIXES = (".mlp.up_proj.weight", ".mlp.gate_proj.weight", ".mlp.down_proj.weight",
                   ".self_attn.q_proj.weight", ".self_attn.k_proj.weight", ".self_attn.v_proj.weight",
                   ".self_attn.o_proj.weight", ".linear_attn.in_proj_qkv.weight",
                   ".linear_attn.in_proj_z.weight", ".linear_attn.in_proj_a.weight",
                   ".linear_attn.in_proj_b.weight", ".linear_attn.out_proj.weight",
                   ".embed_tokens.weight", "lm_head.weight")


def sha256(path):
    digest = hashlib.sha256()
    with Path(path).open("rb") as handle:
        for block in iter(lambda: handle.read(8 * 1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def sanitizer():
    if sha256(SANITIZER) != SANITIZER_SHA:
        raise ValueError("Pinned sanitizer hash mismatch")
    spec = importlib.util.spec_from_file_location("mlx_vlm.models.qwen3_5._coder390_sanitize", SANITIZER)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module.Model.sanitize


def read_header(path):
    with path.open("rb") as handle:
        prefix = handle.read(8)
        if len(prefix) != 8:
            raise ValueError("Truncated safetensors header")
        length = struct.unpack("<Q", prefix)[0]
        if length > 16 * 1024 * 1024:
            raise ValueError("Safetensors header bound exceeded")
        raw = handle.read(length)
        if len(raw) != length:
            raise ValueError("Truncated safetensors header")
        header = json.loads(raw)
    entries = {key: value for key, value in header.items() if key != "__metadata__"}
    payload = path.stat().st_size - length - 8
    spans = []
    for key, meta in entries.items():
        if meta["dtype"] not in DTYPES:
            raise ValueError(f"Unsupported source dtype: {key}: {meta['dtype']}")
        start, end = meta["data_offsets"]
        shape = meta["shape"]
        if any(type(n) is not int or n < 0 for n in shape):
            raise ValueError(f"Invalid tensor shape: {key}")
        size = math.prod(shape) * DTYPES[meta["dtype"]][0].itemsize
        if start < 0 or end - start != size or end > payload:
            raise ValueError(f"Invalid source tensor offsets: {key}")
        spans.append((start, end))
    spans.sort()
    cursor = 0
    for start, end in spans:
        if start != cursor:
            raise ValueError("Safetensors payload gaps or overlaps")
        cursor = end
    if cursor != payload:
        raise ValueError("Safetensors payload size mismatch")
    return entries, 8 + length


def quantizable(name, shape):
    if name.startswith("model.visual."):
        return False
    if name.startswith("mtp."):
        return False
    if len(shape) == 2 and name.endswith(LINEAR_SUFFIXES):
        if shape[-1] % 64:
            raise ValueError(f"Unsupported group alignment: {name}")
        return True
    known = (".input_layernorm.weight", ".post_attention_layernorm.weight", ".norm.weight",
             ".q_norm.weight", ".k_norm.weight", ".conv1d.weight", ".A_log", ".dt_bias")
    if name.endswith(known):
        return False
    raise ValueError(f"Unsupported/unknown source tensor: {name}")


def tensor_bytes(array):
    mx.eval(array)
    dtype = array.dtype
    if dtype == mx.bfloat16:
        return np.asarray(array.view(mx.uint16), dtype="<u2").tobytes(), "BF16"
    if dtype == mx.float32:
        return np.asarray(array, dtype="<f4").tobytes(), "F32"
    if dtype == mx.float16:
        return np.asarray(array, dtype="<f2").tobytes(), "F16"
    if dtype == mx.uint32:
        return np.asarray(array, dtype="<u4").tobytes(), "U32"
    raise ValueError(f"Unsupported output dtype: {dtype}")


def pack_shard(output, pending, sequence):
    filename = f"model-{sequence:05d}.safetensors"
    header = {"__metadata__": {"format": "mlx"}}
    offset = 0
    for record in pending:
        end = offset + record["bytes"]
        header[record["name"]] = {"dtype": record["dtype"], "shape": record["shape"],
                                  "data_offsets": [offset, end]}
        offset = end
    raw = json.dumps(header, separators=(",", ":")).encode()
    raw += b" " * ((-len(raw)) % 8)
    path = output / filename
    with path.open("xb") as handle:
        handle.write(struct.pack("<Q", len(raw)))
        handle.write(raw)
        for record in pending:
            with record["path"].open("rb") as source:
                shutil.copyfileobj(source, handle, 8 * 1024 * 1024)
            record["path"].unlink()
    return filename


def convert(source, output, expected, *, row_chunk=128, shard_bytes=512 * 1024 * 1024):
    mx.set_default_device(mx.cpu)
    source, output = Path(source).resolve(), Path(output).resolve()
    if output.exists() or output == source or source in output.parents:
        raise ValueError("Destination exists or is inside source; refusing overwrite")
    if not 1 <= row_chunk <= 512:
        raise ValueError("row_chunk must be in 1..512")
    index = json.loads((source / "model.safetensors.index.json").read_text())["weight_map"]
    config = json.loads((source / "config.json").read_text())
    source_records = {}
    headers = {}
    for filename in sorted(set(index.values())):
        if Path(filename).name != filename:
            raise ValueError("Unsafe source shard path")
        path = source / filename
        want = expected.get(filename)
        if not want or path.stat().st_size != want["size"]:
            raise ValueError(f"Source size/manifest mismatch: {filename}")
        print(f"Verifying full SHA-256: {filename}", flush=True)
        digest = sha256(path)
        if digest != want["sha256"]:
            raise ValueError(f"Source SHA-256 mismatch: {filename}")
        source_records[filename] = {"size": path.stat().st_size, "sha256": digest}
        headers[filename] = read_header(path)
        if set(headers[filename][0]) != {key for key, value in index.items() if value == filename}:
            raise ValueError(f"Index/header mismatch: {filename}")
    output.mkdir(parents=True)
    spool = output / ".tensor-spool"
    spool.mkdir()
    sanitize = sanitizer()
    owner = SimpleNamespace(config=SimpleNamespace(
        text_config=SimpleNamespace(tie_word_embeddings=config["text_config"].get("tie_word_embeddings", False)),
        vision_config=SimpleNamespace(in_channels=config.get("vision_config", {}).get("in_channels", 3))))
    pending, weight_map, transforms = [], {}, []
    total_size, sequence, spool_id = 0, 1, 0
    started = time.monotonic()
    for number, (name, filename) in enumerate(index.items(), 1):
        if name.startswith("mtp."):
            continue
        meta, base = headers[filename]
        meta = meta[name]
        shape = meta["shape"]
        do_quant = quantizable(name, shape)
        dtype_np, dtype_mx = DTYPES[meta["dtype"]]
        mapped = np.memmap(source / filename, dtype=dtype_np, mode="r",
                           offset=base + meta["data_offsets"][0], shape=tuple(shape))
        rows = shape[0] if shape else 1
        records = {}
        for start in range(0, rows, row_chunk):
            part = np.array(mapped[start:start + row_chunk] if shape else mapped, copy=True)
            array = mx.array(part)
            if dtype_mx == mx.bfloat16:
                array = array.view(mx.bfloat16)
            if not bool(mx.all(mx.isfinite(array))):
                raise ValueError(f"Nonfinite source tensor: {name}")
            clean = sanitize(owner, {name: array})
            if len(clean) != 1:
                raise ValueError(f"Unexpected sanitizer output: {name}")
            new_name, array = next(iter(clean.items()))
            if do_quant:
                q, scale, bias = mx.quantize(array, group_size=64, bits=4, mode="affine")
                values = {new_name: q, new_name.removesuffix(".weight") + ".scales": scale,
                          new_name.removesuffix(".weight") + ".biases": bias}
            else:
                values = {new_name: array}
            for key, value in values.items():
                if not bool(mx.all(mx.isfinite(value))):
                    raise ValueError(f"Nonfinite converted tensor: {key}")
                data, kind = tensor_bytes(value)
                if key not in records:
                    spool_id += 1
                    path = spool / f"{spool_id:06d}.payload"
                    records[key] = {"name": key, "dtype": kind, "shape": list(value.shape), "bytes": 0, "path": path}
                    if shape:
                        records[key]["shape"][0] = 0
                record = records[key]
                if shape:
                    record["shape"][0] += value.shape[0]
                with record["path"].open("ab") as handle:
                    handle.write(data)
                record["bytes"] += len(data)
            del array, clean, values, part
            if do_quant:
                del q, scale, bias
            del value, data
        del mapped
        new_records = list(records.values())
        size = sum(record["bytes"] for record in new_records)
        if pending and sum(record["bytes"] for record in pending) + size > shard_bytes:
            shard = pack_shard(output, pending, sequence)
            for record in pending:
                weight_map[record["name"]] = shard
            pending = []
            sequence += 1
        pending.extend(new_records)
        total_size += size
        transforms.append({"source": name, "output": list(records), "quantized": do_quant})
        gc.collect()
        print(f"Converted {number}/{len(index)} {name} -> {size} bytes (CPU)", flush=True)
    if pending:
        shard = pack_shard(output, pending, sequence)
        for record in pending:
            if record["name"] in weight_map:
                raise ValueError("Duplicate converted tensor name")
            weight_map[record["name"]] = shard
    spool.rmdir()
    index_out = {"metadata": {"total_size": total_size}, "weight_map": dict(sorted(weight_map.items()))}
    (output / "model.safetensors.index.json").write_text(json.dumps(index_out, indent=2) + "\n")
    quantization = {"group_size": 64, "bits": 4, "mode": "affine"}
    config["quantization"] = quantization
    config["quantization_config"] = dict(quantization)
    (output / "config.json").write_text(json.dumps(config, indent=2) + "\n")
    for filename in ("tokenizer.json", "tokenizer_config.json", "chat_template.jinja", "generation_config.json",
                     "preprocessor_config.json", "video_preprocessor_config.json"):
        if (source / filename).is_file():
            shutil.copy2(source / filename, output / filename)
    files = {path.name: {"size": path.stat().st_size, "sha256": sha256(path)}
             for path in sorted(output.iterdir()) if path.is_file()}
    manifest = {"device": "cpu", "quantization": quantization, "vision": "source BF16, unquantized",
                "mtp": "excluded from target; original sidecar retained in source", "source_files": source_records,
                "sanitizer_revision": SANITIZER_REV, "sanitizer_sha256": SANITIZER_SHA,
                "row_chunk": row_chunk, "output_files": files, "transforms": transforms,
                "elapsed_s": time.monotonic() - started, "inference_qualified": False}
    (output / "conversion-manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
    return manifest


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--source", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--expected", type=Path, required=True)
    parser.add_argument("--row-chunk", type=int, default=128)
    args = parser.parse_args()
    result = convert(args.source, args.output, json.loads(args.expected.read_text()), row_chunk=args.row_chunk)
    print(json.dumps({key: result[key] for key in ["device", "elapsed_s", "inference_qualified"]}, indent=2))