"""Reproducible builder checks for T745, independent of the Mellin evaluation.
Run with Sage and numberdb, beside generate.py. Emits per-curve JSON checkpoints.
Uses PARI lfun at 160/220 decimal digits, an exact Weierstrass substitution,
Euler-recurrence reconstruction versus PARI ellan, raw point counting at all
good primes <=97 and every bad prime, and separate Fricke-height checks.
PARI and the generator share local-reduction/prime-trace dependencies; this is
not a claim of complete implementation independence or an independent verdict.
"""
import json,sys,time,platform,hashlib
import numberdb.sage as numberdb
from generate import BoydLValues,SELECTION,NORMALIZATIONS,curve,compute_curve,mellin
from sage.rings.rational_field import QQ
from sage.rings.integer_ring import ZZ
from sage.rings.real_arb import RealBallField
from sage.rings.real_mpfr import RealField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.arith.misc import prime_range
from sage.libs.pari import pari
from sage.env import SAGE_VERSION
from numberdb._write import to_text

def point_trace(E,p):
    a1,a2,a3,a4,a6=map(int,E.a_invariants())
    # Count affine solutions directly, plus the unique point at infinity.
    count=1+sum((y*y+a1*x*y+a3*y-x*x*x-a2*x*x-a4*x-a6)%p==0
                for x in range(p) for y in range(p))
    return p+1-count

def validate_model(E):
    F=E.global_minimal_model();u,r,s,t=E.isomorphism_to(F).tuple()
    R=PolynomialRing(QQ,2,names=('x','y'));x,y=R.gens()
    def eq(C,x,y):
        a1,a2,a3,a4,a6=C.a_invariants()
        return y*y+a1*x*y+a3*y-x*x*x-a2*x*x-a4*x-a6
    assert eq(E,u*u*x+r,u**3*y+s*u*u*x+t)==u**6*eq(F,x,y)
    assert E.discriminant()==u**12*F.discriminant()
    local=[];N=1;root=-1 # archimedean root number
    for d in F.local_data():
        p=int(d.prime().gen());ex=int(d.conductor_valuation());N*=p**ex
        ap=point_trace(F,p);assert ap==int(F.ap(p))
        kind='split multiplicative' if d.has_split_multiplicative_reduction() else ('nonsplit multiplicative' if d.has_multiplicative_reduction() else 'additive')
        expected=1 if kind=='split multiplicative' else (-1 if kind=='nonsplit multiplicative' else 0)
        assert ap==expected
        w=int(F.root_number(p));root*=w
        local.append({'p':p,'conductor_exponent':ex,'kodaira':str(d.kodaira_symbol()),'reduction':kind,'ap':ap,'root':w,'point_trace_checked':True})
    assert N==int(F.conductor()) and root==int(F.root_number())
    good=[]
    for p in prime_range(98):
        p=int(p)
        if N%p:
            v=point_trace(F,p);assert v==int(F.ap(p));good.append([p,v])
    return {'minimal_model':list(map(str,F.a_invariants())),
            'isomorphism_u_r_s_t':list(map(str,(u,r,s,t))),
            'discriminant':str(E.discriminant()),'minimal_discriminant':str(F.discriminant()),
            'local':local,'good_prime_traces':good}

def direct(E,digits,argument,derivative=0):
    bits=numberdb.bits(digits,losing=32);R=RealField(bits)
    return R(pari.lfun(E.__pari__(),argument,derivative,precision=bits))

def fricke_check(a,N,w,y):
    B=RealBallField(400);c=2*B.pi()/B(N).sqrt();M=len(a)-1
    def f(t):
        q=(-c*t).exp();v=B(0)
        for k in range(M,0,-1):v=(v+a[k])*q
        tail=2*q**(M+1)*((M+1)-M*q)/(1-q)**2
        return v.add_error(tail)
    y=B(y);left=f(1/y);right=w*y*y*f(y);res=left-right
    assert res.is_finite() and res.contains_zero()
    assert B(res.rad())<B(10)**-65 and abs(left)>B(10)**-5
    assert not (left+right).contains_zero()
    return {'y':str(y),'residual':str(res),'wrong_sign_rejected':True}

