"""Dense AO and signed native references for doubles_fme minus occupied_fock."""
from itertools import combinations_with_replacement

import numpy as np

try:
    from . import bipole_r1_fock as prior
except ImportError:  # Direct script invocation.
    import bipole_r1_fock as prior

fixture, bare = prior.fixture, prior.bare
SINGLES, TOL = prior.SINGLES, prior.TOL
PIECES = ('bare_fov', 'direct', 'exchange')


def oracle(inputs, fock, singles=SINGLES, *, reverse=False):
    """Lift the ordered doubles to AO dyads; contract three AO covectors."""
    s, eri, _, occ, bases, placed, amps = inputs
    # Reconstruct independent PNO columns in the supplied amplitude gauge.
    c = {ij: b @ (b.T @ s @ placed[ij]) for ij, b in bases.items()}
    d = np.column_stack([c[n,n] @ singles[n % 2] for n in range(6)])
    # In chemists' AO indices: J_v=2 (mu v|x y) O_mu,m O_x,n D_y,n;
    # K_v=-(mu y|x v) O_mu,m D_y,n O_x,n. No PNO overlap in the ERI.
    rows = (occ.T @ fock,
            2*np.einsum('uvxy,um,xn,yn->mv', eri, occ, occ, d, optimize=True),
            -np.einsum('uyxv,um,yn,xn->mv', eri, occ, d, occ, optimize=True))
    out = {name: [] for name in (*PIECES, 'increment')}
    for i in range(6):
        lifted = []
        for m in range(6):
            t = amps[i,m].T if reverse else amps[i,m]
            pair = c[i,m] @ t @ c[i,m].T
            lifted.append(2*pair - pair.T)
        for name, row in zip(PIECES, rows, strict=True):
            out[name].append(c[i,i].T @ s @ np.einsum('muv,mv->u', lifted, row))
        out['increment'].append(sum(out[name][i] for name in PIECES))
    return out


