"""Independent AO-supercell oracle for the two native R2 Fock halves.

Absolute gates are fixed before production: 1e-10 Ha per component;
1e-12 for real reconstruction. The oracle projects independent PAO/PNOs.
"""
import json
from itertools import product, combinations_with_replacement
import numpy as np

try:
    from . import bipole_occupied_complete as occupied_case
except ImportError:
    import bipole_occupied_complete as occupied_case

fixture, bare, half_case = occupied_case.fixture, occupied_case.bare, occupied_case.half_case
SINGLES, TOL = fixture.SINGLES, 1e-10


def oracle(inputs, fock, singles=SINGLES):
    """AO contractions, with complete diagonal singles and source pair T2.

    Combining Fbe-.5*s*Fme and Fmx+.5*Fme.dot(t_x) turns taut's
    half disconnected term into a full singles product in both intermediates.
    No production helper, transformed integral block or action is used.
    """
    s, eri, virtual, occ, bases, placed, amps = inputs
    rot = {ij: v.T @ s @ placed[ij] for ij, v in bases.items()}
    pairs = {ij: v @ rot[ij] @ amps[ij] @ rot[ij].T @ v.T for ij, v in bases.items()}
    d = np.column_stack([bases[m,m] @ rot[m,m] @ singles[m % 2] for m in range(6)])
    fh = occ.T @ fock @ (occ+d)
    for m, x, n in product(range(6), repeat=3):
        fh[m,x] += 2*np.einsum('uvwy,u,v,w,y',eri,occ[:,m],occ[:,x],occ[:,n],d[:,n])
        fh[m,x] -= np.einsum('uvwy,u,v,w,y',eri,occ[:,n],occ[:,x],occ[:,m],d[:,n])
        tau = pairs[x,n]+np.outer(d[:,x],d[:,n])
        fh[m,x] += 2*np.einsum('uvwy,u,w,vy',eri,occ[:,m],occ[:,n],tau)
        fh[m,x] -= np.einsum('uvwy,u,w,yv',eri,occ[:,m],occ[:,n],tau)
    refs = {k:{} for k in ('ij','ji','sum','virtual','occupied')}
    matrices = {}
    for ij,v in bases.items():
        i,j=ij; p=v.T@s; sm=p@d; u=rot[ij]
        fv=v.T@fock@v-sm@(occ.T@fock@v)
        for m in range(6):
            fv += 2*np.einsum('uvwy,u,v,wb,ye->be',eri,occ[:,m],d[:,m],v,v,optimize=True)
            fv -= np.einsum('uvwy,u,ve,wb,y->be',eri,occ[:,m],v,v,d[:,m],optimize=True)
            for n in range(6):
                tau=p@(pairs[m,n]+np.outer(d[:,m],d[:,n]))
                fv -= 2*np.einsum('uvwy,u,ve,w,by->be',eri,occ[:,m],v,occ[:,n],tau,optimize=True)
                fv += np.einsum('uvwy,u,bv,w,ye->be',eri,occ[:,m],tau,occ[:,n],v,optimize=True)
        t=rot[ij]@amps[ij]@rot[ij].T
        a=t@fv.T; b=t.T@fv.T
        vo=a+b.T
        oo=np.zeros_like(t)
        for m in range(6):
            left=p@pairs[i,m]@p.T; right=p@pairs[j,m]@p.T
            a-=fh[m,j]*left; b-=fh[m,i]*right
            oo-=fh[m,j]*left+fh[m,i]*right.T
        for key,value in zip(refs,(a,b,a+b.T,vo,oo),strict=True):
            refs[key][ij]=u.T@value@u
        matrices[ij]=u.T@fv@u
    return refs, dict(fh=fh, fv=matrices, ao_singles=d)


