"""Executable Python reference contracts for the 50 batch-two editorial cases.

These are deliberately small local examples, not production implementations of
transactions, distributed locks, HTTP services or any of the other 39 runtimes.
"""
from copy import deepcopy
import csv
from datetime import date, datetime, timezone
from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
import html
import io
import json
import math
import unicodedata
from urllib.parse import urlencode

CASES = {}

class ContractError(ValueError):
    pass

def number(value):
    if isinstance(value, bool):
        raise ContractError('number-required')
    if value is None or (isinstance(value, str) and not value.strip()):
        raise ContractError('number-required')
    try:
        result = Decimal(str(value).strip())
    except (InvalidOperation, ValueError):
        raise ContractError('number-required')
    if not result.is_finite():
        raise ContractError('finite-number-required')
    return result

def instant(value):
    try:
        result = datetime.fromisoformat(value.replace('Z', '+00:00'))
    except ValueError:
        raise ContractError('invalid-timestamp')
    if result.tzinfo is None:
        raise ContractError('timezone-required')
    return result.astimezone(timezone.utc)

def example(key, payload, expected):
    def register(function):
        CASES[key] = {'id':key,'input':payload,'expected':expected,'function':function}
        return function
    return register

@example('numeric-string-order', ['10','2','30'], [2,10,30])
def numeric_string_order(values):
    parsed = [number(v) for v in values]
    if any(n != n.to_integral_value() for n in parsed):
        raise ContractError('whole-number-required')
    return [int(n) for n in sorted(parsed)]

@example('missing-versus-zero', [None,0,12], {'sum':12,'present_count':2,'missing_count':1})
def missing_versus_zero(values):
    present = [number(v) for v in values if v is not None]
    return {'sum':int(sum(present)), 'present_count':len(present), 'missing_count':len(values)-len(present)}

@example('empty-average', [], {'value':None,'count':0})
def empty_average(values):
    if not values:
        return {'value':None,'count':0}
    parsed = [number(v) for v in values]
    return {'value':float(sum(parsed)/len(parsed)), 'count':len(parsed)}

@example('duplicate-record-id', [{'id':'a','value':4},{'id':'a','value':6}], {'error':'duplicate-id'})
def duplicate_record_id(records):
    seen = set()
    for record in records:
        if record['id'] in seen:
            raise ContractError('duplicate-id')
        seen.add(record['id'])
    return {'count':len(records)}

@example('status-normalization', [{'status':' APPROVED ','value':12},{'status':'approved','value':15},{'status':'cancelled','value':90}], {'sum':27,'count':2})
def status_normalization(records):
    selected = [r for r in records if r['status'].strip().casefold() == 'approved']
    return {'sum':sum(r['value'] for r in selected),'count':len(selected)}

@example('label-whitespace-case', {'records':[{'topic':'Python ','value':12},{'topic':'python','value':18},{'topic':'Java','value':30}],'filter':' PYTHON '}, {'sum':30,'count':2})
def label_whitespace_case(payload):
    key = payload['filter'].strip().casefold()
    rows = [r for r in payload['records'] if r['topic'].strip().casefold() == key]
    return {'sum':sum(r['value'] for r in rows),'count':len(rows)}

@example('empty-filter-policy', {'values':[12,18],'filter':''}, {'sum':30,'count':2})
def empty_filter_policy(payload):
    if payload['filter'] != '':
        raise ContractError('unsupported-filter')
    return {'sum':sum(payload['values']),'count':len(payload['values'])}

@example('unknown-filter-result', {'records':[{'topic':'A','value':12}],'filter':'Z'}, {'sum':0,'count':0})
def unknown_filter_result(payload):
    rows = [r for r in payload['records'] if r['topic'] == payload['filter']]
    return {'sum':sum(r['value'] for r in rows),'count':len(rows)}

