"""Inspect a saved Responses body offline; never sends requests or reads keys."""

import argparse
import json
from decimal import Decimal
from pathlib import Path


MODEL = "muse-wonder-1.0"
RATES = {"input": Decimal("4"), "cached": Decimal("0.20"), "output": Decimal("20")}
RATE_DATE = "2026-10-14"


def token_count(value, label):
    if type(value) is not int or value < 0:
        raise ValueError(f"{label} must be a nonnegative integer")
    return value


def token_cost(input_tokens, output_tokens, cached_tokens):
    total = token_count(input_tokens, "input_tokens")
    output = token_count(output_tokens, "output_tokens")
    cached = token_count(cached_tokens, "cached_tokens")
    if cached > total:
        raise ValueError("cached_tokens cannot exceed total input_tokens")
    return ((total - cached) * RATES["input"] + cached * RATES["cached"]
            + output * RATES["output"]) / Decimal(1000000)


def cost_bounds(usage):
    if not isinstance(usage, dict):
        raise ValueError("usage is missing or not an object")
    total = token_count(usage.get("input_tokens"), "input_tokens")
    output = token_count(usage.get("output_tokens"), "output_tokens")
    if "total_tokens" in usage:
        reported = token_count(usage["total_tokens"], "total_tokens")
        if reported != total + output:
            raise ValueError("total_tokens is inconsistent with input plus output")
    output_details = usage.get("output_tokens_details")
    if output_details is not None and not isinstance(output_details, dict):
        raise ValueError("output_tokens_details must be an object when present")
    if isinstance(output_details, dict) and "reasoning_tokens" in output_details:
        reasoning = token_count(output_details["reasoning_tokens"], "reasoning_tokens")
        if reasoning > output:
            raise ValueError("reasoning_tokens cannot exceed total output_tokens")
    details = usage.get("input_tokens_details")
    if details is not None and not isinstance(details, dict):
        raise ValueError("input_tokens_details must be an object when present")
    if isinstance(details, dict) and "cached_tokens" in details:
        amount = token_cost(total, output, details["cached_tokens"])
        return {"evidence": "CACHE_COUNT_PRESENT", "min_usd": str(amount), "max_usd": str(amount)}
    return {"evidence": "CACHE_COUNT_MISSING", "min_usd": str(token_cost(total, output, total)),
            "max_usd": str(token_cost(total, output, 0))}


def inspect_response(response):
    if not isinstance(response, dict):
        raise ValueError("response must be an object")
    if response.get("model") != MODEL:
        raise ValueError("unexpected reported model identifier")
    if response.get("status") != "completed":
        raise ValueError("response is not completed")
    if response.get("error") is not None or response.get("incomplete_details") is not None:
        raise ValueError("response contains error or incomplete details")
    items = response.get("output")
    if not isinstance(items, list) or not items:
        raise ValueError("output is missing or empty")
    texts = []
    for item in items:
        if not isinstance(item, dict):
            raise ValueError("output item must be an object")
        if item.get("type") == "reasoning":
            continue
        if (item.get("type") != "message" or item.get("role") != "assistant"
                or item.get("status") != "completed"):
            raise ValueError("unexpected or unfinished output item")
        content = item.get("content")
        if not isinstance(content, list) or not content:
            raise ValueError("assistant content is missing")
        for block in content:
            if (not isinstance(block, dict) or block.get("type") != "output_text"
                    or not isinstance(block.get("text"), str)):
                raise ValueError("refusal, unsupported content or malformed text")
            texts.append(block["text"])
    if "".join(texts).strip() != "READY":
        raise ValueError("probe text does not match the READY contract")
    return {"state": "PROBE_CONTRACT_MATCH", "reported_model": MODEL,
            "rates_checked": RATE_DATE, "token_cost_bounds": cost_bounds(response.get("usage")),
            "excludes": ["search", "external tools", "retries", "taxes", "provider adjustments"],
            "note": "Offline body checks, not authenticated identity, inference or billing proof"}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("response", type=Path, help="Saved JSON body; treated as data only")
    args = parser.parse_args()
    try:
        result = inspect_response(json.loads(args.response.read_text()))
    except (ValueError, OSError) as error:
        parser.exit(1, f"REVIEW_REQUIRED: {error}\n")
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()