"""Controller-only adapters to the existing independent domain oracles."""
from copy import deepcopy
from pathlib import Path
import importlib.util
import sys
import json

def load(name,path):
    spec=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(spec)
    sys.modules[name]=m;spec.loader.exec_module(m);return m

class Bundle:
    def __init__(self,path,slot):
        self.path=Path(path);self.slot=slot;key=slot+'_'+str(abs(hash(str(self.path))))
        self.aws=slot=='aws_release_v1'
        self.runtime=load('runtime_'+key,self.path/('environment/runtime.py' if self.aws else 'runtime.py'))
        self.reference=load('reference_'+key,self.path/'private/reference.py')
        self.oracle=load('oracle_'+key,self.path/'private/oracle.py')
        self.task=json.loads((self.path/('public/task.json' if self.aws else 'public/public_task.json')).read_text())
    def transition(self,state,name,args):
        if self.aws:return {'state':deepcopy(state),'observation':self.runtime.call_tool(deepcopy(state),name,deepcopy(args))}
        return self.runtime.transition(self.path/'environment',state,name,args)
    def solve(self,initial):
        state=deepcopy(initial);events=[]
        def call(name,args):
            nonlocal state
            step=self.transition(state,name,deepcopy(args));state=step['state'];obs=deepcopy(step['observation'])
            events.append({'tool':name,'arguments':deepcopy(args),'observation':deepcopy(obs)})
            return obs
        answer=self.reference.solve(call,self.task['context'] if self.aws else deepcopy(self.task))
        return answer,events,state
    def grade(self,initial,answer,events,final_state):
        # Authenticity and atomic effects are checked here even when a legacy
        # oracle's own checks only inspect subsets of the trace/state.
        state=deepcopy(initial)
        for e in events:
            actual=self.transition(state,e['tool'],e['arguments']);state=actual['state']
            if actual['observation']!=e['observation']:return {'passed':False,'errors':['forged_observation']}
        if state!=final_state:return {'passed':False,'errors':['unreplayed_final_state']}
        return self.oracle.grade(deepcopy(initial),deepcopy(answer),deepcopy(events),final_state=deepcopy(final_state))

def public_report(answer):
    return {k:deepcopy(v) for k,v in answer.items() if k not in ('status','decision')}

def restore_protocol(slot,report,protocol_key):
    if not isinstance(report,dict) or 'status' in report or 'decision' in report:raise ValueError('Use the public report fields without benchmark decision labels')
    result=deepcopy(report)
    if slot=='aws_release_v1':outcome='blocked' if report.get('blocker') else 'reviewed'
    elif slot=='slot_01':outcome='block' if report.get('blocking_reasons') else 'abstain' if report.get('unresolved_evidence') else 'approve'
    elif slot=='slot_10':outcome='abstain' if report.get('unresolved_contenders') else 'complete'
    else:
        fields=('missing','missing_evidence','unresolved_evidence','unresolved_ids','unresolved_contenders','unresolved_plans')
        missing=any(report.get(k) for k in fields)
        if slot=='slot_03':missing=bool(report.get('unresolved'))
        outcome='abstain' if missing else 'act' if protocol_key=='decision' else 'complete'
        if not missing:
            if slot=='slot_08':outcome='ready' if report.get('approval_usable') and all(r.get('check')=='match' for r in report.get('deliverables',[])) else 'needs_changes'
            elif slot=='slot_09':outcome='choose' if report.get('selected') else 'no_match'
            elif slot in {'slot_10','slot_11','slot_16','slot_17','slot_18'}:outcome='complete'
    result[protocol_key]=outcome
    return result

def public_schema(schema,root=True):
    # In a root union, every branch is still a root report. Sibling definitions
    # stay on that root, so local references keep their original meaning.
    if not isinstance(schema,dict):return deepcopy(schema)
    out={k:deepcopy(v) for k,v in schema.items() if k not in ('properties','oneOf','anyOf','allOf','items')}
    if 'properties' in schema:
        out['properties']={k:public_schema(v,False) for k,v in schema['properties'].items() if not(root and k in ('status','decision'))}
        if root and 'required'in out:out['required']=[k for k in out['required'] if k not in ('status','decision')]
    for kind in ('oneOf','anyOf','allOf'):
        if kind in schema:out[kind]=[public_schema(v,root) for v in schema[kind]]
    if 'items'in schema:out['items']=public_schema(schema['items'],False)
    return out