"""Independent finite AO oracles for the first two native R1 snapshots.

Predeclared component gate 1e-10 Ha, real reconstruction 1e-12. The physical
fixture and supplied nonconverged amplitudes are unchanged. Synthetic Fock
controls are separate from the physical scientific comparison.
"""
import json
from itertools import combinations_with_replacement
import numpy as np
try:
    from . import bipole_fock as fock_case
except ImportError:
    import bipole_fock as fock_case
fixture, bare = fock_case.fixture, fock_case.bare
SINGLES, TOL = fixture.SINGLES, 1e-10
NAMES = ('linear_fvv', 'quadratic_fov', 'quadratic_ovvv', 'doubles', 'cubic')


def oracle(inputs, fock, singles=SINGLES, *, early_projection=False, transpose_doubles=False):
    """AO contractions; no production intermediate or integral transform."""
    s, eri, virtual, occ, bases, placed, amps = inputs
    rot = {ij:c.T@s@placed[ij] for ij,c in bases.items()}
    pair = {ij:c@rot[ij]@(amps[ij].T if transpose_doubles else amps[ij])@rot[ij].T@c.T
            for ij,c in bases.items()}
    d = np.column_stack([bases[m,m]@rot[m,m]@singles[m%2] for m in range(6)])
    out = {name:{} for name in ('seed', *NAMES, 'increment', 'total')}
    for i in range(6):
        c = bases[i,i]; u = rot[i,i]; p = c.T@s
        di = d[:,i]; inputs_d = c@p@d if early_projection else d
        values = [c.T@fock@di, np.zeros(c.shape[1]), np.zeros(c.shape[1]),
                  np.zeros(c.shape[1]), np.zeros(c.shape[1])]
        for m in range(6):
            values[1] -= .5*(p@d[:,m])*(occ[:,m]@fock@di)
            values[2] += 2*np.einsum('uvxy,u,v,xa,y->a',eri,occ[:,m],inputs_d[:,m],c,di,optimize=True)
            values[2] -= np.einsum('uvxy,u,v,xa,y->a',eri,occ[:,m],di,c,inputs_d[:,m],optimize=True)
            for n in range(6):
                # Only the free first source-double leg is projected to [ii].
                tmn = p@pair[m,n]
                if early_projection: tmn = tmn@s@c@c.T
                values[3] -= 2*np.einsum('uvxy,u,v,x,ay->a',eri,occ[:,m],di,occ[:,n],tmn,optimize=True)
                values[3] += np.einsum('uvxy,u,av,x,y->a',eri,occ[:,m],tmn,occ[:,n],di,optimize=True)
                scalar = 2*np.einsum('uvxy,u,v,x,y',eri,occ[:,m],di,occ[:,n],inputs_d[:,n],optimize=True)
                scalar -= np.einsum('uvxy,u,v,x,y',eri,occ[:,m],inputs_d[:,n],occ[:,n],di,optimize=True)
                values[4] -= .5*(p@d[:,m])*scalar
        out['seed'][i] = u.T@(occ[:,i]@fock@c)
        for name,value in zip(NAMES,values,strict=True): out[name][i] = u.T@value
        out['increment'][i] = sum(out[name][i] for name in NAMES)
        out['total'][i] = out['seed'][i]+out['increment'][i]
    return out


def native_snapshots(inputs, fock, singles=SINGLES):
    """Actual shared_residual_singles boundaries, signed ERIs and F once."""
    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)]
    snapshots = {name:{i:np.zeros_like(t1[i]) for i in range(6)} for name in ('fock','virtual_fock')}
    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))]
        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])*7 for p in pnos],
            [np.zeros_like(t) for t in ts],ts,[list(range(6)) for _ in pairs],t1,True)
        for i,terms in enumerate(got['singles_terms']):
            for name in snapshots: snapshots[name][i] += (sign or 1)*np.asarray(terms[name]).reshape(-1)
    snaps = {name:{i:rot[i,i].T@a for i,a in values.items()} for name,values in snapshots.items()}
    return dict(seed=snaps['fock'], total=snaps['virtual_fock'],
                increment={i:snaps['virtual_fock'][i]-snaps['fock'][i] for i in range(6)})


