"""Fixed-design finite studies: no network, human data, or downloaded model."""
from __future__ import annotations
import argparse,csv,itertools,json,math,time
from pathlib import Path
import numpy as np
from scipy.special import logsumexp
from scipy.stats import t as student_t
from infinite_players.temporal import signs,trajectory_products,lag_moments
from infinite_players.evidence_tree import EvidenceTree,paired_emission_factors,forward_log_likelihoods
from infinite_players.memory_contract import confusability_graph,exact_coloring,retrospective_memory_lower_bits
from infinite_players.fidelity import policy_iteration,project_improvement,semantic_law,signature_residual,solve_fiber
from infinite_players.arena import make_arena,calibration_fixture
from infinite_players.promotion import budget
SEED=1860317

def save_json(path,value):path.write_text(json.dumps(value,indent=2,sort_keys=True,allow_nan=False)+"\n")
def save_csv(path,rows):
    with path.open('w',newline='') as f:
        w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)
def wilson(correct,n):
    p=correct/n;z=1.959963984540054;d=1+z*z/n
    mid=(p+z*z/(2*n))/d;half=z*math.sqrt(p*(1-p)/n+z*z/(4*n*n))/d
    return mid-half,mid+half

def lag_study(out):
    rng=np.random.default_rng(SEED);rows=[];raw=[]
    n=64;trials=16000;alpha=.6;beta=.75;rho=.72
    for lag in (0,1,2,3,4,6,9):
        u=trajectory_products(rng,trials,n,lag,alpha,beta,rho)
        scores=u.sum(1);correct=(scores>0)|((scores==0)&(rng.random(trials)<.5))
        mean,var,bound=lag_moments(n,lag,alpha*beta,rho);lo,hi=wilson(int(correct.sum()),trials)
        rows.append(dict(lag=lag,n=n,trials=trials,correct=int(correct.sum()),accuracy=float(correct.mean()),ci_low=lo,ci_high=hi,mean_score=float(scores.mean()),theory_mean=mean,variance=float(scores.var(ddof=1)),theory_variance=var,error_bound=bound))
        raw.extend(dict(lag=lag,trial=i,score=int(s),correct=int(c)) for i,(s,c) in enumerate(zip(scores,correct)))
    save_csv(out/'continuous_lag.csv',rows);save_csv(out/'continuous_lag_trials.csv',raw);return rows

def hmm_study(out):
    rng=np.random.default_rng(SEED+1);hyp=np.array(list(itertools.product([-1,1],repeat=2)))
    rows=[];raw=[];max_difference=0.;pre_diff=0.
    for n in (8,16,32):
        trials=1000;full_correct=0;replay_correct=0;product_correct=0
        for trial in range(trials):
            theta,world=signs(rng,0.,2);z=np.empty(n,dtype=np.int8);z[0]=signs(rng,0.,1)[0]
            z[1:]=z[0]*np.cumprod(signs(rng,.72,n-1))
            a=theta*world*z*signs(rng,.6,n);b=z*signs(rng,.75,n)
            factors=paired_emission_factors(a,b,hyp)
            tree=EvidenceTree(factors,[str(i) for i in range(n)],model_id="paired-HMM-v1")
            prior=tree.posterior([.5,.5]);pre_diff=max(pre_diff,abs(prior[hyp[:,0]==1].sum()-.5))
            probe=(hyp[:,1]==world).astype(float);p=tree.posterior([.5,.5],probe=probe)
            ll=forward_log_likelihoods(factors,[.5,.5]);ll[hyp[:,1]!=world]=-np.inf;baseline=np.exp(ll-logsumexp(ll))
            max_difference=max(max_difference,float(np.max(np.abs(p-baseline))))
            prob=float(p[hyp[:,0]==1].sum());tie=1 if rng.random()<.5 else -1
            prediction=1 if prob>.5+1e-12 else (-1 if prob<.5-1e-12 else tie)
            baseline_prob=float(baseline[hyp[:,0]==1].sum()); replay_prediction=1 if baseline_prob>.5+1e-12 else (-1 if baseline_prob<.5-1e-12 else tie)
            score=int(world*np.sum(a.astype(int)*b));product=1 if score>0 else (-1 if score<0 else tie)
            hit=int(prediction==theta);replay_hit=int(replay_prediction==theta);hitprod=int(product==theta);full_correct+=hit;replay_correct+=replay_hit;product_correct+=hitprod
            raw.append(dict(n=n,trial=trial,theta=int(theta),world=int(world),posterior_positive=prob,tree_correct=hit,full_replay_correct=replay_hit,product_correct=hitprod))
        for name,correct in (("operator_tree",full_correct),("full_HMM_replay",replay_correct),("paired_product",product_correct)):
            lo,hi=wilson(correct,trials);rows.append(dict(events=n,method=name,trials=trials,correct=correct,accuracy=correct/trials,ci_low=lo,ci_high=hi))
    save_csv(out/'sequence_inference.csv',rows);save_csv(out/'sequence_inference_trials.csv',raw)
    report=dict(maximum_tree_replay_posterior_error=max_difference,maximum_precalibration_identity_error_from_half=pre_diff,independent_records=3000)
    save_json(out/'sequence_inference_audit.json',report);return rows,report

