"""Reciprocal nonlinear field and heterogeneous resonant receivers.

All awareness language is a proposed interpretation, not a simulated observable.
"""
from __future__ import annotations
import numpy as np

N=64
J=4
MODES=19
TRIALS=256
DT=.1
END=75.
INTERVENTION=25.
OMEGA0=.5
DIFFUSION=3.
GAMMA=.08
COUPLING=.03
SPREAD=.04
NOISE=.015
DETUNE=.8
CARRIERS=np.array([2,5,9,13])
BRANCHES=("MATCHED","DETUNED","DISCONNECTED","RETUNED","ERASED","BLOCKED_AFTER")


def frequencies(n=N):
    return OMEGA0+4*DIFFUSION*np.sin(np.pi*np.arange(n)/n)**2


def field_step(psi,dt,nonlinearity,omega):
    if nonlinearity:
        psi*=np.exp(-.5j*nonlinearity*abs(psi)**2*dt)
    psi=np.fft.ifft(np.fft.fft(psi,axis=-1,norm="ortho")*np.exp(-1j*omega*dt),axis=-1,norm="ortho")
    if nonlinearity:
        psi*=np.exp(-.5j*nonlinearity*abs(psi)**2*dt)
    return psi


def brain_step(z,dt,eigenvalues,gamma):
    before=np.sum(abs(z)**2,axis=(-2,-1))
    z*=np.exp((-gamma-1j*eigenvalues)*dt)
    lost=before*(1-np.exp(-2*gamma*dt))
    return z,lost


def couple(psi,z,sites,b,g,dt):
    # Sites are distinct; each bright receiver mode is normalized.
    for j,site in enumerate(sites):
        q=np.sum(b[j].conj()*z[...,j,:],axis=-1)
        old=psi[...,site].copy()
        c=np.cos(g[...,j]*dt)
        s=np.sin(g[...,j]*dt)
        psi[...,site]=c*old-1j*s*q
        new_q=c*q-1j*s*old
        z[...,j,:]+=(new_q-q)[...,None]*b[j]
    return psi,z


def step(psi,z,dt,nonlinearity,omega,eigenvalues,sites,b,g,gamma=GAMMA):
    psi=field_step(psi,dt/2,nonlinearity,omega)
    z,loss1=brain_step(z,dt/2,eigenvalues,gamma)
    psi,z=couple(psi,z,sites,b,g,dt)
    z,loss2=brain_step(z,dt/2,eigenvalues,gamma)
    psi=field_step(psi,dt/2,nonlinearity,omega)
    return psi,z,loss1+loss2


def make_world(index):
    rng=np.random.default_rng(11170000+index)
    labels=np.empty((TRIALS,J),dtype=np.int64)
    for j in range(J):
        labels[:128,j]=rng.permutation(np.repeat(np.arange(4),32))
        labels[128:,j]=rng.permutation(np.repeat(np.arange(4),32))
    coeff=np.zeros((TRIALS,N),dtype=complex)
    for j,mode in enumerate(CARRIERS):coeff[:,mode]=np.exp(.5j*np.pi*labels[:,j])
    psi=np.fft.ifft(coeff,axis=-1,norm="ortho")
    sites=np.sort(rng.choice(N,size=J,replace=False))
    eig=[];b=[]
    for j in range(J):
        h=rng.normal(size=(MODES,MODES));h=(h+h.T)/2
        ev,u=np.linalg.eigh(h);ev/=max(abs(ev))
        coupling=rng.normal(size=MODES)+1j*rng.normal(size=MODES)
        coupling/=np.linalg.norm(coupling)
        b.append(u.T@coupling)
        eig.append(frequencies()[CARRIERS[j]]+SPREAD*ev)
    z=.02*(rng.normal(size=(TRIALS,J,MODES))+1j*rng.normal(size=(TRIALS,J,MODES)))
    return psi,z,labels,np.array(eig),np.array(b),sites


def accuracy(readout,labels):
    # Fixed nearest-class-centroid decoder; only the training half fits prototypes.
    scores=[];predictions=np.empty((128,J),dtype=np.int64)
    for j in range(J):
        train=readout[:128,j]
        centers=np.array([train[labels[:128,j]==k].mean() for k in range(4)])
        prediction=np.argmin(abs(readout[128:,j,None]-centers[None,:])**2,axis=1)
        predictions[:,j]=prediction
        scores.append(float(np.mean(prediction==labels[128:,j])))
    return float(np.mean(scores)),scores,predictions