def comparison(actual, reference):
    rows = {}; worst = 0.
    for i in range(6):
        a,b = np.asarray(actual[i]),np.asarray(reference[i]); error=a-b
        assert a.shape==b.shape and np.isfinite(error).all()
        worst=max(worst,float(np.max(abs(error))))
        rows[str(i)]=dict(actual=a.tolist(),reference=b.tolist(),signed_error=error.tolist())
    assert worst<=TOL,worst
    return dict(max_abs=worst,components=rows)


def compare(actual, reference):
    return {k:comparison(v,reference[k]) for k,v in actual.items()}


def synthetic_inputs():
    """Asymmetric real finite spaces, metric and signed physical-symmetry ERIs."""
    rng=np.random.default_rng(1049)
    a=rng.normal(size=(12,12));s=a.T@a+np.eye(12)
    e,u=np.linalg.eigh(s);q,_=np.linalg.qr(rng.normal(size=(12,12)))
    c=(u/np.sqrt(e))@u.T@q; o,v=c[:,:6],c[:,6:]
    a=rng.normal(size=(7,12,12));a=.04*(a+a.transpose(0,2,1))
    eri=np.einsum('Puv,Pxy,P->uvxy',a,a,np.array([1,-1,1,-1,1,1,1]))
    bases={};placed={};amps={}
    for i in range(6):
        for j in range(i,6):
            n=2 if i==j else 2+(i+j)%2
            u,_=np.linalg.qr(rng.normal(size=(6,n)));w,_=np.linalg.qr(rng.normal(size=(n,n)))
            bases[i,j]=bases[j,i]=v@u;placed[i,j]=placed[j,i]=v@u@w
            t=rng.normal(size=(n,n))*.1
            if i==j:t=(t+t.T)/2
            amps[i,j]=t;amps[j,i]=t.T
    f=rng.normal(size=(12,12));f=.03*(f+f.T)
    return (s,eri,v,o,bases,placed,amps),f


def kernel_inputs(inputs, fock, singles=SINGLES):
    s,eri,v,o,bases,placed,amps = inputs
    rot = {ij:v.T@s@c for ij,c in placed.items()}
    t = np.asarray([[rot[m,n]@amps[m,n]@rot[m,n].T for n in range(6)] for m in range(6)])
    d = np.stack([rot[m,m]@singles[m%2] for m in range(6)])
    def tr(a,b,c,e): return np.einsum('uvxy,ui,vj,xk,yl->ijkl',eri,a,b,c,e,optimize=True)
    return o.T@fock@v, v.T@fock@v, tr(o,v,o,v), tr(o,v,v,v), t, d, rot


def algebra_check():
    from vibeqc.dlpno.bipole_r1_fock import _contract
    inputs,fock=synthetic_inputs()
    refs=oracle(inputs,fock);native=native_snapshots(inputs,fock)
    return dict(native=compare(native,refs),kernel=compare(_contract(*kernel_inputs(inputs,fock)),refs))


