"""Exact CSS marginals, with soft conditioning on the complementary syndrome."""
import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
os.environ['OPENBLAS_NUM_THREADS']='1'
from pathlib import Path
import collections,time
import numpy as np
import stim
import jax
import jax.numpy as jnp
from exact import parse_errors,make_plan,make_decoder,make_marginals_fb


def save_state(path,state):
    flat={k:v for k,v in state.items() if k not in ['on','off']}
    for which in ['on','off']:
        flat.update({which+'__'+k:v for k,v in state[which].items()})
    np.savez(path,**flat)


def load_state(path):
    flat=dict(np.load(path,allow_pickle=False));state={'on':{},'off':{}}
    for k,v in flat.items():
        if '__' in k:
            which,key=k.split('__',1);state[which][key]=v
        else:state[k]=v
    return state


def build(dem):
    coords=dem.get_detector_coordinates()
    first={tuple(c[:2]) for c in coords.values() if c[-1]==0}
    on=[d for d,c in coords.items() if tuple(c[:2]) in first]
    off=[d for d,c in coords.items() if tuple(c[:2]) not in first]
    maps=[{d:i for i,d in enumerate(ds)} for ds in [on,off]]
    errors=parse_errors(dem)
    groups=[{},{}]
    orig_p=[];orig_group=[[],[]]
    for ds,l,p in errors:
        orig_p.append(p)
        for k,idx in enumerate(maps):
            key=tuple(sorted(idx[d] for d in ds if d in idx)),l if k==0 else 0
            if not key[0] and not key[1]:
                orig_group[k].append(-1)
                continue
            if key not in groups[k]:groups[k][key]=[len(groups[k]),1.]
            groups[k][key][1]*=1-2*p
            orig_group[k].append(groups[k][key][0])
    plans=[]
    for k,g in enumerate(groups):
        sub=stim.DetectorErrorModel()
        for (ds,l),(_,bias) in g.items():
            sub.append('error',[(1-bias)/2],[stim.target_relative_detector_id(d) for d in ds]+([stim.target_logical_observable_id(0)] if l else []))
        for d,i in maps[k].items():sub.append('detector',coords[d],[stim.target_relative_detector_id(i)])
        plan=make_plan(sub)
        if k==1:
            # No logical observable is tracked in the complementary partition.
            assert np.all((plan['masks'] & 1)==0)
            plan['masks'] >>= 1
            plan['width'] -= 1
        plans.append(plan)
    # Relate each original error to its complementary parity's likelihood gradient.
    step_from_source={int(v):i for i,v in enumerate(plans[1]['source_indices']) if v>=0}
    offstep=np.array([step_from_source.get(g,0) for g in orig_group[1]],np.int32)
    p=np.array(orig_p,np.float32)
    offp=plans[1]['probabilities'][offstep]
    coeff=p*(1-p)*(1-2*offp)/(1-2*p)
    coeff[np.array(orig_group[1])<0]=0
    members=[[] for _ in groups[0]]
    for i,g in enumerate(orig_group[0]):
        if g>=0:members[g].append(i)
    size=max(map(len,members))
    member_array=np.array([m+[len(p)]*(size-len(m)) for m in members],np.int32)
    return {'on':plans[0],'off':plans[1],'on_indices':np.array(on,np.int32),'off_indices':np.array(off,np.int32),
            'p':p,'coeff':coeff,'offstep':offstep,'members':member_array}


class ConditionalDecoder:
    def __init__(self, state, batch=128):
        self.state=state;self.batch=batch
        self.marginals=make_marginals_fb(int(state['off']['width']))
        self.decode=make_decoder(int(state['on']['width']))
        self.args=[jax.device_put(state['off'][k]) for k in ['probabilities','masks','measured']]
        self.onargs=[jax.device_put(state['on'][k]) for k in ['masks','measured']]
        p,coeff,offstep,members=[jnp.asarray(state[k]) for k in ['p','coeff','offstep','members']]
        src=jnp.asarray(state['on']['source_indices'])
        @jax.jit
        def probabilities(grad,strength):
            q=jnp.clip(p[None,:]+strength*coeff[None,:]*grad[:,offstep],1e-7,1-1e-7)
            q=jnp.pad(q,((0,0),(0,1)))
            bias=jnp.prod(1-2*q[:,members],axis=-1)
            v=(1-bias)/2
            return jnp.where(src[:,None]>=0,v[:,jnp.maximum(src,0)].T,0)
        self.probabilities=probabilities

    def predict(self,dets,strengths=(0.,0.5,1.)):
        outputs=[[] for s in strengths]
        for start in range(0,len(dets),self.batch):
            n=min(self.batch,len(dets)-start)
            ds=np.pad(dets[start:start+n],((0,self.batch-n),(0,0)))
            logz,grad=self.marginals(ds[:,self.state['off_indices']],*self.args)
            for i,strength in enumerate(strengths):
                probabilities=self.probabilities(grad,strength)
                result=self.decode(ds[:,self.state['on_indices']],probabilities,*self.onargs)
                outputs[i].append(np.asarray(result)[:n])
        return np.stack([np.concatenate(v) for v in outputs],axis=1)


if __name__=='__main__':
    import sys
    path=Path(sys.argv[1]);n=int(sys.argv[2]) if len(sys.argv)>2 else 512
    t=time.time();dem=stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem');state=build(dem)
    print('plan',time.time()-t,'widths',state['on']['width'],state['off']['width'],flush=True)
    arrays=np.load(path/'arrays.npz');dets=np.unpackbits(arrays['detectors'][:n],axis=1,count=dem.num_detectors,bitorder='little')
    decoder=ConditionalDecoder(state,batch=128)
    for trial in range(2):
        t=time.time();p=decoder.predict(dets);print('trial',trial,'seconds',time.time()-t,'failure',np.mean((p>=.5)!=arrays['labels'][:n,None],axis=0),'range',p.min(),p.max(),flush=True)