@example('multi-filter-union', {'records':[{'topic':'A','value':5},{'topic':'B','value':7},{'topic':'A','value':9}],'filters':['A','B','A']}, {'sum':21,'count':3})
def multi_filter_union(payload):
    allowed = set(payload['filters'])
    rows = [r for r in payload['records'] if r['topic'] in allowed]
    return {'sum':sum(r['value'] for r in rows),'count':len(rows)}

@example('inclusive-number-boundaries', {'values':[10,20,30],'minimum':10,'maximum':20}, {'values':[10,20],'sum':30})
def inclusive_number_boundaries(payload):
    selected = [v for v in payload['values'] if payload['minimum'] <= v <= payload['maximum']]
    return {'values':selected,'sum':sum(selected)}

@example('half-open-date-range', {'records':[{'date':'2027-02-01','value':5},{'date':'2027-02-28','value':6},{'date':'2027-03-01','value':9}],'start':'2027-02-01','end':'2027-03-01'}, {'sum':11,'count':2})
def half_open_date_range(payload):
    start,end = date.fromisoformat(payload['start']),date.fromisoformat(payload['end'])
    rows = [r for r in payload['records'] if start <= date.fromisoformat(r['date']) < end]
    return {'sum':sum(r['value'] for r in rows),'count':len(rows)}

@example('same-instant-offsets', ['2027-01-01T09:00:00+05:30','2027-01-01T03:30:00Z'], {'same_instant':True})
def same_instant_offsets(values):
    return {'same_instant':instant(values[0]) == instant(values[1])}

@example('invalid-calendar-date', '2027-02-30', {'error':'invalid-date'})
def invalid_calendar_date(value):
    try:
        return {'date':date.fromisoformat(value).isoformat()}
    except ValueError:
        raise ContractError('invalid-date')

@example('missing-timezone', '2027-01-01T09:00:00', {'error':'timezone-required'})
def missing_timezone(value):
    return {'utc':instant(value).isoformat()}

@example('whole-number-quantity', '2.5', {'error':'whole-positive-quantity-required'})
def whole_number_quantity(value):
    parsed = number(value)
    if parsed <= 0 or parsed != parsed.to_integral_value():
        raise ContractError('whole-positive-quantity-required')
    return {'quantity':int(parsed)}

@example('decimal-addition', ['0.1','0.2'], {'sum':'0.3'})
def decimal_addition(values):
    return {'sum':str(sum((number(v) for v in values), Decimal('0')))}

@example('round-after-aggregation', ['1.005','1.005'], {'rounded_sum':'2.01'})
def round_after_aggregation(values):
    total = sum((number(v) for v in values), Decimal('0'))
    return {'rounded_sum':str(total.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))}

@example('mixed-storage-units', [{'value':1,'unit':'KB'},{'value':1,'unit':'KiB'}], {'bytes':2024})
def mixed_storage_units(records):
    factors = {'KB':1000,'KiB':1024}
    if any(r['unit'] not in factors for r in records):
        raise ContractError('unknown-unit')
    return {'bytes':sum(r['value']*factors[r['unit']] for r in records)}

@example('negative-quantity', -3, {'error':'positive-quantity-required'})
def negative_quantity(value):
    parsed = number(value)
    if parsed <= 0:
        raise ContractError('positive-quantity-required')
    return {'quantity':float(parsed)}

@example('non-finite-number', 'NaN', {'error':'finite-number-required'})
def non_finite_number(value):
    return {'number':float(number(value))}

@example('identifier-leading-zeroes', ['001','1'], {'distinct_ids':2,'ids':['001','1']})
def identifier_leading_zeroes(values):
    if not all(isinstance(v,str) for v in values):
        raise ContractError('string-id-required')
    return {'distinct_ids':len(set(values)),'ids':list(values)}

@example('deterministic-tie-break', [{'id':'b','score':10},{'id':'a','score':10},{'id':'c','score':5}], {'ids':['a','b','c']})
def deterministic_tie_break(records):
    ordered = sorted(records,key=lambda r:(-r['score'],r['id']))
    return {'ids':[r['id'] for r in ordered]}

