#!/usr/bin/env python3
"""Full Cartesian-FEM audit of arbitrary-strength balanced-port robustness.

The nearby nexus_core.py is an unchanged portable copy of the full Cartesian
pressure FEM. This verifier adds finite-rank penalties or exact constraints to
that discretized energy. It checks balanced strengths from zero to 1e8 and
infinity, and anchored strengths lambda=tau*epsilon.
"""
from pathlib import Path
import argparse
import json
import numpy as np
from nexus_core import _base_problem


def solve_port(base, epsilon, kind, strength):
    if kind=='balanced':
        row=(base['port'][0]-base['port'][1])[None,:]
    elif kind=='anchored':
        row=(base['port'][0]+base['port'][1])[None,:]
    else:raise ValueError('Unknown port kind')
    free=base['free'];L=row[:,free]
    z0=base['z0'];W=base['solve'](L.T)
    S=L@W;y0=L@z0+row[:,1]
    hard=np.isinf(strength)
    if hard:
        multiplier=np.linalg.solve(S,y0)
    else:
        multiplier=strength*np.linalg.solve(np.eye(len(row))+strength*S,y0)
    z=z0-W@multiplier
    # Evaluate the original positive local energy first, then the exact port
    # penalty. Hard constraints do not add a finite quadratic port energy.
    full,e=base['evaluate'](z,np.zeros_like(row))
    port_value=float((row@full)[0])
    port_energy=0. if hard else float(strength*port_value*port_value)
    capacity=e['capacity']+port_energy
    residual=base['Hff']@z-base['rhs']+L.T@multiplier
    relres=float(np.linalg.norm(residual)/max(np.linalg.norm(base['rhs']),1.))
    return dict(epsilon=epsilon,kind=kind,
                strength='infinity' if hard else float(strength),
                cells=base['cells'],xmax=float(base['xmax']),
                capacity=float(capacity),scaled_capacity=float(capacity/epsilon),
                impedance=float(1/capacity),port_value=port_value,
                derivative_energy=e['derivative_energy'],
                local_leakage_energy=e['local_leakage_energy'],
                nonlocal_port_energy=port_energy,
                relative_stationarity_residual=relres)


def run(output):
    rows=[]
    strengths=[0.,1.,1e4,1e8,np.inf]
    taus=[0.,.25,1.,4.]
    for eps in [1e-4,1e-5,1e-6]:
        base=_base_problem(eps,cells=8000)
        for strength in strengths:
            row=solve_port(base,eps,'balanced',strength)
            row['predicted_scaled_capacity']=3.
            row['relative_error_to_limit']=abs(row['scaled_capacity']/3.-1)
            rows.append(row)
        for tau in taus:
            row=solve_port(base,eps,'anchored',tau*eps)
            row['tau']=tau
            row['predicted_scaled_capacity']=3.+4*tau
            row['relative_error_to_limit']=abs(row['scaled_capacity']/row['predicted_scaled_capacity']-1)
            rows.append(row)
    checks=[]
    for cells in [4000,8000,16000]:
        base=_base_problem(1e-5,cells=cells)
        for kind,strength in [('balanced',np.inf),('anchored',1e-5)]:
            row=solve_port(base,1e-5,kind,strength)
            row['check']='mesh';checks.append(row)
    base=_base_problem(1e-5,cells=16000,endpoint=5.)
    tail=[]
    for kind,strength in [('balanced',np.inf),('anchored',1e-5)]:
        row=solve_port(base,1e-5,kind,strength)
        row['check']='endpoint';tail.append(row)
    for kind in ['balanced','anchored']:
        mesh=[r for r in checks if r['kind']==kind]
        relmesh=abs(mesh[-1]['capacity']/mesh[-2]['capacity']-1)
        reltail=abs(next(r for r in tail if r['kind']==kind)['capacity']/mesh[-1]['capacity']-1)
        assert relmesh<3e-4,(kind,'mesh',relmesh)
        assert reltail<3e-4,(kind,'endpoint',reltail)
    last=[r for r in rows if r['epsilon']==1e-6]
    assert max(r['relative_error_to_limit'] for r in last)<2e-4
    hard=[r for r in rows+checks+tail if r['strength']=='infinity']
    assert max(abs(r['port_value']) for r in hard)<1e-10
    assert max(r['relative_stationarity_residual'] for r in rows+checks+tail)<1e-9
    result=dict(status='PASS',method='Full Cartesian pressure FEM with six-point quadrature; low-rank passive updates and exact hard constraints',
                model=dict(a=2,b=.8,s=3,A=1,B=1,
                           f1='indicator [1,2]',f2='indicator [3,4]'),
                balanced_prediction='kappa/epsilon -> 3 uniformly over fixed or epsilon-dependent strength in [0,infinity]',
                anchored_prediction='for lambda=tau*epsilon, kappa/epsilon -> 3+4*tau',
                hard_constraint_max_absolute_error=max(abs(r['port_value']) for r in hard),
                rows=rows+checks+tail,
                scope='Finite parameter and finite mesh checks illustrate, but do not independently prove, the analytic uniform theorem')
    output=Path(output);output.parent.mkdir(parents=True,exist_ok=True)
    output.write_text(json.dumps(result,indent=2)+'\n')
    print(json.dumps(dict(status=result['status'],runs=len(result['rows']),
                         last_parameter_rows=last,
                         hard_constraint_error=result['hard_constraint_max_absolute_error'],
                         output=str(output)),indent=2))
    return result


if __name__=='__main__':
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output',default=str(Path(__file__).resolve().parents[1]/'results'/'nexus_uniform.json'))
    run(parser.parse_args().output)