def native_snapshots(inputs, fock, singles=SINGLES, *, denominator_energy=7.):
    """Isolate local half snapshots; their preceding value is zero, not R2.

    ERI pieces are linear in the signed operator. Fock-only is evaluated
    once separately: including F in both signed passes would cancel it.
    Diagonal targets execute only half_ij and use its transpose for ji.
    """
    s,eri,virtual,occ,bases,placed,amps=inputs
    pairs=list(combinations_with_replacement(range(6),2))
    rot={ij:bases[ij].T@s@placed[ij] for ij in pairs}
    pnos=[virtual.T@s@bases[ij] for ij in pairs]
    ts=[rot[ij]@amps[ij]@rot[ij].T for ij in pairs]
    t1=[rot[m,m]@singles[m%2] for m in range(6)]
    names=('half_ij_fock','half_ji_fock','bare','occupied_ladder','virtual_ladder')
    blocks={name:{ij:np.zeros_like(t) for ij,t in zip(pairs,ts,strict=True)} for name in names}
    ev,vec=np.linalg.eigh(eri.reshape(144,144))
    for sign in (-1,1,0):
        keep=sign*ev>0
        if sign and not keep.any(): continue
        ao=(vec[:,keep]*np.sqrt(sign*ev[keep])).T.reshape(-1,12,12) if sign else np.zeros((1,12,12))
        factors=[np.ascontiguousarray((l.T@ao@r).reshape(len(ao),-1))
                 for l,r in ((occ,virtual),(occ,occ),(virtual,virtual))]
        ov=factors[0].reshape(-1,6,6)
        k=[(ov[:,i]@p).T@(ov[:,j]@p) for (i,j),p in zip(pairs,pnos,strict=True)]
        f=np.zeros_like(fock) if sign else fock
        got=bare.native._dlpno_ccsd_pno_evaluate(*factors,occ.T@f@occ,occ.T@f@virtual,virtual.T@f@virtual,
            [i for i,j in pairs],[j for i,j in pairs],pnos,[np.ones(p.shape[1])*denominator_energy for p in pnos],
            k,ts,[list(range(6)) for _ in pairs],t1,True)
        for ij,terms in zip(pairs,got['doubles_terms'],strict=True):
            for name in names:
                key='half_ij_fock' if ij[0]==ij[1] and name=='half_ji_fock' else name
                blocks[name][ij]+=(sign or 1)*terms[key]
    ordered={k:{} for k in ('ij','ji','sum','bare','occupied_ladder','virtual_ladder')}
    for ij in bases:
        key=tuple(sorted(ij)); u=bases[key].T@s@placed[ij]
        a,b=(blocks[name][key] for name in names[:2])
        if ij[0]>ij[1]: a,b=b,a
        ordered['ij'][ij]=u.T@a@u; ordered['ji'][ij]=u.T@b@u
        ordered['sum'][ij]=u.T@(a+b.T)@u
        for name in names[2:]:
            value=blocks[name][key]
            ordered[name][ij]=u.T@(value.T if ij[0]>ij[1] else value)@u
    return ordered


def algebra_check(kernel):
    """Uncombined native 1/2 corrections versus the collapsed intermediates.

    Deliberately nonsymmetric algebraic tensors isolate all index placements;
    this source check is not the physical scientific gate.
    """
    rng=np.random.default_rng(1049); no,nv=3,4
    foo=rng.normal(size=(no,no)); fov=rng.normal(size=(no,nv)); fvv=rng.normal(size=(nv,nv))
    g=rng.normal(size=(no,nv,no,nv)); h=rng.normal(size=(no,no,no,nv))
    w=rng.normal(size=(no,nv,nv,nv)); t=rng.normal(size=(no,no,nv,nv)); d=rng.normal(size=(no,nv))
    fm=fov.copy(); fa=fvv.copy(); fi=foo.copy()
    for m,e in product(range(no),range(nv)):
        for n,f in product(range(no),range(nv)):
            fm[m,e]+=d[n,f]*(2*g[m,e,n,f]-g[m,f,n,e])
    for a,e in product(range(nv),repeat=2):
        for m in range(no):
            fa[a,e]-=.5*d[m,a]*fov[m,e]
            for f in range(nv):
                fa[a,e]+=d[m,f]*(2*w[m,f,a,e]-w[m,e,a,f])
                for n in range(no):
                    taut=t[m,n,a,f]+.5*d[m,a]*d[n,f]
                    fa[a,e]-=taut*(2*g[m,e,n,f]-g[m,f,n,e])
            fa[a,e]-=.5*d[m,a]*fm[m,e]
    for m,x in product(range(no),repeat=2):
        for e in range(nv):
            fi[m,x]+=.5*d[x,e]*(fov[m,e]+fm[m,e])
            for n in range(no):
                fi[m,x]+=d[n,e]*(2*h[m,x,n,e]-h[n,x,m,e])
                for f in range(nv):
                    taut=t[x,n,e,f]+.5*d[x,e]*d[n,f]
                    fi[m,x]+=taut*(2*g[m,e,n,f]-g[m,f,n,e])
    actual=kernel(foo,fov,fvv,g,h,w,t,d)
    errors=dict(occupied=float(np.max(abs(actual[0]-fi))),virtual=float(np.max(abs(actual[1]-fa))))
    assert max(errors.values())<TOL,errors
    return dict(seed=1049,errors=errors,atol=TOL)


