"""Small executable contracts for 25 batch-three design labs.

Local deterministic examples only; no external services, production cache,
distributed queue, authorization system or concurrency guarantee is supplied.
"""
from copy import deepcopy
from datetime import date
import json

CASES={}

class ContractError(ValueError):pass

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

@example('inject-clock-for-date-rules',{'today':'2027-01-10','due':'2027-01-12'},{'days_remaining':2})
def inject_clock_for_date_rules(payload):
    return {'days_remaining':(date.fromisoformat(payload['due'])-date.fromisoformat(payload['today'])).days}

@example('inject-identifier-factory',{'labels':['A','B'],'supplied_ids':['demo-01','demo-02']},{'records':[{'id':'demo-01','label':'A'},{'id':'demo-02','label':'B'}]})
def inject_identifier_factory(payload):
    identifiers=iter(payload['supplied_ids'])
    records=[{'id':next(identifiers),'label':label} for label in payload['labels']]
    return {'records':records}

@example('configuration-precedence',{'defaults':{'mode':'demo','limit':10},'environment':{'limit':20},'command':{'limit':5}},{'mode':'demo','limit':5})
def configuration_precedence(payload):
    resolved={}
    for layer in ['defaults','environment','command']:
        resolved.update(payload[layer])
    return resolved

@example('redact-declared-secret-fields',{'event':{'name':'demo','token':'fictional-token','password':'fictional-password'},'sensitive_keys':['token','password']},{'name':'demo','token':'[REDACTED]','password':'[REDACTED]'})
def redact_declared_secret_fields(payload):
    sensitive=set(payload['sensitive_keys'])
    return {key:'[REDACTED]' if key in sensitive else value for key,value in payload['event'].items()}

@example('propagate-correlation-context',{'context':{'correlation_id':'demo-trace-7'},'operations':['load','summarize']},{'events':[{'operation':'load','correlation_id':'demo-trace-7'},{'operation':'summarize','correlation_id':'demo-trace-7'}]})
def propagate_correlation_context(payload):
    return {'events':[{'operation':op,'correlation_id':payload['context']['correlation_id']} for op in payload['operations']]}

@example('separate-query-from-write',{'stored':[3,5],'write_count':0},{'total':8,'write_count':0,'stored':[3,5]})
def separate_query_from_write(payload):
    return {'total':sum(payload['stored']),'write_count':payload['write_count'],'stored':list(payload['stored'])}

@example('bounded-queue-admission',{'queue':['a','b','c'],'capacity':3,'item':'d'},{'accepted':False,'queue':['a','b','c']})
def bounded_queue_admission(payload):
    queue=list(payload['queue'])
    accepted=len(queue)<payload['capacity']
    if accepted:queue.append(payload['item'])
    return {'accepted':accepted,'queue':queue}

@example('retain-final-partial-chunk',{'records':['a','b','c','d','e'],'size':2},{'chunks':[['a','b'],['c','d'],['e']]})
def retain_final_partial_chunk(payload):
    size=payload['size']
    if type(size) is not int or size<=0:raise ContractError('positive-chunk-size-required')
    return {'chunks':[payload['records'][i:i+size] for i in range(0,len(payload['records']),size)]}

@example('bounded-retry-attempts',{'outcomes':[False,False,True],'max_attempts':3},{'succeeded':True,'attempts':3})
def bounded_retry_attempts(payload):
    for index,outcome in enumerate(payload['outcomes'][:payload['max_attempts']],start=1):
        if outcome:return {'succeeded':True,'attempts':index}
    return {'succeeded':False,'attempts':min(len(payload['outcomes']),payload['max_attempts'])}

@example('cancel-before-processing',{'cancelled':True,'records':['a','b']},{'processed':[],'cancelled':True})
def cancel_before_processing(payload):
    if payload['cancelled']:return {'processed':[],'cancelled':True}
    return {'processed':list(payload['records']),'cancelled':False}

@example('cursor-after-stable-key',{'records':[{'id':2},{'id':4},{'id':6}],'after':4,'limit':2},{'records':[{'id':6}]})
def cursor_after_stable_key(payload):
    ordered=sorted(payload['records'],key=lambda r:r['id'])
    return {'records':[r for r in ordered if r['id']>payload['after']][:payload['limit']]}

@example('explicit-schema-upgrade',{'version':1,'label':'Demo'},{'version':2,'display_name':'Demo'})
def explicit_schema_upgrade(payload):
    if payload['version']!=1:raise ContractError('unsupported-source-version')
    return {'version':2,'display_name':payload['label']}

@example('reject-unknown-input-fields',{'record':{'name':'Demo','unexpected':9},'allowed':['name']},{'error':'unknown-field'})
def reject_unknown_input_fields(payload):
    if set(payload['record'])-set(payload['allowed']):raise ContractError('unknown-field')
    return deepcopy(payload['record'])

@example('copy-nested-edit-state',{'stored':{'settings':{'theme':'light'}},'new_theme':'dark'},{'edited':{'settings':{'theme':'dark'}},'original':{'settings':{'theme':'light'}}})
def copy_nested_edit_state(payload):
    edited=deepcopy(payload['stored'])
    edited['settings']['theme']=payload['new_theme']
    return {'edited':edited,'original':deepcopy(payload['stored'])}

@example('validate-startup-configuration',{'config':{'host':'localhost'},'required':['host','port']},{'ready':False,'missing':['port']})
def validate_startup_configuration(payload):
    missing=sorted(set(payload['required'])-set(payload['config']))
    return {'ready':not missing,'missing':missing}

