#!/usr/bin/env python
"""
04_reshard.py
Problem: decoder_model_merged_q4f16.onnx_data ist EINE Datei mit 2.84 GB.
Browser-ArrayBuffer-Limit liegt bei ~2 GB -> Ladefehler.

Loesung: Gewichte auf ZWEI Dateien verteilen (wie das Stock-Modell von Google):
  decoder_model_merged_q4f16.onnx_data     (~2.0 GB)
  decoder_model_merged_q4f16.onnx_data_1   (~0.8 GB)

Kein Torch, kein Training, kein Re-Export. Nur onnx + huggingface_hub.
"""

import os
from pathlib import Path

import onnx
from onnx.external_data_helper import (
    load_external_data_for_model,
    _get_all_tensors,
)

os.environ.setdefault("HF_HOME", "/root/hf")

REPO = "gfp78/gemma4-bund-onnx"
WORK = Path("/root/reshard")
WORK.mkdir(parents=True, exist_ok=True)

BASE = "decoder_model_merged_q4f16"
SPLIT_BYTES = 1_900_000_000        # ~1.9 GB pro Datei, sicher unter 2 GB


def log(m):
    print(f"\n=== {m}", flush=True)


# ------------------------------------------------------------- 1) holen
log("1) Dateien von HF holen")
from huggingface_hub import hf_hub_download

for fn in (f"onnx/{BASE}.onnx", f"onnx/{BASE}.onnx_data"):
    p = hf_hub_download(REPO, fn)
    print("  ", fn, "->", p)

onnx_path = hf_hub_download(REPO, f"onnx/{BASE}.onnx")
src_dir = Path(onnx_path).parent


# --------------------------------------------------------- 2) laden
log("2) Graph + externe Daten in den Speicher laden (dauert 1-3 Min)")
m = onnx.load(onnx_path, load_external_data=True)
print("  geladen.")


# ------------------------------------------- 3) Tensoren auf 2 Files verteilen
log("3) Gewichte auf zwei Dateien verteilen")
tensors = [t for t in _get_all_tensors(m) if t.HasField("raw_data")]
tensors.sort(key=lambda t: len(t.raw_data), reverse=True)

# Groesse aller Tensoren > 1 KB (kleinere bleiben im .onnx selbst)
big = [t for t in tensors if len(t.raw_data) > 1024]
total = sum(len(t.raw_data) for t in big)
print(f"  {len(big)} Tensoren, gesamt {total/1e9:.2f} GB")

# Greedy: fuelle Datei 0 bis zur Grenze, Rest in Datei 1
assign = {}
used = [0, 0]
for t in big:
    sz = len(t.raw_data)
    idx = 0 if used[0] + sz <= SPLIT_BYTES else 1
    assign[id(t)] = idx
    used[idx] += sz

print(f"  Datei 0: {used[0]/1e9:.2f} GB")
print(f"  Datei 1: {used[1]/1e9:.2f} GB")
if used[1] > SPLIT_BYTES:
    print("  !! WARNUNG: Datei 1 zu gross — SPLIT_BYTES senken und erneut laufen lassen.")

LOC = [f"{BASE}.onnx_data", f"{BASE}.onnx_data_1"]

# Jeden Tensor manuell auf 'external' setzen, mit seinem Ziel-File
out_dir = WORK / "onnx"
out_dir.mkdir(parents=True, exist_ok=True)
for loc in LOC:
    (out_dir / loc).unlink(missing_ok=True)

offsets = [0, 0]
handles = [open(out_dir / LOC[0], "wb"), open(out_dir / LOC[1], "wb")]

for t in big:
    i = assign[id(t)]
    raw = t.raw_data
    handles[i].write(raw)

    t.ClearField("raw_data")
    t.data_location = onnx.TensorProto.EXTERNAL
    del t.external_data[:]
    for k, v in (("location", LOC[i]),
                 ("offset", str(offsets[i])),
                 ("length", str(len(raw)))):
        e = t.external_data.add()
        e.key = k
        e.value = v
    offsets[i] += len(raw)

for h in handles:
    h.close()

onnx.save_model(m, str(out_dir / f"{BASE}.onnx"), save_as_external_data=False)
print("  geschrieben.")


# --------------------------------------------------------- 4) Verifikation
log("4) Verifikation")
for loc in LOC:
    sz = (out_dir / loc).stat().st_size / 1e9
    flag = "OK" if sz < 2.0 else "!! >2 GB — Browser-Limit!"
    print(f"  {loc}: {sz:.2f} GB  {flag}")

m2 = onnx.load(str(out_dir / f"{BASE}.onnx"), load_external_data=True)
onnx.checker.check_model(m2)
print("  Graph valide, externe Daten aufloesbar.")
del m2

import onnxruntime as ort
s = ort.InferenceSession(str(out_dir / f"{BASE}.onnx"),
                         providers=["CPUExecutionProvider"])
print("  ORT-Session OK. Inputs:", len(s.get_inputs()))

os.system(f"ls -la {out_dir}")
log("FERTIG. Dateien liegen in " + str(out_dir))
print("Naechster Schritt: die DREI Dateien nach C:\\tiseR\\models\\gemma4-bund-v2\\onnx\\")
print("kopieren und die ALTE .onnx_data dort ERSETZEN:")
print(f"  {BASE}.onnx")
print(f"  {BASE}.onnx_data")
print(f"  {BASE}.onnx_data_1")