def run():
    start=time.time();rows=[];checkpoint=[]
    R=PolynomialRing(QQ,'n');n=R.gen();a=n-24;b=-16*(n-9)
    assert 16*b*b*(a*a-4*b)==2**12*n*(n+16)*(n-9)**2
    assert all(16*(-16*(j-9))**2*((j-24)**2+64*(j-9))==0 for j in [0,9])
    # External low-precision control from the Sage L-series documentation.
    from sage.schemes.elliptic_curves.constructor import EllipticCurve
    E37=EllipticCurve(QQ,[0,0,1,-1,0]);control=mellin(E37,100)[0]
    assert abs(RealField(100)(control.mid())-RealField(100)('0.381575408260711'))<QQ(1)/10**15
    assert control.lower() <= direct(E37,160,2) <= control.upper()
    print('KNOWN_CONTROL '+json.dumps({'curve':[0,0,1,-1,0],'L2':str(control),'passed':True}),flush=True)
    for n in SELECTION:
        t=time.time();E=curve(n);L,D,info,a=compute_curve(n,100)
        metadata=validate_model(E);F=E.global_minimal_model()
        exact_pari=list(map(int,pari.ellan(F.__pari__(),len(a)-1)))
        assert a[1:]==exact_pari
        numeric={}
        for arg,der,label,ball in [(2,0,'L2',L),(0,1,'D0',D)]:
            low=direct(E,160,arg,der);high=direct(E,220,arg,der)
            assert abs(high-low)<RealField(800)(10)**-145
            assert ball.lower() <= high <= ball.upper()
            numeric[label]={'at_160':str(low),'at_220':str(high),'inside_mellin_ball':True,
                            'absolute_midpoint_difference':str(abs(high-RealField(800)(ball.mid())))}
        B=L.parent();assert (D-info['w']*info['N']*L/(4*B.pi()**2)).contains_zero()
        heights=[fricke_check(a,info['N'],info['w'],QQ(5)/4),fricke_check(a,info['N'],info['w'],QQ(3)/2)]
        for mode,v in zip(NORMALIZATIONS,[L,D]):
            text=to_text(v,100);rows.append({'params':{'n':str(n),'normalization':mode},'number':text,
                'param-latex':'$L_n(2)$' if mode=='at-two' else "$L_n'(0)$"})
        item={'n':n,**info,**metadata,'pari':numeric,'fricke':heights,'elapsed_seconds':time.time()-t,'euler_coefficients_count':len(a)-1,'euler_coefficients_sha256':hashlib.sha256(json.dumps(a).encode()).hexdigest()}
        checkpoint.append(item);print('CURVE_RESULT '+json.dumps(item),flush=True)
    assert int(curve(16).conductor())==224
    # The wrong k=n interpretation at n=4 gives E_16, distinguishable from E_4.
    assert not compute_curve(4,100)[0].overlaps(compute_curve(16,100)[0])
    controls={}
    L=compute_curve(1,100)[0]
    for name,opts in [('wrong_sign',{'wrong_sign':True}),('omitted_bad_factor',{'omit_prime':17}),('spurious_2pi',{'c_multiplier':2})]:
        bad=mellin(curve(1),100,**opts)[0];assert not bad.overlaps(L)
        controls[name]={'bad_L2':str(bad),'rejected':True}
    controls['wrong_n_equals_k']={'expected_n':4,'wrong_n':16,'rejected':True}
    # Exercise the actual repository deterministic checks, against cached real balls.
    import dry_run
    status=dry_run.main([__import__('generate').__file__]);assert status==0
    summary={'table':'T745','checked_entries':70,'total_entries':70,'failures':[],
             'known_answer_control':True,'negative_control_rejected':True,'controls':controls,
             'versions':{'sage':SAGE_VERSION,'pari':str(pari.version()),'python':platform.python_version(),'numberdb':numberdb.__version__},
             'skill_manifest':'../20261118T044553Z-build-skills/manifest.json',
             'skill_bundle_sha256':'d6e85d49873fac5bc748d068b0288cf242b0f9aebf3a9a0fff70295019227420',
             'elapsed_seconds':time.time()-start,'curves':checkpoint}
    print('ROWS_JSON '+json.dumps(rows),flush=True)
    print('BUILD_RESULTS_JSON '+json.dumps(summary),flush=True)

if __name__=='__main__':run()