def revision_study(out):
    rng=np.random.default_rng(SEED+2);hyp=np.array(list(itertools.product([-1,1],repeat=2)));rows=[];timings=[];raw=[]
    for n in (256,2048,16384):
        a=signs(rng,0.,n);b=signs(rng,0.,n);factors=paired_emission_factors(a,b,hyp)
        begin=time.perf_counter();tree=EvidenceTree(factors,[str(i) for i in range(n)],model_id="m");build=time.perf_counter()-begin
        maximum=0.;max_centered_logerror=0.;tree_seconds=0.;replay_seconds=0.
        for revision,index in enumerate(rng.choice(n,size=16,replace=False)):
            b[index]*=-1;new=paired_emission_factors(a[index:index+1],b[index:index+1],hyp)[0];factors[index]=new
            t=time.perf_counter();tree.replace(str(index),new,model_id="m",revision_id=str(revision));tp=tree.posterior([.5,.5],probe=[0,1,0,1]);tree_seconds+=time.perf_counter()-t
            t=time.perf_counter();ll=forward_log_likelihoods(factors,[.5,.5]);ll[[0,2]]=-np.inf;fp=np.exp(ll-logsumexp(ll));replay_seconds+=time.perf_counter()-t
            err=float(np.max(np.abs(tp-fp)));maximum=max(maximum,err)
            tll=tree.log_likelihoods([.5,.5]); fll=forward_log_likelihoods(factors,[.5,.5]); logerr=float(np.max(np.abs((tll-tll[0])-(fll-fll[0])))); max_centered_logerror=max(max_centered_logerror,logerr)
            raw.append(dict(events=n,revision=revision,index=int(index),posterior_max_error=err,centered_logscore_error=logerr,tree_compositions=tree.last_update_compositions,forward_steps=n))
        depth=(n-1).bit_length()
        rows.append(dict(events=n,hypotheses=4,hidden_states=2,revisions=16,tree_compositions_per_revision=depth,replay_steps_per_revision=n,tree_payload_bytes=tree.allocated_array_bytes,raw_two_sign_payload_bytes=2*n,max_posterior_error=maximum,max_centered_logscore_error=max_centered_logerror))
        timings.append(dict(events=n,build_seconds=build,tree_16_revisions_seconds=tree_seconds,replay_16_revisions_seconds=replay_seconds,measured_revision_speed_ratio=replay_seconds/tree_seconds))
    save_csv(out/'local_revisions.csv',rows);save_csv(out/'local_revision_trials.csv',raw);save_json(out/'runtime_telemetry.json',timings);return rows