@example('namespace-cache-identity',{'records':[{'namespace':'team-a','id':'7'},{'namespace':'team-b','id':'7'}]},{'keys':[['team-a','7'],['team-b','7']],'distinct_keys':2})
def namespace_cache_identity(payload):
    keys=[(r['namespace'],r['id']) for r in payload['records']]
    return {'keys':[list(key) for key in keys],'distinct_keys':len(set(keys))}

@example('explicit-cache-expiry-boundary',{'now':100,'expires_at':100,'value':'demo'},{'hit':False,'value':None})
def explicit_cache_expiry_boundary(payload):
    hit=payload['now']<payload['expires_at']
    return {'hit':hit,'value':payload['value'] if hit else None}

@example('invalidate-cache-after-write',{'stored':{'a':1},'cache':{'a':1},'id':'a','new_value':2},{'stored':{'a':2},'cache':{},'next_read':2})
def invalidate_cache_after_write(payload):
    stored=deepcopy(payload['stored']);cache=deepcopy(payload['cache'])
    stored[payload['id']]=payload['new_value']
    cache.pop(payload['id'],None)
    return {'stored':stored,'cache':cache,'next_read':stored[payload['id']]}

@example('ordered-label-deduplication',['B','A','B','C'],{'labels':['B','A','C']})
def ordered_label_deduplication(values):
    seen=set();result=[]
    for value in values:
        if value not in seen:seen.add(value);result.append(value)
    return {'labels':result}

@example('ordered-locale-fallback',{'preferred':['hi-IN','en-IN'],'messages':{'en-IN':'Hello'}},{'locale':'en-IN','message':'Hello'})
def ordered_locale_fallback(payload):
    for locale in payload['preferred']:
        if locale in payload['messages']:return {'locale':locale,'message':payload['messages'][locale]}
    return {'locale':None,'message':None}

@example('declare-result-truncation',{'records':['a','b','c','d'],'limit':2},{'records':['a','b'],'total':4,'truncated':True})
def declare_result_truncation(payload):
    return {'records':payload['records'][:payload['limit']],'total':len(payload['records']),'truncated':len(payload['records'])>payload['limit']}

@example('normalize-text-line-endings','A\r\nB\rC\n',{'text':'A\nB\nC\n'})
def normalize_text_line_endings(text):
    return {'text':text.replace('\r\n','\n').replace('\r','\n')}

@example('explicit-utf8-round-trip','Jaipur जयपुर',{'text':'Jaipur जयपुर','round_trip':True})
def explicit_utf8_round_trip(text):
    encoded=text.encode('utf-8',errors='strict')
    decoded=encoded.decode('utf-8',errors='strict')
    return {'text':decoded,'round_trip':decoded==text}

def structural_depth(value):
    if isinstance(value,dict):return 1+max((structural_depth(v) for v in value.values()),default=0)
    if isinstance(value,list):return 1+max((structural_depth(v) for v in value),default=0)
    return 0

@example('limit-parsed-structure-depth',{'value':{'a':{'b':{'c':1}}},'maximum':2},{'accepted':False,'depth':3})
def limit_parsed_structure_depth(payload):
    depth=structural_depth(payload['value'])
    return {'accepted':depth<=payload['maximum'],'depth':depth}

@example('count-lookup-operations',{'records':[{'id':'a'},{'id':'b'},{'id':'c'}],'queries':['c','a']},{'scan_comparisons':4,'index_build_records':3,'indexed_lookups':2,'matches':['c','a']})
def count_lookup_operations(payload):
    comparisons=0;matches=[]
    for query in payload['queries']:
        for record in payload['records']:
            comparisons+=1
            if record['id']==query:matches.append(query);break
    index={r['id']:r for r in payload['records']}
    indexed=[query for query in payload['queries'] if query in index]
    if matches!=indexed:raise ContractError('lookup-results-disagree')
    return {'scan_comparisons':comparisons,'index_build_records':len(payload['records']),'indexed_lookups':len(payload['queries']),'matches':matches}

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():
    results=[]
    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,'input mutated')
        results.append({'case':key,'status':'passed','actual':actual})
    assert len(results)==25
    return results

def run_additional_checks():
    checks=[
        ('retry-stops-at-limit',bounded_retry_attempts,{'outcomes':[False,False,True],'max_attempts':2},{'succeeded':False,'attempts':2}),
        ('queue-has-room',bounded_queue_admission,{'queue':['a'],'capacity':2,'item':'b'},{'accepted':True,'queue':['a','b']}),
        ('unexpired-cache',explicit_cache_expiry_boundary,{'now':99,'expires_at':100,'value':'demo'},{'hit':True,'value':'demo'}),
        ('empty-chunks',retain_final_partial_chunk,{'records':[],'size':2},{'chunks':[]}),
        ('invalid-chunk-size',retain_final_partial_chunk,{'records':['a'],'size':0},{'error':'positive-chunk-size-required'}),
        ('locale-absent',ordered_locale_fallback,{'preferred':['hi-IN'],'messages':{}},{'locale':None,'message':None}),
        ('unneeded-truncation',declare_result_truncation,{'records':['a'],'limit':2},{'records':['a'],'total':1,'truncated':False}),
        ('allowed-depth',limit_parsed_structure_depth,{'value':{'a':{'b':1}},'maximum':2},{'accepted':True,'depth':2}),
    ]
    results=[]
    for key,function,payload,expected in checks:
        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=True))