@example('filter-before-pagination', {'records':[{'id':1,'status':'active'},{'id':2,'status':'pending'},{'id':3,'status':'active'},{'id':4,'status':'active'}],'size':2}, {'ids':[1,3],'matching_total':3})
def filter_before_pagination(payload):
    filtered = [r for r in payload['records'] if r['status']=='active']
    return {'ids':[r['id'] for r in filtered[:payload['size']]],'matching_total':len(filtered)}

@example('rows-versus-distinct-people', ['person-1','person-1','person-2'], {'attendance_actions':3,'distinct_people':2})
def rows_versus_distinct_people(values):
    return {'attendance_actions':len(values),'distinct_people':len(set(values))}

@example('weighted-mean', [{'value':10,'weight':1},{'value':20,'weight':3}], {'weighted_mean':17.5,'weight_total':4})
def weighted_mean(records):
    denominator = sum(r['weight'] for r in records)
    numerator = sum(r['value']*r['weight'] for r in records)
    return {'weighted_mean':numerator/denominator if denominator else None,'weight_total':denominator}

@example('combine-group-averages', [{'mean':10,'count':1},{'mean':20,'count':3}], {'combined_mean':17.5,'count':4})
def combine_group_averages(records):
    count = sum(r['count'] for r in records)
    return {'combined_mean':sum(r['mean']*r['count'] for r in records)/count if count else None,'count':count}

@example('percentage-denominator', {'selected':3,'total':10}, {'percentage':30.0})
def percentage_denominator(payload):
    return {'percentage':100*payload['selected']/payload['total'] if payload['total'] else None}

@example('parent-child-double-count', {'parents':[{'id':'p1','value':100}],'children':[{'parent_id':'p1'},{'parent_id':'p1'}]}, {'parent_total':100,'child_count':2})
def parent_child_double_count(payload):
    return {'parent_total':sum(r['value'] for r in payload['parents']),'child_count':len(payload['children'])}

@example('orphan-reference', {'parent_ids':['p1'],'children':[{'parent_id':'p2'}]}, {'error':'orphan-reference'})
def orphan_reference(payload):
    known = set(payload['parent_ids'])
    if any(r['parent_id'] not in known for r in payload['children']):
        raise ContractError('orphan-reference')
    return {'count':len(payload['children'])}

@example('composite-uniqueness', [{'session':'s1','person':'p1'},{'session':'s1','person':'p1'}], {'error':'duplicate-composite-key'})
def composite_uniqueness(records):
    keys = [(r['session'],r['person']) for r in records]
    if len(keys) != len(set(keys)):
        raise ContractError('duplicate-composite-key')
    return {'count':len(keys)}

@example('state-transition-rules', {'current':'cancelled','requested':'approved'}, {'error':'transition-not-allowed'})
def state_transition_rules(payload):
    allowed = {'requested':{'approved','cancelled'},'approved':{'cancelled'},'cancelled':set()}
    if payload['requested'] not in allowed.get(payload['current'],set()):
        raise ContractError('transition-not-allowed')
    return {'status':payload['requested']}

@example('idempotent-retry', [{'request_id':'r1','delta':5},{'request_id':'r1','delta':5}], {'value':5,'applied_requests':1})
def idempotent_retry(events):
    seen = set();value = 0
    for event in events:
        if event['request_id'] not in seen:
            value += event['delta'];seen.add(event['request_id'])
    return {'value':value,'applied_requests':len(seen)}

@example('optimistic-version-conflict', {'expected_version':2,'stored_version':3,'stored_value':9,'new_value':10}, {'error':'version-conflict'})
def optimistic_version_conflict(payload):
    if payload['expected_version'] != payload['stored_version']:
        raise ContractError('version-conflict')
    return {'value':payload['new_value'],'version':payload['stored_version']+1}