def memory_study(out):
    rows=[]
    for n in range(1,5):
        records=np.array(list(itertools.product([0,1],repeat=n)))
        for prefix in sorted(set((1,n))):
            k,_=exact_coloring(confusability_graph(records[:,:prefix]));rows.append(dict(record_bits=n,queried_coordinates=prefix,records=2**n,minimum_memory_states=k,minimum_fixed_bits=int(math.ceil(math.log2(k)))))
    save_csv(out/'memory_graphs.csv',rows)
    rng=np.random.default_rng(SEED+3);n=256;trials=16000
    d=signs(rng,0.,(trials,n));theta=signs(rng,0.,trials);j=rng.integers(n,size=trials);actual=d[np.arange(trials),j];w=theta*actual;guess=signs(rng,0.,trials);result=[]
    for b in (0,8,32,64,128,256):
        answer=w*np.where(j<b,actual,guess);correct=int(np.sum(answer==theta));lo,hi=wilson(correct,trials)
        result.append(dict(history_bits=n,retained_prefix_bits=b,trials=trials,correct=correct,accuracy=correct/trials,ci_low=lo,ci_high=hi,analytic_accuracy=.5+.5*b/n,evidential_coverage=b/n))
    save_csv(out/'retrospective_memory.csv',result);save_json(out/'lossy_memory_bound.json',{"history_bits":n,"bounds":[{"average_error":e,"minimum_bits_lower_bound":retrospective_memory_lower_bits(n,e)} for e in (0,.01,.05,.1,.25,.5)]});return result

def shield_study(out):
    rows=[];curves=[];policies=[];horizon_rows=[]
    for seed in range(16):
        mdp,anchor,targets=make_arena(4100+seed,theta=(-1 if seed%2 else 1));basevalue,_=mdp.evaluate(anchor);reference=semantic_law(mdp,anchor,6)
        methods={"source_anchor":anchor};audits={}
        for kind,name in (("path","path_shield_LP"),("class","conditional_class_only"),("none","unconstrained")):
            pi,v,check=policy_iteration(mdp,targets,kind);methods[name]=pi;audits[name]=check
        projected,hist=project_improvement(mdp,anchor,targets,steps=24);methods['nullspace_24_updates']=projected;curves.extend(dict(seed=seed,**x) for x in hist)
        for name,pi in methods.items():
            v,_=mdp.evaluate(pi);law=semantic_law(mdp,pi,6)
            class_error=max(np.max(np.abs(np.array([pi[s,mdp.semantic_action[s]==c].sum() for c in range(mdp.C)])-targets[mdp.semantic_state[s]].sum(axis=1))) for s in range(mdp.S))
            rows.append(dict(seed=seed,method=name,discounted_value=float(v.mean()),normalized_value=float((1-mdp.gamma)*v.mean()),normalized_gain=float((1-mdp.gamma)*(v-basevalue).mean()),minimum_state_value_gain=float(np.min(v-basevalue)),class_probability_error=float(class_error),signature_error=signature_residual(mdp,pi,targets),semantic_path_TV_h6=float(np.abs(law-reference).sum()/2)))
            if seed<3:policies.append(dict(seed=seed,method=name,policy=pi.tolist(),audit=audits.get(name)))
            if seed==0 and name in ('source_anchor','path_shield_LP','conditional_class_only','unconstrained'):
                for h in range(1,9):
                    r=semantic_law(mdp,anchor,h);q=semantic_law(mdp,pi,h);horizon_rows.append(dict(method=name,horizon=h,semantic_path_TV=float(np.abs(r-q).sum()/2)))
    summary=[]
    for name in dict.fromkeys(x['method'] for x in rows):
        subset=[x for x in rows if x['method']==name];g=np.array([x['normalized_gain'] for x in subset]);m=float(g.mean());half=float(student_t.ppf(.975,15)*g.std(ddof=1)/4)
        summary.append(dict(method=name,seeds=16,normalized_value=float(np.mean([x['normalized_value'] for x in subset])),normalized_gain=m,paired_gain_ci_low=m-half,paired_gain_ci_high=m+half,semantic_path_TV_h6=float(np.mean([x['semantic_path_TV_h6'] for x in subset])),max_signature_error=float(max(x['signature_error'] for x in subset))))
    save_csv(out/'shield_arena.csv',rows);save_csv(out/'shield_summary.csv',summary);save_csv(out/'nullspace_updates.csv',curves);save_csv(out/'semantic_horizons.csv',horizon_rows);save_json(out/'policy_examples.json',policies)
    d0,d1,k,reward=calibration_fixture();cal=[]
    for name,D,K in (("before_calibration_robust",np.vstack([d0,d1]),np.tile(k,2)),("true_world_0",d0,k),("true_world_1",d1,k)):
        pi,a=solve_fiber(reward,D,K);cal.append(dict(stage=name,policy=pi.tolist(),reward=float(reward@pi),rank=int(np.linalg.matrix_rank(D)),nullity=int(3-np.linalg.matrix_rank(D)),audit=a))
    mdp,anchor,k=make_arena(781,no_headroom=True);p,v,a=policy_iteration(mdp,k)
    report={"calibration":cal,"no_headroom_max_absolute_gain":float(np.max(np.abs(v-mdp.evaluate(anchor)[0])))}
    save_json(out/'calibration_unlock.json',report);return summary,report