def controls(inputs,fock,refs,inter,kernel):
    s,eri,v,o,bases,placed,amps=inputs
    rot={ij:c.T@s@placed[ij] for ij,c in bases.items()}
    pairs={ij:c@rot[ij]@amps[ij]@rot[ij].T@c.T for ij,c in bases.items()}
    negative={k:{} for k in ('wrong_ji_transpose','omit_occupied_offdiagonal',
        'wrong_occupied_offdiagonal_sign','omit_virtual_offdiagonal','duplicate_fock')}
    for ij,c in bases.items():
        i,j=ij; u=rot[ij]; p=u.T@c.T@s
        fo=inter['fh']; fv=inter['fv'][ij]; t=amps[ij]
        off=fv-np.diag(np.diag(fv)); dv=t@off.T+off@t
        do=np.zeros_like(t)
        for m in range(6):
            if m!=j: do-=fo[m,j]*(p@pairs[i,m]@p.T)
            if m!=i: do-=fo[m,i]*(p@pairs[j,m]@p.T).T
        wrong=dict(wrong_ji_transpose=refs['ij'][ij]+refs['ji'][ij],
            omit_occupied_offdiagonal=refs['sum'][ij]-do,
            wrong_occupied_offdiagonal_sign=refs['sum'][ij]-2*do,
            omit_virtual_offdiagonal=refs['sum'][ij]-dv,
            duplicate_fock=2*refs['sum'][ij])
        for name,value in wrong.items(): bare.witness(negative[name],ij,value,refs['sum'][ij])
    assert all(x['abs']>TOL for x in negative.values()),negative
    # Fock-only native residual and deliberately changed preconditioner values.
    noeri=(s,np.zeros_like(eri),v,o,bases,placed,amps)
    fonly,_=oracle(noeri,fock,[np.zeros_like(t) for t in SINGLES])
    fn=native_snapshots(noeri,fock,[np.zeros_like(t) for t in SINGLES],denominator_energy=11.)
    diagonal={}; offdiagonal={}; doubled_diagonal={}
    for ij,c in bases.items():
        i,j=ij; a=placed[ij]; fp=a.T@fock@a; foo=o.T@fock@o
        denom=foo[i,i]+foo[j,j]-np.diag(fp)[:,None]-np.diag(fp)[None,:]
        diag=-denom*amps[ij]
        off=amps[ij]@(fp-np.diag(np.diag(fp))).T+(fp-np.diag(np.diag(fp)))@amps[ij]
        p=a.T@s
        for m in range(6):
            if m!=j: off-=foo[m,j]*p@pairs[i,m]@p.T
            if m!=i: off-=foo[m,i]*(p@pairs[j,m]@p.T).T
        diagonal[ij]=diag+off; offdiagonal[ij]=off
        bare.witness(doubled_diagonal,ij,2*diag+off,fonly['sum'][ij])
    # Asymmetric, symmetric-Hermitian Fock sentinel in the complete orbital
    # spaces. It exposes bare virtual offdiagonals hidden by semicanonical PNOs.
    rng=np.random.default_rng(592); q=rng.normal(size=(12,12)); q=.03*(q+q.T)
    c=np.column_stack((o,v)); sf=fock+s@c@q@c.T@s
    sentinel,si=oracle(inputs,sf)
    d=(v.T@s@inter['ao_singles']).T
    t=np.asarray([[v.T@s@pairs[m,n]@s@v for n in range(6)] for m in range(6)])
    def transform(a,b,c,d): return np.einsum('uvxy,ui,vj,xk,yl->ijkl',eri,a,b,c,d,optimize=True)
    fo,fv=kernel(o.T@sf@o,o.T@sf@v,v.T@sf@v,
        transform(o,v,o,v),transform(o,o,o,v),transform(o,v,v,v),t,d)
    sent={k:{} for k in ('ij','ji','sum')}; bare_off={}
    for ij,a in placed.items():
        i,j=ij; u=v.T@s@a; p=a.T@s; fp=u.T@fv@u
        aa=amps[ij]@fp.T; bb=amps[ij].T@fp.T
        for m in range(6):
            aa-=fo[m,j]*p@pairs[i,m]@p.T; bb-=fo[m,i]*p@pairs[j,m]@p.T
        for k,value in zip(sent,(aa,bb,aa+bb.T),strict=True): sent[k][ij]=value
        vf=a.T@sf@a; off=vf-np.diag(np.diag(vf))
        bare.witness(bare_off,ij,amps[ij]@off.T+off@amps[ij],np.zeros_like(aa))
    assert bare_off['abs']>TOL and doubled_diagonal['abs']>TOL
    sn=native_snapshots(inputs,sf)
    return dict(negative=negative,duplicated_diagonal=doubled_diagonal,diagonal_counted_once=half_case.compare(diagonal,fonly['sum']),
        denominator_only_energy_invariance=half_case.compare(fn['sum'],fonly['sum']),
        sentinel_kernel={k:half_case.compare(sent[k],sentinel[k]) for k in sent},
        sentinel_native={k:half_case.compare(sn[k],sentinel[k]) for k in sent},
        sentinel_virtual_offdiagonal=bare_off,sentinel_seed=592,sentinel_fock_ao=sf.tolist())


