"""askmdb model output contract v1 in Python: the strict parser of the askmdb binary.

Mirrors the binary's parser (parse_response) and its stop rule (the generation is cut after the
top-level '}'). Standard library plus bson (pymongo).

Known differences with the binary (none changes a verdict):
- A stage that is not an object with exactly one key is rejected here as invalid_schema; the
  binary's parser accepts it and the verifier blocks it (B-STAGE-SHAPE).
- Repeated keys inside the pipeline: like the binary, they are not a parse error (the verifier
  blocks them, B-DUP-KEY). The decoded pipeline keeps the last value; use
  pipeline_has_duplicate_keys(raw) to see them.
- libbson reads a few legacy Extended JSON forms that bson.json_util leaves as plain documents
  (e.g. {"$type": "double"} as a legacy binary). The verifier blocks those anyway.
"""

import datetime
import json
import math
import re
import sys
from pathlib import Path

from bson import json_util  # noqa: E402
from bson.json_util import JSONMode, JSONOptions  # noqa: E402

CONTRACT_VERSION = 1
MAX_OUT_TOKENS = 384  # generation cap of the askmdb binary
MAX_RAW_BYTES = 8 * 1024
MAX_EXPLANATION_BYTES = 400
MAX_STAGES = 20
KEYS = ("type", "collection", "pipeline", "explanation")
TYPES = ("query", "refuse", "unsure")

# Relaxed Extended JSON decoded to native BSON types, dates as aware UTC datetimes.
JSON_OPTIONS = JSONOptions(json_mode=JSONMode.RELAXED, tz_aware=True, tzinfo=datetime.timezone.utc)

_ASCII_WS = " \t\n\r\f\v"  # trim_ascii in parser.cpp
_TRACKER_WS = " \t\n\r"  # JsonTracker: blanks allowed before '{'
_INT64_MIN, _INT64_MAX = -(2 ** 63), 2 ** 63 - 1


class _Obj(list):
    """A JSON object as its ordered (key, value) pairs, so repeated keys stay visible."""


def _reject_constant(name):
    raise ValueError("invalid constant " + name)


def _parse_float(s):
    v = float(s)
    if not math.isfinite(v):  # nlohmann: out_of_range 406 (e.g. 1e999)
        raise ValueError("number overflow")
    return v


def _strings(v):
    """Every string of a parsed value, keys included."""
    if isinstance(v, str):
        yield v
    elif isinstance(v, _Obj):
        for k, x in v:
            yield k
            yield from _strings(x)
    elif isinstance(v, list):
        for x in v:
            yield from _strings(x)


def _has_control(s):
    """C0, DEL and C1 (U+0080-U+009F), as has_control in parser.cpp."""
    return any(ord(c) < 0x20 or 0x7F <= ord(c) <= 0x9F for c in s)


def _has_surrogate(s):
    return any(0xD800 <= ord(c) <= 0xDFFF for c in s)


def _nbytes(s):
    return len(s.encode("utf-8"))


def _ints_out_of_range(v):
    """libbson cannot read integers outside int64."""
    if isinstance(v, bool):
        return False
    if isinstance(v, int):
        return not _INT64_MIN <= v <= _INT64_MAX
    if isinstance(v, _Obj):
        return any(_ints_out_of_range(x) for _, x in v)
    if isinstance(v, list):
        return any(_ints_out_of_range(x) for x in v)
    return False


def _has_dup(v):
    if isinstance(v, _Obj):
        keys = [k for k, _ in v]
        if len(keys) != len(set(keys)):
            return True
        return any(_has_dup(x) for _, x in v)
    if isinstance(v, list):
        return any(_has_dup(x) for x in v)
    return False


def _load(text):
    """json.loads with nlohmann's strictness. Raises ValueError on anything nlohmann rejects."""
    doc = json.loads(text, object_pairs_hook=_Obj, parse_constant=_reject_constant,
                     parse_float=_parse_float)
    if any(_has_surrogate(s) for s in _strings(doc)):  # lone \uD800: not valid UTF-8
        raise ValueError("invalid surrogate")
    return doc


def _decode(v):
    """Parsed pairs -> native BSON types (relaxed Extended JSON), key order kept, last repeat wins."""
    if isinstance(v, _Obj):
        return json_util.object_pairs_hook([(k, _decode(x)) for k, x in v], JSON_OPTIONS)
    if isinstance(v, list):
        return [_decode(x) for x in v]
    return v


def decode_ejson(value):
    """Relaxed Extended JSON already loaded with json.loads (e.g. a reference pipeline from a JSONL)
    -> native BSON types. Values that are already native pass through."""
    if isinstance(value, dict):
        return json_util.object_pairs_hook([(k, decode_ejson(x)) for k, x in value.items()],
                                           JSON_OPTIONS)
    if isinstance(value, list):
        return [decode_ejson(x) for x in value]
    return value


