"""
Narration layer — MiniCPM4-0.5B (openbmb, 0.5B params, <=4B cap).
OPTIONAL and NON-BLOCKING: if the model can't load, a deterministic
template narration is used instead. The app never depends on it.
Unlocks: Tiny Titan badge (<=4B), Best MiniCPM sponsor, small-model track.
"""
MODEL_ID = "openbmb/MiniCPM4-0.5B"
try:
    import spaces
    GPU = spaces.GPU
except Exception:
    def GPU(*a, **k):
        def wrap(f): return f
        return wrap(a[0]) if a and callable(a[0]) else wrap
_model = None
_tok = None
_tried = False

def _try_load():
    global _model, _tok, _tried
    if _tried:
        return _model is not None
    _tried = True
    try:
        import torch
        from transformers import AutoModelForCausalLM, AutoTokenizer
        _tok = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
        _model = AutoModelForCausalLM.from_pretrained(
            MODEL_ID, torch_dtype=torch.bfloat16, device_map="auto",
            trust_remote_code=True)
        return True
    except Exception as e:
        print(f"[narrate] model unavailable, using template fallback: {e}")
        return False

def _template(name, m, klass):
    v, l = m["velocity"], m["leverage"]
    if m["non_compounding"]:
        body = (f"{name} runs a stateless pipe - no cache commits, so the "
                f"cascade can't form. High read volume, but nothing is being "
                f"built forward. Leverage {l:,.1f}x comes from reuse alone.")
    elif v >= 1 and l >= 100:
        body = (f"{name} holds both axes at once: {v:.1f}x generation AND "
                f"{l:,.0f}x memory leverage. A closed kinetic loop - the rare "
                f"operator the leverage/generation tradeoff says shouldn't exist.")
    elif l >= 10 and v < 1:
        body = (f"{name} is an archival sponge - {l:,.0f}x reuse but only "
                f"{v:.2f}x generation. Holds context beautifully, executes little "
                f"with it. The reuse number is inflated by a weak commitment stage.")
    elif v >= 0.8 and l < 2:
        body = (f"{name} is a volatile ingestor - {v:.2f}x generation but "
                f"{l:.1f}x leverage. Fast on single shots, resets between turns. "
                f"Memory doesn't persist into a compounding loop.")
    else:
        body = (f"{name} sits low on both axes: {v:.2f}x generation, {l:.1f}x "
                f"leverage. A transient profile - neither building state nor "
                f"converting input to output efficiently.")
    return f"**{klass}.** {body}"

@GPU
def narrate(name, m, klass):
    if not _try_load():
        return _template(name, m, klass)
    try:
        v, l, snr = m["velocity"], m["leverage"], m["snr"]
        dev = f"{m['dev10x']:.2f}" if m['dev10x'] is not None else "none (stateless)"
        prompt = (
            "You are a terse systems analyst for a token-economy leaderboard. "
            "In 2-3 sentences, characterize this AI coding operator from its "
            "metrics. Be specific and a little vivid. Do not list the numbers back.\n"
            f"Operator: {name}\nClass: {klass}\n"
            f"Generation (output/input): {v:.2f}x\n"
            f"Memory leverage (read/input): {l:.1f}x\n"
            f"Signal (output share): {snr:.2f}\n"
            f"Cascade amplification: {dev}\n")
        msgs = [{"role": "user", "content": prompt}]
        inputs = _tok.apply_chat_template(msgs, add_generation_prompt=True,
                                          return_tensors="pt").to(_model.device)
        out = _model.generate(inputs, max_new_tokens=110, temperature=0.7,
                              do_sample=True, top_p=0.9)
        text = _tok.decode(out[0][inputs.shape[1]:], skip_special_tokens=True).strip()
        return f"**{klass}.** {text}" if text else _template(name, m, klass)
    except Exception as e:
        print(f"[narrate] generation failed, template fallback: {e}")
        return _template(name, m, klass)