@example('atomic-batch-validation', [{'quantity':2},{'quantity':-1}], {'error':'invalid-quantity','stored':[]})
def atomic_batch_validation(records):
    if any(number(r['quantity'])<=0 for r in records):
        return {'error':'invalid-quantity','stored':[]}
    return {'stored':deepcopy(records)}

@example('omitted-versus-null-patch', {'stored':{'status':'approved','note':'draft'},'patch':{'note':None}}, {'status':'approved','note':None})
def omitted_versus_null_patch(payload):
    updated = deepcopy(payload['stored'])
    updated.update(payload['patch'])
    return updated

@example('non-mutating-sort', [3,1,2], {'sorted':[1,2,3],'original':[3,1,2]})
def non_mutating_sort(values):
    ordered = sorted(values)
    return {'sorted':ordered,'original':list(values)}

@example('quoted-csv-records', 'name,note\n"Demo, A","line one\nline two"\nB,plain\n', {'records':2,'first_name':'Demo, A','first_note':'line one\nline two'})
def quoted_csv_records(text):
    rows = list(csv.DictReader(io.StringIO(text,newline='')))
    return {'records':len(rows),'first_name':rows[0]['name'],'first_note':rows[0]['note']}

@example('blank-csv-record-policy', 'name,note\n\nA,\n', {'records':1,'note':''})
def blank_csv_record_policy(text):
    rows = [row for row in csv.reader(io.StringIO(text,newline='')) if row]
    header,*records = rows
    objects = [dict(zip(header,row)) for row in records]
    return {'records':len(objects),'note':objects[0]['note']}

@example('unicode-normalization', ['e\u0301','\u00e9'], {'equal_after_nfc':True,'distinct_labels':1})
def unicode_normalization(values):
    normalized = [unicodedata.normalize('NFC',v) for v in values]
    return {'equal_after_nfc':normalized[0]==normalized[1],'distinct_labels':len(set(normalized))}

@example('exact-versus-substring-filter', {'labels':['Java','JavaScript'],'filter':'Java'}, {'matches':['Java']})
def exact_versus_substring_filter(payload):
    return {'matches':[v for v in payload['labels'] if v==payload['filter']]}

@example('escape-display-text', '<strong>Demo</strong>', {'escaped':'&lt;strong&gt;Demo&lt;/strong&gt;'})
def escape_display_text(value):
    return {'escaped':html.escape(value,quote=True)}

@example('encode-query-values', 'C++ & SQL', {'query':'topic=C%2B%2B+%26+SQL'})
def encode_query_values(value):
    return {'query':urlencode({'topic':value})}

@example('strict-boolean-input', 'false', {'error':'boolean-required'})
def strict_boolean_input(value):
    if type(value) is not bool:
        raise ContractError('boolean-required')
    return {'enabled':value}

@example('boolean-is-not-a-quantity', True, {'error':'number-required'})
def boolean_is_not_a_quantity(value):
    return {'quantity':float(number(value))}

@example('missing-values-sort-last', [None,5,2], {'values':[2,5,None]})
def missing_values_sort_last(values):
    return {'values':sorted(values,key=lambda v:(v is None,v if v is not None else 0))}

@example('chronological-timestamp-sort', [{'id':'a','at':'2027-01-01T10:00:00+05:30'},{'id':'b','at':'2027-01-01T06:00:00Z'}], {'ids':['a','b']})
def chronological_timestamp_sort(records):
    return {'ids':[r['id'] for r in sorted(records,key=lambda r:instant(r['at']))]}

@example('exact-capacity-boundary', {'available':5,'requested':5}, {'accepted':True,'remaining':0})
def exact_capacity_boundary(payload):
    accepted = payload['requested'] <= payload['available']
    return {'accepted':accepted,'remaining':payload['available']-payload['requested'] if accepted else payload['available']}

@example('blank-numeric-input', '   ', {'error':'number-required'})
def blank_numeric_input(value):
    return {'number':float(number(value))}