def native_difference(inputs, fock, singles=SINGLES):
    """Evaluate both actual snapshots for each signed spectral sector; F once."""
    s, eri, virt, 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 = [virt.T @ s @ bases[ij] for ij in pairs]
    ts = [rot[ij] @ amps[ij] @ rot[ij].T for ij in pairs]
    t1 = [rot[i,i] @ singles[i % 2] for i in range(6)]
    out = [np.zeros_like(t) for t in t1]
    ev, u = 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 = ((u[:,keep]*np.sqrt(sign*ev[keep])).T.reshape(-1,12,12)
              if sign else np.zeros((1,12,12)))
        blocks = [np.ascontiguousarray((a.T @ ao @ b).reshape(len(ao), -1))
                  for a,b in ((occ,virt), (occ,occ), (virt,virt))]
        f = np.zeros_like(fock) if sign else fock
        got = bare.native._dlpno_ccsd_pno_evaluate(
            *blocks, occ.T@f@occ, occ.T@f@virt, virt.T@f@virt,
            [i for i,j in pairs], [j for i,j in pairs], pnos,
            [np.full(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']):
            diff = np.ravel(terms['doubles_fme']) - np.ravel(terms['occupied_fock'])
            out[i] += (sign or 1) * (rot[i,i].T @ diff)
    return out


def kernel_inputs(inputs, fock):
    s, eri, v, o, _, placed, amps = inputs
    g = np.einsum('uvxy,um,ve,xn,yf->menf', eri, o, v, o, v, optimize=True)
    rotations = {ij: v.T @ s @ c for ij,c in placed.items()}
    return o.T @ fock @ v, g, rotations, amps


def controls(inputs, fock):
    from vibeqc.dlpno.bipole_r1_doubles_fme import _contract
    s, _, v, o, *_ = inputs
    refs = oracle(inputs, fock)
    reversed_t = oracle(inputs, fock, reverse=True)
    def distance(a, b):
        return max(float(np.max(abs(x-y))) for x,y in zip(a,b,strict=True))
    negative = dict(wrong_pair_transpose=distance(reversed_t['increment'], refs['increment']),
                    omitted_exchange=distance([a+b for a,b in zip(refs['bare_fov'],refs['direct'],
                                                                  strict=True)], refs['increment']))
    assert min(negative.values()) > TOL, negative
    k = .03*np.sin(np.arange(36).reshape(6,6)+.3)
    delta = s @ (o @ k @ v.T + v @ k.T @ o.T) @ s
    known_error = float(np.max(abs(o.T @ delta @ v - k)))
    assert np.max(abs(delta-delta.T)) < 1e-12 and known_error < TOL
    perturbed = oracle(inputs, fock+delta)
    changed = distance(perturbed['bare_fov'], refs['bare_fov'])
    assert changed > TOL
    control = dict(known_block_error=known_error, bare_change=changed,
                   production_kernel=prior.compare(_contract(*kernel_inputs(inputs,fock+delta), SINGLES),
                                                   perturbed),
                   native=prior.comparison(native_difference(inputs,fock+delta), perturbed['increment']))
    return negative, control


def run():
    from dataclasses import replace
    from types import MappingProxyType
    from unittest.mock import patch
    from vibeqc.dlpno import bipole_r1_doubles_fme as action

    result, prepared, ts = fixture.prepare()
    inputs = fixture.reference_inputs(result, prepared, ts)
    _, fock, *_ = bare.supercell_operands(result, bare.op.GaussianCell(**bare.FIXTURE))
    h = result.terminal_transitions
    limits = dict(max_bytes=h.required_bytes, max_work=action.WORK_BOUND)
    refs = oracle(inputs, fock)
    native = native_difference(inputs, fock)
    record = dict(atol=TOL, imaginary_atol=1e-12, source=h.identity, source_record=h.provenance,
                  build=prepared.pair_build.identity, ranks=list(prepared.pair_build.spaces.pair_ranks),
                  singles=[t.tolist() for t in SINGLES], doubles=[t.tolist() for t in ts],
                  raw_mp2=prepared.solution.e_pair_per_cell,
                  native_oracle=prior.comparison(native, refs['increment']))
    assert sum(a.size for a in native) == 12
    record['negative'], record['fock_control'] = controls(inputs, fock)
    record['refusals'] = prior.fock_case.half_case.quadratic.refusals(
        result, prepared, lambda r,p,s,**kw: action.doubles_fme_terms(r,p,ts,s,**kw), limits)

    captured = []
    check, real = action._check_blocks, action._real
    def capture(blocks, *args):
        check(blocks, *args)
        captured.append(blocks)
    def reconstruct(g):
        record['max_imaginary_ovov'] = float(np.max(abs(g.imag)))
        return real(g)
    with patch.object(action, '_check_blocks', capture), patch.object(action, '_real', reconstruct):
        actual = action.doubles_fme_terms(result, prepared, ts, SINGLES, **limits)
    record['production_oracle'] = prior.compare(actual, refs)
    record['production_native'] = prior.comparison(actual['increment'], native)
    record['physical_bare_max'] = max(float(np.max(abs(a))) for a in refs['bare_fov'])
    block, = captured
    for name, change in (
            ('identity', dict(identity='0'*64)), ('issuer', dict(_issuer=object())),
            ('transfer', dict(transfer=(0,)*len(block.transfer))),
            ('shape', dict(blocks=MappingProxyType({'ovov': np.zeros((2,),complex)})))):
        with patch.object(type(h), 'coulomb_blocks', return_value=replace(block, **change)):
            try:
                action.doubles_fme_terms(result, prepared, ts, SINGLES, **limits)
            except ValueError as exc:
                record['refusals']['invalid_block_'+name] = str(exc)
            else:
                raise AssertionError('invalid block admitted: '+name)
    # The physical integrals are amplitude independent. Reuse this very lease
    # in the controls; the public action still checks its state and provenance.
    record['scaling'] = {}
    with patch.object(type(h), 'coulomb_blocks', return_value=block):
        for alpha,beta in ((1.,0.), (0.,1.), (-1.7,1.)):
            singles = [alpha*t for t in SINGLES]
            doubles = [beta*t for t in ts]
            got = action.doubles_fme_terms(result, prepared, doubles, singles, **limits)
            want = {k: [a*(beta if k=='bare_fov' else alpha*beta) for a in refs[k]] for k in PIECES}
            want['increment'] = [sum(parts) for parts in zip(*(want[k] for k in PIECES),strict=True)]
            data = (*inputs[:-1], {ij: beta*t for ij,t in inputs[-1].items()})
            if beta == 0:
                assert all(np.count_nonzero(a)==0 for values in got.values() for a in values)
            if alpha == 0:
                assert all(np.array_equal(a,b) for a,b in zip(got['increment'],got['bare_fov'],strict=True))
            record['scaling'][f'{alpha},{beta}'] = dict(
                polynomial=prior.compare(got,want), oracle=prior.compare(got,oracle(data,fock,singles)),
                native=prior.comparison(got['increment'],native_difference(data,fock,singles)))
    record['resources'] = action.resource_census()
    return record


if __name__ == '__main__':
    import json
    print(json.dumps(run()))