def negative_controls(inputs, fock, refs, action):
    s,eri,v,o,bases,placed,amps=inputs
    early=oracle(inputs,fock,early_projection=True)
    reversed_t=oracle(inputs,fock,transpose_doubles=True)
    negative={}
    def separation(name,actual,expected):
        error=max(float(np.max(abs(actual[i]-expected[i]))) for i in range(6))
        assert error>TOL,(name,error)
        negative[name]=error
    separation('early_input_projection',early['increment'],refs['increment'])
    separation('reversed_source_doubles',reversed_t['increment'],refs['increment'])
    separation('wrong_update_sign',{i:-a for i,a in refs['increment'].items()},refs['increment'])
    separation('R2_full_instead_of_R1_half',
        {i:refs['increment'][i]+refs['quadratic_fov'][i]+refs['cubic'][i] for i in range(6)},refs['increment'])
    # Known nonzero O-V block in an S-orthonormal complete orbital frame.
    k=.03*np.sin(np.arange(36).reshape(6,6)+.3)
    delta=s@(o@k@v.T+v@k.T@o.T)@s
    sf=fock+delta
    sentinel=oracle(inputs,sf);sn=native_snapshots(inputs,sf)
    frames=[placed[i,i] for i in range(6)]
    prod=action._seed(sf,o,frames)
    expected={i:refs['seed'][i]+k[i]@(v.T@s@frames[i]) for i in range(6)}
    sentinel_checks=dict(seed_known_block=comparison(prod,expected),native=compare(sn,sentinel),
        kernel=compare(action._contract(*kernel_inputs(inputs,sf)),sentinel))
    separation('seed_wrong_sign',{i:-prod[i] for i in range(6)},expected)
    separation('seed_wrong_frame',{i:o[:,i]@sf@frames[(i+1)%6] for i in range(6)},expected)
    separation('seed_extra_metric',{i:o[:,i]@s@sf@frames[i] for i in range(6)},expected)
    theta=np.exp(1j*np.linspace(.2,1.3,6)); phases=np.exp(1j*np.array([.37,-.61]))
    of=o*theta;cf=[a*phases for a in frames]
    got=action._seed(sf,of,cf)
    want={i:theta[i].conjugate()*expected[i]*phases for i in range(6)}
    err=max(float(np.max(abs(got[i]-want[i]))) for i in range(6));assert err<TOL
    separation('seed_missing_bra_conjugation',{i:of[:,i]@sf@cf[i] for i in range(6)},want)
    # A complex gauge of complete physical orbitals independently exposes both bra legs.
    c=np.column_stack((o,v)).astype(complex)*np.exp(1j*np.linspace(.1,1.7,12))
    correct=np.einsum('uvxy,um,ve,xa,yf->meaf',eri,c[:,:6].conj(),c[:,6:],c[:,6:].conj(),c[:,6:],optimize=True)
    wrong=np.einsum('uvxy,um,ve,xa,yf->meaf',eri,c[:,:6],c[:,6:],c[:,6:],c[:,6:],optimize=True)
    error=float(np.max(abs(correct-wrong)));assert error>TOL
    negative['integral_missing_bra_conjugations']=error
    sentinel_checks.update(hermiticity_error=float(np.max(abs(sf-sf.T))),
        known_ov_error=float(np.max(abs(o.T@delta@v-k))),
        nonzero_seed_max=max(float(np.max(abs(a))) for a in prod),
        physical_seed_max=max(float(np.max(abs(a))) for a in refs['seed'].values()),
        complex_frame_covariance_error=err,occupied_virtual_block=k.tolist(),fock_perturbation=delta.tolist(),
        scope='controlled contraction/native checks; authenticated physical source is never altered')
    return negative,sentinel_checks