def run(*,oracle_only=False):
    result,prepared,doubles=fixture.prepare()
    inputs=fixture.reference_inputs(result,prepared,doubles)
    s,fock,_,_,_=bare.supercell_operands(result,bare.op.GaussianCell(**bare.FIXTURE))
    refs,inter=oracle(inputs,fock)
    native=native_snapshots(inputs,fock)
    record=dict(atol=TOL,ordered_targets=36,components_per_comparison=174,
        oracle_native={k:half_case.compare(native[k],refs[k]) for k in ('ij','ji','sum')})
    zero=[np.zeros_like(t) for t in SINGLES]
    zr,_=oracle(inputs,fock,zero); zn=native_snapshots(inputs,fock,zero)
    record['zero_oracle_native']={k:half_case.compare(zn[k],zr[k]) for k in ('ij','ji','sum')}
    assert len(refs['sum'])==36 and sum(a.size for a in refs['sum'].values())==174
    record['source']=result.terminal_transitions.identity
    record['raw_mp2']=prepared.solution.e_pair_per_cell
    print(json.dumps(record),flush=True)
    if oracle_only: return record
    from vibeqc.dlpno.bipole_fock import (fock_terms,ladders_fock_assembly,
        WORK_BOUND,assembly_work_bound,resource_census,_intermediates)
    h,z=result.terminal_transitions,prepared.pair_build.spaces
    limits=dict(max_bytes=h.required_bytes,max_work=WORK_BOUND)
    record['refusals']=half_case.quadratic.refusals(result,prepared,
        lambda r,p,t,**kw:fock_terms(r,p,doubles,t,**kw),limits)
    for name,budget in [('one_byte_below',dict(max_bytes=h.required_bytes-1,max_work=assembly_work_bound())),
                        ('one_work_below',dict(max_bytes=h.required_bytes,max_work=assembly_work_bound()-1))]:
        try: ladders_fock_assembly(result,prepared,doubles,SINGLES,**budget)
        except (ValueError,MemoryError) as exc: record['refusals']['assembly_'+name]=str(exc)
        else: raise AssertionError(name)
    from dataclasses import replace
    changed=list(prepared.pair_build.integrals)
    changed[0]=changed[0].copy(); changed[0][0,0]+=.01
    bad=replace(prepared,pair_build=replace(prepared.pair_build,integrals=tuple(changed)))
    try: ladders_fock_assembly(result,bad,doubles,SINGLES,max_bytes=h.required_bytes,max_work=assembly_work_bound())
    except ValueError as exc:
        assert 'bare seed' in str(exc)
        record['refusals']['changed_bare_seed']=str(exc)
    else: raise AssertionError('changed bare seed admitted')
    record['uncombined_algebra']=algebra_check(_intermediates)
    record['controls']=controls(inputs,fock,refs,inter,_intermediates)
    full=ladders_fock_assembly(result,prepared,doubles,SINGLES,max_bytes=h.required_bytes,max_work=assembly_work_bound())
    got=full['fock']
    def ordered(terms):
        return {k:{ij:terms.placed(z,*ij)[leg] for ij in refs[k]}
                for leg,k in enumerate(('ij','ji','sum'))}
    actual=ordered(got)
    record['production']={k:half_case.compare(actual[k],refs[k]) for k in actual}
    record['production_native']={k:half_case.compare(actual[k],native[k]) for k in actual}
    record['reversal']={
        'ij_to_ji':half_case.compare(actual['ij'],{ij:actual['ji'][ij[::-1]] for ij in actual['ij']}),
        'total':half_case.compare(actual['sum'],{ij:actual['sum'][ij[::-1]].T for ij in actual['sum']})}
    zgot=ordered(fock_terms(result,prepared,doubles,zero,**limits))
    record['zero_singles']={k:half_case.compare(zgot[k],zr[k]) for k in zgot}
    def placed(values): return {ij:z.orient_tensor(*ij,values) for ij in refs['sum']}
    occupied,_,_=occupied_case.oracle(inputs)
    virtual,_=half_case.oracle(inputs)
    _,eri,_,occ,_,target_frames,_=inputs
    dense_seed={ij:np.einsum('uvxy,u,va,x,yb->ab',eri,occ[:,ij[0]],a,occ[:,ij[1]],a,optimize=True)
                for ij,a in target_frames.items()}
    record['earlier_oracle']={
        'occupied':half_case.compare(placed(full['occupied']['total']),occupied['occupied']),
        'virtual':half_case.compare(placed(full['virtual']),virtual['full']),
        'bare':half_case.compare(placed(full['seed']),dense_seed)}
    assembly={ij:dense_seed[ij]+occupied['occupied'][ij]+virtual['full'][ij]+refs['sum'][ij]
              for ij in refs['sum']}
    native['assembly']={ij:native['virtual_ladder'][ij]+native['sum'][ij] for ij in refs['sum']}
    record['assembly_native']=half_case.compare(placed(full['total']),native['assembly'])
    record['assembly']=half_case.compare(placed(full['total']),assembly)
    actual['assembly']=placed(full['total']); refs['assembly']=assembly
    record['signed_components']={k:[dict(target=list(ij),actual=a.tolist(),reference=refs[k][ij].tolist(),
        error=(a-refs[k][ij]).tolist()) for ij,a in values.items()] for k,values in actual.items()}
    record['native_components']={k:[dict(target=list(ij),actual=a.tolist(),reference=native[k][ij].tolist(),
        error=(a-native[k][ij]).tolist()) for ij,a in actual[k].items()] for k in ('ij','ji','sum','assembly')}
    o=full['occupied']
    outputs=dict(bare_oooo=o['oooo']['doubles'],oooo_ss=o['oooo']['singles'],
        x=o['linear'].x,y=o['linear'].y,linear=o['linear'].total,
        cubic_x=o['cubic'].x,cubic_y=o['cubic'].y,cubic=o['cubic'].total,
        half=o['half'].total,half_tt=o['half'].tt,t1_free=o['t1_free'],occupied=o['total'])
    outputs['earlier_partial']=tuple(a+b for a,b in zip(outputs['linear'],outputs['half'],strict=True))
    outputs['partial']=tuple(a+b for a,b in zip(outputs['earlier_partial'],outputs['cubic'],strict=True))
    voutputs=dict(bare=full['virtual_bare'],linear_x=full['virtual_linear'].x,linear_y=full['virtual_linear'].y,
        quadratic=full['virtual_disconnected'],cubic_x=full['virtual_cubic'].x,cubic_y=full['virtual_cubic'].y,
        six=full['virtual_six'],full=full['virtual'],half=o['half'].total,
        tt=o['half'].tt,t_z1=o['half'].t_z1,ss_z=o['half'].ss_z,ss_z1=o['half'].ss_z1)
    record.update(source_record=h.provenance,pair_build=prepared.pair_build.identity,
        pair_frames=[a.tolist() for a in z.pair_coefficients],singles=[a.tolist() for a in SINGLES],
        doubles=[a.tolist() for a in doubles],ranks=list(z.pair_ranks),
        outputs={k:[a.tolist() for a in v] for k,v in outputs.items()},
        virtual_outputs={k:[a.tolist() for a in v] for k,v in voutputs.items()},
        resources=resource_census(),assembly_work=assembly_work_bound(),assembly_leases=full['leases'],
        coverage=full['coverage'],verdict='PASS')
    return record


if __name__=='__main__':
    import sys
    print(json.dumps(run(oracle_only='--oracle-only' in sys.argv)),flush=True)
