"""A torch-free stand-in for the real engine: answers Jev requests in the shape
DecisionEngine.predict() returns, and records every call it was given."""
from __future__ import annotations

import copy
import hashlib
import json
import math

CALIBRATION = {"method": "temperature-scaling", "temperature": 1.99241824}


def softmax(xs: list[float]) -> list[float]:
    top = max(xs)
    e = [math.exp(x - top) for x in xs]
    return [v / sum(e) for v in e]


def score_by_description(field: str, question: dict) -> list[float]:
    """Default scorer: the option whose description is longest wins; a small first-position bias."""
    descs = list(question["criteria"].values())
    return [len(d) + (0.5 if i == 0 else 0.0) for i, d in enumerate(descs)]


class FakeEngine:
    def __init__(self, scorer=score_by_description, tokens_per_question: int = 100):
        self.scorer = scorer
        self.tokens_per_question = tokens_per_question
        self.calls: list[dict] = []

    metadata = {"name": "Intern-Decision-4B", "revision": "0" * 40}

    def health(self) -> dict:
        return {**self.metadata, "reserved_gib": 9.1}

    def predict(self, request: dict) -> tuple[dict, str]:
        self.calls.append(copy.deepcopy(request))
        answers = {}
        for field, question in request["questions"].items():
            ids = list(question["criteria"])
            probs = dict(zip(ids, softmax(self.scorer(field, question))))
            best = min(ids, key=lambda i: (-probs[i], i))
            answers[field] = {"type": "choice", "probabilities": probs, "confidence": probs[best],
                              "choice": best, "source": "local", "decision": best}
        response = {"answers": answers,
                    "usage": {"input_tokens": self.tokens_per_question * len(answers),
                              "output_tokens": len(answers), "decision_count": len(answers)},
                    "timing": {"inference_ms": 12.5}, "calibration": dict(CALIBRATION),
                    "model": "Intern-Decision-4B", "backend": "hf"}
        return response, request_sha(request)


def request_sha(request: dict) -> str:
    """Stands in for the real prompt hash: the same call always hashes the same."""
    return hashlib.sha256(json.dumps(request, sort_keys=True).encode()).hexdigest()