#!/usr/bin/env python3
"""Independent Gaussian-quadrature FEM check of weak rank-one twist capacity.

The original two-component pressure energy is discretized in a rotating basis.
Six-point quadrature integrates derivative connection terms and the leakage
penalty; no nodal or midpoint-only approximation of the rank-one sink is used.
Boundary data: dark pressure 1 at the inlet, bright pressure free, zero pressure
at a remote truncated endpoint. Results concern the stated reduced model.
"""
from pathlib import Path
import argparse
import json
import numpy as np
from scipy import sparse
from scipy.sparse.linalg import spsolve
from scipy.special import gamma
from numpy.polynomial.legendre import leggauss


def limit_constant(a, s):
    nu = (a + 1) / (2*s)
    if not 0 < nu < 1:
        raise ValueError('Supercritical formula requires 0<nu<1')
    return float(s*2**(1-2*nu)*gamma(1-nu)/gamma(nu))


def fem_capacity(eps, s=2.0, a=2.0, b=0.8, A=1.0, B=1.0,
                 cells=4000, endpoint=6.0, quadrature=6, frame='rotating'):
    """Return full-model effective capacity and its rescaled value.

    t=eps**(1/s)*x; P=Rot(t**s-eps)*(bright,dark).
    Dividing energy by eps**((a+1)/s)/A gives the functional
    int t**(-a) |z'+s*t**(s-1)*J*z|**2
        + A*B*eps**(-(a-b+2)/s)*t**(-b)*bright**2 dt.
    """
    start = eps**(1/s)
    ts = np.geomspace(start, endpoint, cells+1)
    widths = np.diff(ts)
    points, weights = leggauss(quadrature)
    loc = np.zeros((cells,4,4))
    penalty = A*B*eps**(-(a-b+2)/s)
    cached = []
    for gp, gw in zip(points, weights):
        n1, n2 = (1-gp)/2, (1+gp)/2
        tt = (ts[:-1]+ts[1:])/2 + widths*gp/2
        kk = s*tt**(s-1)
        dp = 1/widths
        BB = np.zeros((cells,2,4))
        if frame == 'rotating':
            BB[:,0,:] = np.stack((-dp, -kk*n1, dp, -kk*n2),axis=1)
            BB[:,1,:] = np.stack((kk*n1, -dp, kk*n2, dp),axis=1)
            CC = np.broadcast_to(np.array([n1,0,n2,0]),(cells,4))
        elif frame == 'physical':
            BB[:,0,:] = np.stack((-dp,0*dp,dp,0*dp),axis=1)
            BB[:,1,:] = np.stack((0*dp,-dp,0*dp,dp),axis=1)
            theta=tt**s-eps
            ct,st=np.cos(theta),np.sin(theta)
            CC=np.stack((n1*ct,n1*st,n2*ct,n2*st),axis=1)
        else:
            raise ValueError('unknown frame')
        WW = widths*gw/2
        loc += (WW*tt**(-a))[:,None,None]*np.einsum('nki,nkj->nij',BB,BB)
        loc += (WW*penalty*tt**(-b))[:,None,None]*np.einsum('ni,nj->nij',CC,CC)
        cached.append((BB,CC,WW,tt))
    ids = 2*np.arange(cells)[:,None]+np.arange(4)[None,:]
    rr = np.broadcast_to(ids[:,:,None],loc.shape).ravel()
    cc = np.broadcast_to(ids[:,None,:],loc.shape).ravel()
    size=2*(cells+1)
    mat=sparse.coo_matrix((loc.ravel(),(rr,cc)),shape=(size,size)).tocsr()
    # h(start)=1, u(start) free; final values both zero.
    fixed=np.array([1,size-2,size-1])
    free=np.setdiff1d(np.arange(size),fixed,assume_unique=True)
    rhs=-mat[free,1].toarray().ravel()
    mm=mat[free,:][:,free].tocsc()
    diag=1/np.sqrt(mm.diagonal())
    scale=sparse.diags(diag)
    zz=np.zeros(size)
    zz[1]=1
    zz[free]=diag*spsolve(scale@mm@scale,diag*rhs)
    zloc=zz[ids]
    # Evaluate positive integrals directly, avoiding cancellation in z^T K z.
    derivative_energy=0.0
    leakage_energy=0.0
    for BB,CC,WW,tt in cached:
        dv=np.einsum('nki,ni->nk',BB,zloc)
        uv=np.einsum('ni,ni->n',zloc,CC)
        derivative_energy += np.dot(WW*tt**(-a),np.sum(dv*dv,axis=1))
        leakage_energy += np.dot(WW*penalty*tt**(-b),uv*uv)
    scaled=derivative_energy+leakage_energy
    capacity=scaled*eps**((a+1)/s)/A
    residual=np.linalg.norm(mm@zz[free]-rhs)/max(np.linalg.norm(rhs),1.)
    return dict(epsilon=eps,s=s,a=a,b=b,A=A,B=B,cells=cells,
                endpoint=endpoint,scaled_capacity=float(scaled),
                capacity=float(capacity),impedance=float(1/capacity),
                scaled_derivative_energy=float(derivative_energy),
                scaled_leakage_energy=float(leakage_energy),
                relative_linear_residual=float(residual),
                bright_inlet_pressure=float(zz[0]),frame=frame)