def approximation_study(out):
    rng=np.random.default_rng(SEED+4);rows=[]
    for trial in range(1000):
        n,H,K=8,4,2;factors=rng.uniform(.01,.7,(n,H,K,K));eps=rng.uniform(.001,.02,n);tilde=factors*np.exp(rng.uniform(-1,1,factors.shape)*eps[:,None,None,None])
        initial=rng.dirichlet(np.ones(K));terminal=rng.uniform(.1,1.,(H,K));prior=rng.dirichlet(np.ones(H));probe=np.exp(rng.uniform(-650,0,H))
        x=EvidenceTree(factors,[str(i) for i in range(n)],model_id="x");y=EvidenceTree(tilde,[str(i) for i in range(n)],model_id="x")
        p=x.posterior(initial,prior,terminal,probe);q=y.posterior(initial,prior,terminal,probe);error=float(np.abs(p-q).sum()/2);bound=math.tanh(float(eps.sum())/2)
        if error>bound+1e-12:raise AssertionError("approximation bound violation")
        rows.append(dict(trial=trial,log_error_budget=float(eps.sum()),posterior_TV=error,uniform_bound=bound))
    save_csv(out/'approximation_trials.csv',rows);result={"trials":1000,"violations":0,"maximum_posterior_TV":max(x['posterior_TV'] for x in rows),"maximum_error_bound_ratio":max(x['posterior_TV']/x['uniform_bound'] for x in rows)};save_json(out/'approximation_summary.json',result);return result

def lifetime_study(out):
    rng=np.random.default_rng(SEED+5);trials=10000;versions=40;n=256;delta=.05;rows=[]
    for true_gain in (0.,.3):
        sums=2*rng.binomial(n,(1+true_gain)/2,(trials,versions))-n;radii=np.sqrt(2*np.log([1/budget(delta,j) for j in range(1,versions+1)])/n);accepted=sums/n>radii[None,:]
        any_count=int(np.sum(accepted.any(1)));lo,hi=wilson(any_count,trials)
        rows.append(dict(true_gain=true_gain,trials=trials,versions=versions,audit_sessions_per_version=n,lifetime_budget=delta,any_promotion_count=any_count,any_promotion_rate=any_count/trials,ci_low=lo,ci_high=hi,mean_promotions=float(accepted.sum(1).mean())))
    save_csv(out/'lifetime_audit.csv',rows);return rows

def main():
    p=argparse.ArgumentParser();p.add_argument('--output',type=Path,default=Path('results'));args=p.parse_args();out=args.output;out.mkdir(parents=True,exist_ok=True)
    config={"seed":SEED,"scope":"synthetic finite known-model studies","lag_trials_per_lag":16000,"lag_events":64,"hmm_records_per_size":1000,"sizes":[8,16,32],"revision_lengths":[256,2048,16384],"local_corrections":16,"arena_seeds":16,"projection_updates":24,"horizon":6,"positive_circuit_trials":1000,"lifetime_runs_per_condition":10000};save_json(out/'config.json',config)
    report={}
    for name,fn in [('lag',lag_study),('sequence',hmm_study),('revisions',revision_study),('memory',memory_study),('shield',shield_study),('approximation',approximation_study),('lifetime',lifetime_study)]:
        print('RUN',name,flush=True);report[name]=fn(out)
    save_json(out/'summary.json',report);print('Finite studies completed',flush=True)
if __name__=='__main__':main()