"""Auditable, bounded experiments; all favorable and unfavorable controls saved."""
from __future__ import annotations
import copy
import hashlib
import json
import math
from pathlib import Path
import platform
import sys
import time
import numpy as np
from synthesis import discover, digest, verify_tensor
from arithmetic import Kernel, NTTKernel, P
from native import build, NativeKernel, NativeNTTKernel
from tasks import reciprocal, exponential, reversion, catalan
from audit import CreditAccount, AnytimeGate, atomic_save

ROOT = Path(__file__).resolve().parents[1]


def arrayhash(x):
    return hashlib.sha256(np.asarray(x,dtype='<i8').tobytes()).hexdigest()


def vector(seed,n,constant=1):
    r=np.random.default_rng(seed).integers(0,P,n,dtype=np.int64)
    r[0]=constant
    return r


class Lab:
    def __init__(self,root=ROOT,native=True):
        self.root=Path(root)
        self.config=json.loads((self.root/'experiment_config.json').read_text())
        self.discovery=discover()
        self.law=self.discovery['law']
        self.native=build(self.law,self.root/'native_build') if native else {'available':False,'wall_seconds':0}
        self.files={}
        self.backend='native C++' if self.native['available'] else 'portable NumPy'
    def save(self,name,data):
        path=self.root/'results'/name
        path.parent.mkdir(parents=True,exist_ok=True)
        path.write_text(json.dumps(data,indent=2,sort_keys=True))
    def kernel(self,cap=0,ntt=False):
        if self.native['available']:
            return NativeNTTKernel(self.law,self.native['library']) if ntt else NativeKernel(self.law,cap,self.native['library'])
        return NTTKernel(self.law) if ntt else Kernel(self.law,cap)
    def run_job(self,family,n,seed,cap=0,ntt=False):
        # Generate task inputs outside the solver timer; this cost is shared and
        # not called learning. Kernel construction and checking ARE inside.
        f=vector(seed,n,0 if family=='exponential' else 1)
        fshort=np.array([0,1,seed%19+1,seed%23+2,seed%13+1],dtype=np.int64)
        b=vector(seed+9871,n,2)
        start=time.perf_counter_ns()
        k=self.kernel(cap,ntt)
        if family=='reciprocal':
            out=reciprocal(f,n,k)
        elif family=='exponential':
            out=exponential(f,n,k)
        elif family=='reversion':
            out=reversion(fshort,n,k)
        elif family=='implicit_catalan':
            out=catalan(n,k)
        elif family=='convolution':
            out=k.mul(f,b)
        else:
            raise ValueError('Unknown task family')
        elapsed=time.perf_counter_ns()-start
        record={'family':family,'length':n,'input_seed':seed,'cap':cap,'ntt':ntt,
                'wall_ns':elapsed,'output_sha256':arrayhash(out),
                'meter':k.meter.snapshot(),
                'trace':[[a,b,count] for (a,b),count in sorted(k.trace.items())]}
        return out,record

    def train(self):
        cfg=self.config
        account=CreditAccount(cfg['bootstrap_ledger_units'])
        disc=self.discovery['counts']
        startup_charge=disc['rational_ops']+disc['pivot_tests']+disc['certificate_ops']
        if not account.invest(startup_charge):
            raise RuntimeError('Insufficient bootstrap credit')
        cap=0
        state=self.kernel(0).program()
        records=[];service=[];audit=[]
        training_wall_start=time.perf_counter()
        for stage,n in enumerate(cfg['training_lengths']):
            stage_start=time.perf_counter()
            for rep in range(cfg['service_jobs_per_stage']):
                seed=cfg['master_seed']+stage*1000+rep
                out,live=self.run_job('reciprocal',n,seed,cap)
                ref,base=self.run_job('reciprocal',n,seed,0)
                if not np.array_equal(out,ref):
                    raise ArithmeticError('Service semantics changed')
                account.service(base['meter']['ledger_units'],live['meter']['ledger_units'])
                service.append({'stage':stage,'live':live,'reference':base})
            seed=cfg['master_seed']+stage*1000+999
            child_kernel=self.kernel(cap+1)
            proposed=child_kernel.program(state['sha256'])
            before,old=self.run_job('reciprocal',n,seed,cap)
            after,new=self.run_job('reciprocal',n,seed,cap+1)
            if not np.array_equal(before,after):
                raise ArithmeticError('Candidate changed learning result')
            # Validation work is an explicit cost of producing a successor.
            checks=verify_tensor(self.law)[1]
            investment=old['meter']['ledger_units']+new['meter']['ledger_units']+checks+len(json.dumps(proposed))
            improvement=new['meter']['field_ops']<old['meter']['field_ops']
            paid=account.invest(investment)
            committed=paid and improvement
            if committed:
                cap+=1;state=proposed
            event={'stage':stage,'length':n,'before_cap':cap-int(committed),'after_cap':cap,
                   'committed':committed,'candidate_sha256':proposed['sha256'],
                   'state_sha256':state['sha256'],'investment_units':investment,
                   'strict_arithmetic_gain':improvement,'paid':paid,
                   'parent_evaluation':old,'candidate_evaluation':new,
                   'account':account.snapshot(),'stage_wall_seconds':time.perf_counter()-stage_start}
            records.append(event)
            audit.append({'stage':stage,'candidate':proposed})
            atomic_save(self.root/'results/checkpoint.json',
                        {'generation':stage+1,'program':state,'account':account.snapshot(),
                         'protocol_sha256':digest(cfg),'next_request':'bounded external job'})
            atomic_save(self.root/f'results/checkpoint_{stage:02d}.json',
                        {'generation':stage+1,'program':state,'account':account.snapshot()})
        result={'mode':'arithmetic objective; timings are diagnostic, not the promotion criterion',
                'final_cap':cap,'commits':sum(x['committed'] for x in records),
                'startup_discovery_units':startup_charge,'records':records,'service':service,
                'programs':audit,'final_account':account.snapshot(),
                'loop_wall_seconds_including_reference_audit':time.perf_counter()-training_wall_start,
                'production_wall_seconds':sum(x['live']['wall_ns'] for x in service)/1e9+
                    sum((x['parent_evaluation']['wall_ns']+x['candidate_evaluation']['wall_ns'])/1e9 for x in records)+
                    self.discovery['wall_seconds']+self.native['wall_seconds'],
                'reference_service_wall_seconds':sum(x['reference']['wall_ns'] for x in service)/1e9,
                'accounting_note':'Production time includes discovery, native compilation, service and paired validation; reference reruns are research-only audit costs and are logged separately.'}
        self.save('training.json',result)
        return result

    def same_child(self,final_cap):
        cfg=self.config;rows=[]
        for n in cfg['same_child_lengths']:
            for rep in range(cfg['same_child_replicates']):
                seed=710000+n*10+rep
                child,child_record=self.run_job('reciprocal',n,seed,final_cap)
                artifact=self.kernel(final_cap).program('counterfactual-fixed-parent-metadata')
                for cap in range(final_cap+1):
                    old,record=self.run_job('reciprocal',n,seed,cap)
                    if not np.array_equal(old,child):
                        raise ArithmeticError('Same-child output mismatch')
                    fixed=verify_tensor(self.law)[1]+len(json.dumps(artifact))
                    rows.append({'length':n,'replicate':rep,'parent_cap':cap,
                                 'candidate_cap':final_cap,'candidate_sha256':artifact['sha256'],
                                 'identical_learned_output':True,
                                 'parent_evaluation':record,'candidate_evaluation':child_record,
                                 'meta_field_ops':record['meter']['field_ops']+child_record['meter']['field_ops'],
                                 'meta_ledger_units':record['meter']['ledger_units']+child_record['meter']['ledger_units']+fixed,
                                 'meta_wall_ns':record['wall_ns']+child_record['wall_ns']})
        result={'definition':'Same fixed candidate artifact and task. Only the inherited arithmetic implementation used by the incumbent validation arm is intervened on.',
                'not_a_claim':'This does not show that the proposal grammar or proof strategy improved.',
                'rows':rows}
        self.save('same_child.json',result)
        return result

    def holdout(self,final_cap,wall_cap):
        cfg=self.config;rows=[]
        methods=[('frozen_schoolbook',0,False),('arithmetic_lineage',final_cap,False),
                 ('wall_gated_lineage',wall_cap,False),('static_cap4',4,False),
                 ('static_full_envelope',20,False),('conventional_NTT',0,True)]
        order_rng=np.random.default_rng(22012027)
        for family in ['exponential','reversion','implicit_catalan','convolution']:
            for n in cfg['holdout_lengths']:
                for rep in range(cfg['holdout_replicates']):
                    seed=cfg['holdout_seed']+n*100+rep
                    expected=None
                    for j in order_rng.permutation(len(methods)):
                        name,cap,ntt=methods[int(j)]
                        out,row=self.run_job(family,n,seed,cap,ntt)
                        if expected is None:expected=out
                        elif not np.array_equal(out,expected):
                            raise ArithmeticError('Held-out algorithm disagreement')
                        row.update({'method':name,'replicate':rep,'correct_vs_other_algorithms':True})
                        rows.append(row)
        result={'status':'Fresh coefficient instances and control-flow families, but the same finite-field arithmetic contract.',
                'families_not_used_for_promotion':['exponential','reversion','implicit_catalan','convolution'],
                'rows':rows}
        self.save('holdout.json',result)
        return result

    def hardware_gate(self):
        cfg=self.config;cap=0;records=[]
        rng=np.random.default_rng(813411)
        for proposal,n in enumerate(cfg['hardware_audit_lengths'],1):
            gate=AnytimeGate(proposal,cfg['hardware_alpha'])
            pairs=[];parent_cap=cap
            for t in range(cfg['hardware_audit_max_pairs']):
                seed=8800000+proposal*10000+t
                order=list(map(int,rng.permutation(2)));data={};outs={}
                for j in order:
                    outs[int(j)],data[int(j)]=self.run_job('reciprocal',n,seed,cap+int(j))
                if not np.array_equal(outs[0],outs[1]):
                    raise ArithmeticError('Hardware gate saw a semantic difference')
                a,b=data[0]['wall_ns'],data[1]['wall_ns']
                sign=1 if b<a else (-1 if b>a else 0)
                gate.update(sign)
                pairs.append({'trial':t,'order':order,'parent_ns':a,'candidate_ns':b,
                              'sign':sign,'parent_units':data[0]['meter']['ledger_units'],
                              'candidate_units':data[1]['meter']['ledger_units']})
                if gate.accepted and t+1>=16:
                    break
            if gate.accepted:cap+=1
            records.append({'proposal':proposal,'length':n,'parent_cap':parent_cap,
                            'candidate_cap':parent_cap+1,'accepted':gate.accepted,
                            'after_cap':cap,'evidence':gate.snapshot(),'pairs':pairs})
        result={'final_cap':cap,'accepted_proposals':sum(r['accepted'] for r in records),
                'alpha':cfg['hardware_alpha'],'records':records,
                'null':'For a proposal, conditional probability of a candidate timing win is at most one half on the sampled reciprocal workload.',
                'limitations':'No distribution-free guarantee for future wall time; hardware-dependent outcomes; this gate is separate from the arithmetic lineage.'}
        self.save('hardware_gate.json',result)
        return result

    def payback(self,cap):
        cfg=self.config;rows=[];rng=np.random.default_rng(199903)
        for rep in range(cfg['payback_jobs']):
            seed=9100000+rep
            pair={};outs={}
            for j in rng.permutation(2):
                outs[int(j)],pair[int(j)]=self.run_job('reciprocal',cfg['payback_length'],seed,cap if j else 0)
            if not np.array_equal(outs[0],outs[1]):
                raise ArithmeticError('Payback task mismatch')
            rows.append({'replicate':rep,'frozen':pair[0],'evolved':pair[1]})
        result={'deployed_cap':cap,'rows':rows,
                'frozen_seconds':sum(r['frozen']['wall_ns'] for r in rows)/1e9,
                'evolved_seconds':sum(r['evolved']['wall_ns'] for r in rows)/1e9,
                'note':'A measured finite deployment workload, not a forecast. Subtract separately recorded discovery, compilation and all relevant proposal-validation costs before claiming net payback.'}
        self.save('payback.json',result)
        return result

    def fixed_budget(self,cap,wall_cap):
        cfg=self.config;rows=[]
        methods=[('frozen_schoolbook',0,False),('arithmetic_lineage',cap,False),
                 ('wall_gated_lineage',wall_cap,False),('static_cap4',4,False),
                 ('static_full_envelope',20,False),('conventional_NTT',0,True)]
        for name,d,ntt in methods:
            spent=0;completed=0;wall=0.;hashes=[]
            # Exact shape model makes cost constant for non-NTT methods. NTT
            # root setup is separately charged through measured counters.
            while completed<1000:
                out,r=self.run_job('reciprocal',cfg['budget_length'],9300000+completed,d,ntt)
                units=r['meter']['ledger_units']
                if spent+units>cfg['budget_ledger_units']:
                    # This look-ahead run belongs to audit, not the service
                    # budget; its full cost is explicitly disclosed.
                    lookahead={'units':units,'wall_ns':r['wall_ns']};break
                spent+=units;wall+=r['wall_ns']/1e9;completed+=1;hashes.append(r['output_sha256'])
            rows.append({'method':name,'completed':completed,'budget':cfg['budget_ledger_units'],
                         'spent_units':spent,'service_seconds':wall,'output_hashes':hashes,
                         'research_only_lookahead':lookahead})
        result={'scope':'Equal warm-service abstract resource budgets; separate from end-to-end training budgets.',
                'rows':rows}
        self.save('fixed_budget.json',result)
        return result

    def e_simulation(self):
        cfg=self.config;rng=np.random.default_rng(319127)
        result=[]
        for probability in [0.5,0.65,0.8]:
            successes=0;stops=[]
            for simulation in range(cfg['null_simulations']):
                gate=AnytimeGate(1,cfg['hardware_alpha'])
                for t in range(cfg['null_horizon']):
                    if gate.update(1 if rng.random()<probability else -1):
                        successes+=1;stops.append(t+1);break
            result.append({'win_probability':probability,'accepted':successes,
                           'runs':cfg['null_simulations'],'horizon':cfg['null_horizon'],
                           'acceptance_fraction':successes/cfg['null_simulations'],
                           'mean_stopping_trial_if_accepted':float(np.mean(stops)) if stops else None})
        output={'proposal':1,'allocated_alpha':cfg['hardware_alpha']/2,'results':result,
                'interpretation':'Monte Carlo check of a proved gate, not evidence of AI capability.'}
        self.save('e_simulation.json',output)
        return output

    def run(self):
        totalstart=time.perf_counter()
        self.save('discovery.json',self.discovery)
        self.save('native_build.json',self.native)
        self.save('environment.json',{'python':sys.version,'platform':platform.platform(),
                    'numpy':np.__version__,'backend':self.backend,
                    'hardware_scope':'Container CPU only; no GPU or user-PC benchmark',
                    'protocol_sha256':digest(self.config)})
        training=self.train()
        print('Training',training['commits'],'commits; cap',training['final_cap'],flush=True)
        same=self.same_child(training['final_cap'])
        hardware=self.hardware_gate()
        print('Hardware gate',hardware['accepted_proposals'],'accepted; cap',hardware['final_cap'],flush=True)
        holdout=self.holdout(training['final_cap'],hardware['final_cap'])
        payback=self.payback(hardware['final_cap'])
        budget=self.fixed_budget(training['final_cap'],hardware['final_cap'])
        e=self.e_simulation()
        self.save('experiment_run.json',{'completed':True,'wall_seconds':time.perf_counter()-totalstart,
            'training_commits':training['commits'],'hardware_commits':hardware['accepted_proposals'],
            'heldout_method_runs':len(holdout['rows']),'same_child_runs':len(same['rows']),
            'payback_jobs':len(payback['rows']),'note':'All reported outcomes, including regressions and stronger conventional controls, are retained.'})
        print('Completed experiments',time.perf_counter()-totalstart,flush=True)

if __name__=='__main__':
    Lab(native='--portable' not in sys.argv).run()