def parse_response(raw):
    """Strict parser of the model output, same checks and order as parser.cpp.

    Returns (obj, None) or (None, "invalid_json" | "invalid_schema"). obj has the four keys in
    order; obj["pipeline"] is decoded to native BSON types (datetime in UTC, ObjectId, Decimal128).
    """
    if not isinstance(raw, str):
        return None, "invalid_json"
    try:
        if _nbytes(raw) > MAX_RAW_BYTES:
            return None, "invalid_json"
    except UnicodeEncodeError:
        return None, "invalid_json"

    try:
        doc = _load(raw)
    except (ValueError, RecursionError):
        return None, "invalid_json"
    if not isinstance(doc, _Obj):
        return None, "invalid_json"

    if [k for k, _ in doc] != list(KEYS):  # repeated, unexpected, out of order or missing
        return None, "invalid_schema"
    if any(_has_control(s) for s in _strings(doc)):
        return None, "invalid_schema"

    values = dict(doc)
    kind, collection = values["type"], values["collection"]
    pipeline, explanation = values["pipeline"], values["explanation"]
    if not isinstance(kind, str) or not isinstance(collection, str):
        return None, "invalid_schema"
    if not isinstance(pipeline, list) or isinstance(pipeline, _Obj):
        return None, "invalid_schema"
    if not isinstance(explanation, str):
        return None, "invalid_schema"

    if kind == "query":
        # A stage that is not a one-key object passes, as in parser.cpp: the verifier blocks it
        # (B-STAGE-SHAPE; see bad_stage_shape).
        if not collection or not pipeline or len(pipeline) > MAX_STAGES:
            return None, "invalid_schema"
    elif kind in ("refuse", "unsure"):
        if collection or pipeline:
            return None, "invalid_schema"
    else:
        return None, "invalid_schema"

    if not explanation.strip(_ASCII_WS) or _nbytes(explanation) > MAX_EXPLANATION_BYTES:
        return None, "invalid_schema"

    # Step 2 of parser.cpp: what libbson cannot read is invalid_json.
    if _ints_out_of_range(pipeline):
        return None, "invalid_json"
    try:
        decoded = _decode(pipeline)
    except Exception:  # bad $oid, $date, $numberDecimal...: libbson would not read them either
        return None, "invalid_json"
    return {"type": kind, "collection": collection, "pipeline": decoded,
            "explanation": explanation}, None


def bad_stage_shape(pipeline):
    """True if a stage of a decoded pipeline is not a one-key object (B-STAGE-SHAPE of the verifier).

    A stage with a repeated key decodes to one key; pipeline_has_duplicate_keys covers it.
    """
    return any(not isinstance(st, dict) or len(st) != 1 for st in pipeline)


def pipeline_has_duplicate_keys(raw):
    """True if any object inside the pipeline of a contract-valid raw output repeats a key.

    The binary passes them to the verifier, which blocks the query (B-DUP-KEY); the decoded
    pipeline of parse_response only keeps the last value.
    """
    try:
        doc = _load(raw)
    except (ValueError, RecursionError):
        return False
    if not isinstance(doc, _Obj):
        return False
    return any(k == "pipeline" and _has_dup(v) for k, v in doc)


def cut_with_status(text):
    """JsonTracker over the whole text. Returns (cut, status):
      "done"       cut ends at the '}' that closes the top-level object;
      "invalid"    the first non-blank character is not '{' (cut ends at that character);
      "incomplete" the object never closes (cut is the whole text).
    Leading blanks (' ', '\\t', '\\n', '\\r') are kept, as the binary's raw keeps them.
    Brackets are ignored; braces inside strings do not count.
    """
    depth = 0
    in_string = escape = False
    for i, c in enumerate(text):
        if depth == 0:
            if c in _TRACKER_WS:
                continue
            if c != "{":
                return text[:i + 1], "invalid"
            depth = 1
            continue
        if in_string:
            if escape:
                escape = False
            elif c == "\\":
                escape = True
            elif c == '"':
                in_string = False
            continue
        if c == '"':
            in_string = True
        elif c == "{":
            depth += 1
        elif c == "}":
            depth -= 1
            if depth == 0:
                return text[:i + 1], "done"
    return text, "incomplete"


def cut_first_object(text):
    """The binary's stop rule (json_tracker.hpp): text up to the top-level closing '}'."""
    return cut_with_status(text)[0]


def to_raw(obj):
    """Compact contract output: the four keys in order, pipeline in relaxed Extended JSON."""
    pipeline = json.loads(json_util.dumps(obj["pipeline"], json_options=json_util.RELAXED_JSON_OPTIONS))
    out = {"type": obj["type"], "collection": obj["collection"], "pipeline": pipeline,
           "explanation": obj["explanation"]}
    return json.dumps(out, ensure_ascii=False, separators=(",", ":"))