def run(output):
    rows=[]
    for s,endpoint in [(2.,6.),(3.,4.)]:
        target=limit_constant(2.,s)
        for eps in [1e-2,1e-3,1e-4,1e-5,1e-6]:
            row=fem_capacity(eps,s=s,cells=5000,endpoint=endpoint)
            row['limiting_constant']=target
            row['relative_error_to_limit']=abs(row['scaled_capacity']/target-1)
            rows.append(row)
        # Separate mesh and truncation checks at a fixed small epsilon.
        checks=[fem_capacity(1e-5,s=s,cells=nn,endpoint=endpoint)
                for nn in [2500,5000,10000]]
        trunc=fem_capacity(1e-5,s=s,cells=10000,endpoint=endpoint*1.25)
        relmesh=abs(checks[-1]['scaled_capacity']/checks[-2]['scaled_capacity']-1)
        reltail=abs(trunc['scaled_capacity']/checks[-1]['scaled_capacity']-1)
        assert relmesh < 3e-4, ('mesh',s,relmesh)
        assert reltail < 3e-4, ('tail',s,reltail)
        for row in checks:
            row['kind']='mesh_check'
            rows.append(row)
        trunc['kind']='truncation_check'
        rows.append(trunc)
        assert rows[-5]['relative_error_to_limit'] < .015
    # Different discretization in the original, fixed laboratory coordinates.
    # Agreement here checks the connection signs and sink rotation independently.
    physical=fem_capacity(1e-3,s=3.,cells=12000,endpoint=4.,frame='physical')
    rotating=fem_capacity(1e-3,s=3.,cells=12000,endpoint=4.,frame='rotating')
    relframe=abs(physical['capacity']/rotating['capacity']-1)
    assert relframe < 3e-6, ('independent physical-frame check',relframe)
    for row in [physical,rotating]:
        row['kind']='independent_frame_check'
        rows.append(row)
    for AA,BB in [(0.5,0.25),(2.,5.),(3.,0.1)]:
        row=fem_capacity(1e-6,s=3.,A=AA,B=BB,cells=6000,endpoint=4.)
        row['kind']='coefficient_check'
        row['limiting_constant']=3.
        row['relative_error_to_limit']=abs(row['scaled_capacity']/3.-1)
        assert row['relative_error_to_limit'] < 5e-4
        rows.append(row)
    result={'model':'two-component rank-one rotating drainage, six-point FEM',
            'status':'passed','rows':rows,
            'independent_frame_relative_difference':relframe,
            'scope':'supercritical s=2,3 only; numerical confirmation is not proof'}
    output=Path(output)
    output.parent.mkdir(parents=True,exist_ok=True)
    output.write_text(json.dumps(result,indent=2)+'\n')
    print(json.dumps({'status':'passed','output':str(output),'rows':len(rows),
          'independent_frame_relative_difference':relframe,
          'last_coefficient_check':rows[-1]},indent=2))
    return result


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