def simulate(index,nonlinearity):
    initial_psi,initial_z,labels,eig,b,sites=make_world(index)
    branches=len(BRANCHES)
    psi=np.repeat(initial_psi[None,:,:],branches,axis=0)
    z=np.repeat(initial_z[None,:,:,:],branches,axis=0)
    n0=np.sum(abs(psi)**2,axis=-1)
    total0=n0+np.sum(abs(z)**2,axis=(-2,-1))
    bath=np.zeros_like(n0);erased=np.zeros_like(n0)
    shift=np.zeros((branches,1,J,1))
    shift[[1,3]]=DETUNE
    eigenvalues=eig[None,None,:,:]+shift
    g=np.full((branches,1,J),COUPLING);g[2]=0
    residual=0.
    trace={"time":[],"field_norm":[],"receiver_norm":[],"q_real":[],"q_imag":[],"spatial_intensity":[]}
    for k in range(int(round(END/DT))):
        if k==int(round(INTERVENTION/DT)):
            shift[3]=0
            eigenvalues=eig[None,None,:,:]+shift
            erased[4]+=np.sum(abs(z[4])**2,axis=(-2,-1));z[4]=0
            g[5]=0
        psi,z,loss=step(psi,z,DT,nonlinearity,frequencies(),eigenvalues,sites,b,g)
        bath+=loss
        norm_field=np.sum(abs(psi)**2,axis=-1)
        norm_brain=np.sum(abs(z)**2,axis=(-2,-1))
        budget=norm_field+norm_brain+bath+erased
        residual=max(residual,float(np.max(abs(budget-total0)/total0)))
        if index==0 and (k%10==0 or k==int(round(END/DT))-1):
            q=np.sum(b.conj()[None,:,:]*z[:,0],axis=-1)
            trace["time"].append((k+1)*DT)
            trace["field_norm"].append(norm_field[:,0].tolist())
            trace["receiver_norm"].append(norm_brain[:,0].tolist())
            trace["q_real"].append(q.real.tolist());trace["q_imag"].append(q.imag.tolist())
            trace["spatial_intensity"].append((abs(psi[:,0,:])**2).tolist())
    q=np.sum(b.conj()[None,None,:,:]*z,axis=-1)
    rng=np.random.default_rng(11175000+index)
    # Identical sensor noise across counterfactual branches.
    noise=NOISE*(rng.normal(size=(TRIALS,J))+1j*rng.normal(size=(TRIALS,J)))
    observed=q+noise[None,:,:]
    result={"world":index,"seed":11170000+index,"lambda":nonlinearity,
            "max_norm_budget_relative_residual":residual,
            "finite":bool(np.isfinite(psi).all() and np.isfinite(z).all()),"branches":{}}
    predictions=[]
    for i,name in enumerate(BRANCHES):
        acc,each,pred=accuracy(observed[i],labels);predictions.append(pred)
        result["branches"][name]={"accuracy":acc,"receiver_accuracies":each,
            "mean_final_carrier_norm_fraction":float(np.mean(norm_field[i]/n0[i])),
            "mean_final_receiver_norm":float(np.mean(norm_brain[i])),
            "mean_bath_loss":float(np.mean(bath[i])),"mean_erasure_loss":float(np.mean(erased[i]))}
    arrays={"labels":labels,"readout_real":observed.real,"readout_imag":observed.imag,
            "prediction":np.array(predictions),"checkpoint_message_indices":np.arange(8),
            "checkpoint_final_field":psi[:,:8,:],"checkpoint_final_receiver_modes":z[:,:8,:,:],
            "final_field_norm":norm_field,"final_receiver_norm":norm_brain,
            "initial_total_norm":total0,"initial_carrier_norm":n0,"carrier_norm_fraction":norm_field/n0,
            "bath_loss":bath,"erasure_loss":erased,"tuning_eigenvalues":eig,
            "coupling_vector":b,"sites":sites}
    return result,arrays,trace
