"""Strict scorer for Bilingual Patch Contracts (Apache-2.0, see LICENSE).

Same pass/fail rule as the published Kaggle task: the whole response must parse
as one JSON object with exactly the five keys, the required types, and every
expected value. No repair, fence stripping, regex extraction or model judge.

Differences from the task's scorer are diagnostic only and never turn a failing
response into a passing one:
- numbers that overflow (1e999 becomes inf, integers outside signed 64-bit)
  are rejected at parse time instead of failing later as a type or value error;
- pathologically deep nesting is reported as a parse failure instead of raising;
- each result carries a list of failure labels.
"""
import json
import math

KEYS = ('active', 'delay_minutes', 'note', 'route', 'tags')
ROUTES = {'email', 'sms', 'none'}
INT_MIN, INT_MAX = -(2 ** 63), 2 ** 63 - 1


class StrictParseError(ValueError):
    def __init__(self, label, detail):
        super().__init__(label + ':' + detail)
        self.label = label


def _unique_object(pairs):
    result = {}
    for key, value in pairs:
        if key in result:
            raise StrictParseError('duplicate-key', key)
        result[key] = value
    return result


def _reject_constant(token):
    raise StrictParseError('non-finite', token)


def _finite_float(token):
    value = float(token)
    if not math.isfinite(value):
        raise StrictParseError('overflow', token[:40])
    return value


def _bounded_int(token):
    if len(token.lstrip('-')) > 19:
        raise StrictParseError('overflow', token[:40])
    value = int(token)
    if not INT_MIN <= value <= INT_MAX:
        raise StrictParseError('overflow', token[:40])
    return value


def strict_loads(raw):
    """Parse one JSON document; raise StrictParseError on anything non-strict."""
    if not isinstance(raw, str):
        raise StrictParseError('not-text', type(raw).__name__)
    try:
        return json.loads(raw, object_pairs_hook=_unique_object, parse_constant=_reject_constant,
                          parse_float=_finite_float, parse_int=_bounded_int)
    except StrictParseError:
        raise
    except RecursionError:
        raise StrictParseError('too-deep', 'nesting') from None
    except ValueError as exc:
        raise StrictParseError('syntax', str(exc)) from None


VALIDATORS = {
    'route': lambda v: type(v) is str and v in ROUTES,
    'delay_minutes': lambda v: v is None or (type(v) is int and v >= 0),
    'active': lambda v: type(v) is bool,
    'tags': lambda v: type(v) is list and all(type(x) is str for x in v) and len(set(v)) == len(v),
    'note': lambda v: v is None or type(v) is str,
}


def score_response(raw, expected):
    result = {'json_valid': False, 'schema_valid': False, 'exact': False,
              'fields': {key: False for key in KEYS}, 'failures': [], 'error': None}
    try:
        parsed = strict_loads(raw)
    except StrictParseError as exc:
        result['failures'] = ['parse:' + exc.label]
        result['error'] = str(exc)
        return result
    result['json_valid'] = True
    if type(parsed) is not dict:
        result['failures'] = ['not-object:' + type(parsed).__name__]
        result['error'] = 'not-object'
        return result
    failures = []
    missing = [k for k in KEYS if k not in parsed]
    extra = sorted(k for k in parsed if k not in VALIDATORS)
    if missing:
        failures.append('schema:missing:' + ','.join(missing))
    if extra:
        failures.append('schema:extra:' + ','.join(extra))
    types_ok = True
    for key in KEYS:
        if key not in parsed:
            continue
        if not VALIDATORS[key](parsed[key]):
            types_ok = False
            failures.append('schema:type:' + key)
        elif parsed[key] != expected[key]:
            failures.append('value:' + key)
        else:
            result['fields'][key] = True
    result['schema_valid'] = not missing and not extra and types_ok
    result['exact'] = result['schema_valid'] and all(result['fields'].values())
    result['failures'] = failures
    if not result['exact']:
        result['error'] = 'schema-or-value-mismatch'
    return result