def run(*, oracle_only=False):
    result,prepared,doubles=fixture.prepare()
    inputs=fixture.reference_inputs(result,prepared,doubles)
    _,fock,_,_,_=bare.supercell_operands(result,bare.op.GaussianCell(**bare.FIXTURE))
    refs=oracle(inputs,fock);native=native_snapshots(inputs,fock)
    record=dict(atol=TOL,imaginary_atol=1e-12,occupied_placements=6,components_per_comparison=12,
        oracle_native=compare(native,refs),source=result.terminal_transitions.identity,
        source_record=result.terminal_transitions.provenance,build=prepared.pair_build.identity,
        raw_mp2=prepared.solution.e_pair_per_cell,singles=[a.tolist() for a in SINGLES],
        doubles=[a.tolist() for a in doubles])
    assert sum(a.size for a in refs['seed'].values())==12
    print('Independent R1 seed/increment and actual native snapshots PASS',flush=True)
    if oracle_only:return record
    from copy import copy
    from dataclasses import replace
    from unittest.mock import patch
    import vibeqc.dlpno.bipole_r1_fock as action
    h,z=result.terminal_transitions,prepared.pair_build.spaces
    limits=dict(max_bytes=h.required_bytes,max_work=action.WORK_BOUND)
    seed_limits=dict(max_bytes=h.required_bytes,max_work=action.SEED_WORK)
    record['synthetic']=algebra_check()
    record['negative_controls'],record['fock_control']=negative_controls(inputs,fock,refs,action)
    record['refusals']=fock_case.half_case.quadratic.refusals(result,prepared,
        lambda r,p,s,**kw:action.virtual_fock_terms(r,p,doubles,s,**kw),limits)
    refused=record['refusals']
    def refuse(name,func):
        try:func()
        except (ValueError,MemoryError) as exc:refused[name]=str(exc)
        else:raise AssertionError(name+' admitted')
    for name,kw in (('seed_short_bytes',dict(seed_limits,max_bytes=h.required_bytes-1)),
                    ('seed_short_work',dict(seed_limits,max_work=action.SEED_WORK-1))):
        refuse(name,lambda kw=kw:action.fock_seed(result,prepared,**kw))
    badz=copy(z);badz._fock=z._fock.copy();badz._fock[0,0]+=.01
    bad=replace(prepared,pair_build=replace(prepared.pair_build,spaces=badz))
    refuse('seed_changed_fock',lambda:action.fock_seed(result,bad,**seed_limits))
    refuse('update_changed_fock',lambda:action.virtual_fock_terms(result,bad,doubles,SINGLES,**limits))
    # The seed has its own stale/frame gates even though it uses no integral lease.
    badz=copy(z);frames=list(z.pair_coefficients);frames[0]=frames[0].copy();frames[0][:,0]*=-1
    badz.pair_coefficients=tuple(frames);bad=replace(prepared,pair_build=replace(prepared.pair_build,spaces=badz))
    refuse('seed_changed_frame',lambda:action.fock_seed(result,bad,**seed_limits))
    energy=result.energy
    try:
        object.__setattr__(result,'energy',energy+.01)
        refuse('seed_stale_source',lambda:action.fock_seed(result,prepared,**seed_limits))
    finally:object.__setattr__(result,'energy',energy)
    seed=action.fock_seed(result,prepared,**seed_limits)
    record['seed_production']=comparison(seed,refs['seed'])
    captured=[];check=action._check_blocks
    def capture(*args,**kwargs):check(*args,**kwargs);captured[:]=[args[0]]
    with patch.object(action,'_check_blocks',capture):
        actual=action.virtual_fock_terms(result,prepared,doubles,SINGLES,**limits)
    record['production']=compare(actual,refs)
    record['production_native']=compare({k:actual[k] for k in native},native)
    for name,change in (('invalid_block_identity',dict(identity='0'*64)),
                        ('invalid_block_issuer',dict(_issuer=object())),
                        ('invalid_block_transfer',dict(transfer=tuple(0 for _ in captured[0].transfer)))):
        with patch.object(type(h),'coulomb_blocks',return_value=replace(captured[0],**change)):
            refuse(name,lambda:action.virtual_fock_terms(result,prepared,doubles,SINGLES,**limits))
    record['scaling']={}
    # alpha scales T1, beta scales T2: alpha L + alpha^2 Q + alpha*beta D + alpha^3 C.
    for alpha,beta in ((0.,1.),(-1.7,.6),(.6,-1.25),(1.,0.)):
        ss=[alpha*a for a in SINGLES];tt=[beta*a for a in doubles]
        xi=(*inputs[:-1],{ij:beta*a for ij,a in inputs[-1].items()})
        expected=oracle(xi,fock,ss);sn=native_snapshots(xi,fock,ss)
        got=action.virtual_fock_terms(result,prepared,tt,ss,**limits)
        powers=dict(linear_fvv=alpha,quadratic_fov=alpha**2,quadratic_ovvv=alpha**2,
                    doubles=alpha*beta,cubic=alpha**3)
        poly={name:{i:scale*refs[name][i] for i in range(6)} for name,scale in powers.items()}
        if alpha==0:assert all(np.count_nonzero(a)==0 for a in got['increment'])
        record['scaling'][f'{alpha},{beta}']=dict(production=compare(got,expected),
            native=compare(sn,expected),polynomial=compare(poly,expected))
    record['resource_census']=action.resource_census()
    record['coverage']='R1 fock seed and isolated virtual_fock-fock; sum equals virtual_fock'
    record['next_boundary']='occupied_fock - virtual_fock: full occupied F_mi contraction with output singles'
    return record


if __name__=='__main__':
    import argparse
    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--oracle-only',action='store_true')
    print(json.dumps(run(oracle_only=p.parse_args().oracle_only)),flush=True)
