"""Microphysics and stationary-pressure checks for the R-z B1 screen."""
import argparse
import json
from pathlib import Path

import numpy as np
from scipy.integrate import solve_ivp

from reactive import burn,exchange,grid,hydro,load_microphysics,primitives,state,thermo


def main(code, out):
    table,net,y,_=load_microphysics(code)
    import pulse_model as pm
    from fast_eos import FastEOS
    from updated_network import kernel,setup
    exact=FastEOS()
    inputs=setup()[0]
    zz=net[1]
    ye=y@zz
    yi=y.sum()
    errors=[]
    for rho in (1.,1000.,30000.,3e5,3e6):
        for temp in (1e6,1e7,1e8,5e8,1e9):
            ref=exact.state(rho/1000,temp,ye,yi)
            p,e,_,_=thermo(rho,temp,ye,yi,table)
            errors.append((abs(p/(ref.p*.1)-1),abs(e/(ref.e*rho*1e-4)-1)))
    max_eos=np.max(errors,axis=0)
    assert max_eos.max()<.005

    r,z=grid(2,8,16,1.09)
    q=np.zeros((len(r)-1,len(z)-1,5+len(y)))
    q[:,:,0]=1000
    q[:,:,3]=thermo(1000,1e7,ye,yi,table)[1]
    q[:,:,4:4+len(y)]=1000*y
    stationary=hydro(q,primitives(q,zz,table),r,z,2,net[0],zz,table)
    residual=float(abs(stationary[:,:,1]).max()/q[:,:,3].max())
    assert residual<1e-14

    rng=np.random.default_rng(431)
    rho_field=rng.uniform(800,1200,q.shape[:2])
    temperatures=rng.uniform(1e7,2e7,q.shape[:2])
    q[:,:,0]=rho_field
    q[:,:,1:3]=rho_field[:,:,None]*rng.uniform(-1e5,1e5,q.shape[:2]+(2,))
    for i,j in np.ndindex(q.shape[:2]):
        q[i,j,3]=thermo(rho_field[i,j],temperatures[i,j],ye,yi,table)[1]+.5*(q[i,j,1:3]@q[i,j,1:3])/rho_field[i,j]
    q[:,:,4:4+len(y)]=rho_field[:,:,None]*y
    w=primitives(q,zz,table)
    volume=np.pi*np.diff(r*r)[:,None]*np.diff(z)[None,:]
    flux_r=np.sum((q[-1,:,3]+w[-1,:,2])*np.maximum(w[-1,:,0],0.)*2*np.pi*r[-1]*np.diff(z))
    flux_z=np.sum(((q[:,-1,3]+w[:,-1,2])*np.maximum(w[:,-1,1],0.)+
                   (q[:,0,3]+w[:,0,2])*np.maximum(-w[:,0,1],0.))*np.pi*np.diff(r*r))
    flux_residual=abs(np.sum(hydro(q,w,r,z,2,net[0],zz,table)[:,:,3]*volume)/(flux_r+flux_z)+1)
    assert flux_residual<1e-12
    previous=q[:,:,3].copy()
    escaped=exchange(q,w,1e-8,r,z,.001)
    exchange_residual=abs(np.sum((q[:,:,3]-previous)*volume)+escaped)/np.sum(previous*volume)
    assert exchange_residual<1e-12
    assert np.all(np.isfinite(primitives(q,zz,table)))

    rho=3e5
    T=5e8
    mass_energy=pm.MASS*9.648533212e13
    start=thermo(rho,T,ye,yi,table)[1]
    elapsed=2e-7
    def rhs(_, x):
        yy=x[:-1]
        e=start+rho*((y-yy)@mass_energy-x[-1])
        _,t,_,_=state(rho,e,yy@zz,yy.sum(),table)
        d,_,weak,_=kernel(np.array([t]),np.array([rho/1000]),yy[None,:],*inputs)
        return np.r_[d[0],weak[0]*1e-4]
    sol=solve_ivp(rhs,(0,elapsed),np.r_[y,0.],method='BDF',rtol=1e-9,
                  atol=np.r_[np.full(len(y),1e-13),1e-3])
    assert sol.success
    ref=(y-sol.y[:-1,-1])@mass_energy-sol.y[-1,-1]
    reaction_errors={}
    for count in (8,16,32,64):
        q=np.zeros((1,1,5+len(y)))
        q[0,0,0]=rho
        q[0,0,3]=start
        q[0,0,4:4+len(y)]=rho*y
        release=0.
        for _ in range(count):
            d,w=burn(q,primitives(q,zz,table),elapsed/count,np.ones((1,1)),table,net,1e8)
            release+=(d-w)/rho
        reaction_errors[str(count)]=release/ref-1
    assert abs(reaction_errors['64'])<.02
    assert abs(reaction_errors['64'])<abs(reaction_errors['8'])
    record=dict(max_eos_pressure_and_energy_errors=max_eos.tolist(),stationary_pressure_residual=residual,
                independent_open_boundary_flux_residual=flux_residual,
                isolated_grey_exchange_energy_residual=exchange_residual,
                reaction_density_kg_m3=rho,reaction_initial_K=T,reaction_duration_s=elapsed,
                reference_deposited_J_kg=ref,relative_reaction_errors=reaction_errors)
    out.write_text(json.dumps(record,indent=2,allow_nan=False)+'\n')
    print(record)


if __name__=='__main__':
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument('code',type=Path)
    p.add_argument('out',type=Path)
    a=p.parse_args()
    main(a.code,a.out)