@example('preserve-duration-precision', {'milliseconds':1500}, {'seconds':1.5})
def preserve_duration_precision(payload):
    return {'seconds':payload['milliseconds']/1000}

@example('page-beyond-last-result', {'records':['a','b','c'],'page':3,'size':2}, {'records':[],'total':3,'pages':2,'page':3})
def page_beyond_last_result(payload):
    start = (payload['page']-1)*payload['size']
    return {'records':payload['records'][start:start+payload['size']], 'total':len(payload['records']), 'pages':math.ceil(len(payload['records'])/payload['size']), 'page':payload['page']}

@example('idempotency-payload-conflict', [{'request_id':'r1','delta':5},{'request_id':'r1','delta':9}], {'error':'idempotency-payload-conflict'})
def idempotency_payload_conflict(events):
    seen = {}
    for event in events:
        key = event['request_id']
        if key in seen and seen[key] != event['delta']:
            raise ContractError('idempotency-payload-conflict')
        seen[key] = event['delta']
    return {'value':sum(seen.values()),'applied_requests':len(seen)}

@example('csv-column-count-mismatch', 'name,note\nA,x,y\n', {'error':'column-count-mismatch'})
def csv_column_count_mismatch(text):
    rows = list(csv.reader(io.StringIO(text,newline='')))
    header,*records = rows
    if any(len(row) != len(header) for row in records):
        raise ContractError('column-count-mismatch')
    return {'records':len(records)}

def execute(function,payload,copy_input=True):
    try:
        return function(deepcopy(payload) if copy_input else payload)
    except ContractError as error:
        return {'error':str(error)}

def run_checks():
    outcomes=[]
    for key,case in CASES.items():
        supplied=deepcopy(case['input'])
        before=deepcopy(supplied)
        actual=execute(case['function'],supplied,copy_input=False)
        assert json.dumps(actual,sort_keys=True)==json.dumps(case['expected'],sort_keys=True),(key,actual,case['expected'])
        assert supplied==before,(key,'fixture mutated')
        outcomes.append({'case':key,'status':'passed','actual':actual})
    assert len(outcomes)==52
    return outcomes

def run_additional_checks():
    examples = [
        ('fraction-not-truncated',numeric_string_order,['2.5'],{'error':'whole-number-required'}),
        ('nonempty-average',empty_average,[2,4],{'value':3.0,'count':2}),
        ('positive-whole-count',whole_number_quantity,2,{'quantity':2}),
        ('zero-denominator',percentage_denominator,{'selected':0,'total':0},{'percentage':None}),
        ('allowed-transition',state_transition_rules,{'current':'approved','requested':'cancelled'},{'status':'cancelled'}),
        ('matching-version',optimistic_version_conflict,{'expected_version':3,'stored_version':3,'stored_value':9,'new_value':10},{'value':10,'version':4}),
        ('valid-batch',atomic_batch_validation,[{'quantity':2},{'quantity':1}],{'stored':[{'quantity':2},{'quantity':1}]}),
        ('real-false',strict_boolean_input,False,{'enabled':False}),
        ('distinct-retries',idempotent_retry,[{'request_id':'r1','delta':5},{'request_id':'r2','delta':9}],{'value':14,'applied_requests':2}),
        ('correct-csv-width',csv_column_count_mismatch,'name,note\nA,x\n',{'records':1}),
    ]
    results=[]
    for key,function,payload,expected in examples:
        supplied=deepcopy(payload);before=deepcopy(supplied)
        actual=execute(function,supplied,copy_input=False)
        assert json.dumps(actual,sort_keys=True)==json.dumps(expected,sort_keys=True),(key,actual,expected)
        assert supplied==before
        results.append({'check':key,'status':'passed','actual':actual})
    return results

if __name__=='__main__':
    print(json.dumps({'checks':run_checks(),'additional_checks':run_additional_checks()},indent=2,ensure_ascii=False))