"""Build-stage mathematical checks, not an independent critic's verdict.
Run beside generate.py with: sage -python check_values.py.
Estermann double sums use roots of unity, no cotangents. Both methods share
Arb, exact rational inputs and the sourced normalization. All default arguments
are checked; known answers and deliberately wrong/broad controls test this code.
For --stored, configure a NumberDB API key and read the current table first.
"""
import sys,json,math,argparse,os
from fractions import Fraction
from functools import lru_cache
import numberdb.sage as numberdb
from numberdb._write import to_text
from sage.rings.rational_field import QQ
from sage.rings.real_arb import RealBallField
from sage.rings.complex_arb import ComplexBallField
import generate

R=RealBallField(550);C=ComplexBallField(550);pi=R.pi()

def rational(text):
    q=Fraction(text);return QQ(q.numerator)/QQ(q.denominator)

def decimal_bounds(text):
    q=Fraction(text);mant,_,exponent=text.lower().partition('e');places=len(mant.split('.')[1]) if '.' in mant else 0
    ulp=QQ(10)**((int(exponent) if exponent else 0)-places)
    return R(rational(text)-ulp).lower(),R(rational(text)+ulp).upper()

def inside(v,text):
    if not v.is_finite() or v.accuracy()<350:return False
    lo,hi=decimal_bounds(text)
    return bool(v.lower()>lo and v.upper()<hi)

@lru_cache(None)
def estermann_c(h,k):
    h=h%k if k>1 else 0
    roots=[C(0,2*pi*QQ(r)/QQ(k)).exp() for r in range(k)]
    D=sum((roots[(h*a*b)%k] * (QQ(1)/2-QQ(a)/k) * (QQ(1)/2-QQ(b)/k)
           for a in range(1,k+1) for b in range(1,k+1)),C(0))
    assert (D.real().is_finite() and D.imag().is_finite()) and (D.real()-QQ(1)/4).contains_zero()
    return 2*D.imag()

def independent(x):
    x=QQ(x);h=int(x.numerator());k=int(x.denominator())
    return R(x)*estermann_c(h,k)+estermann_c(k,h)-1/(pi*k)

def controls():
    controls={'1':-1/pi,'1/2':-1/(2*pi),'1/3':1/(9*R(3).sqrt())-1/(3*pi),'1/4':QQ(1)/8-1/(4*pi)}
    assert all((independent(x)-v).contains_zero() and independent(x).is_finite() for x,v in controls.items())
    wrong_sign=-QQ(1)/8-1/(4*pi)
    wrong_den=QQ(1)/8-1/pi
    wrong_scale=controls['1']/4
    narrow=to_text(generate.evaluate({'x':'1/4'}),100)
    negative={'cotangent_sign':not inside(wrong_sign,narrow),'reduced_denominator':not inside(wrong_den,narrow),'period_scale':not inside(wrong_scale,to_text(generate.evaluate({'x':'1'}),100)), 'NaN':not inside(R('nan'),narrow),'broad_ball':not inside(R(0).add_error(100),narrow)}
    assert all(negative.values())
    return {x:str(v) for x,v in controls.items()},negative

def main():
    parser=argparse.ArgumentParser();parser.add_argument('--stored',action='store_true');args=parser.parse_args()
    if os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':numberdb.configure(api_key=sys.stdin.read().strip())
    known,negative=controls();selection=list(generate.selection());expected=[p['x'] for p in selection]
    # Enumeration independently by rational reduction of the entire box.
    distinct={QQ(h)/QQ(k) for h in range(1,21) for k in range(1,21)}
    assert distinct=={QQ(x) for x in expected} and len(expected)==len(set(expected))==255
    if args.stored or os.environ.get('CHECK_STORED')=='1':
        doc=numberdb.table(generate.BettinConreyValues.table)
        records=doc['Numbers']
        # Legacy numberdb clients may expose one-parameter nested scalar entries.
        if isinstance(records,dict):
            records=[{'params':{'x':str(x)},'number':(v['number'] if isinstance(v,dict) else v)} for x,v in records.items()]
        assert [str(r['params']['x']) for r in records]==expected
        text={str(r['params']['x']):r['number'] for r in records}
    else:text={p['x']:to_text(generate.evaluate(p),100) for p in selection}
    rows=[];vals={};failures=[]
    for x in expected:
        v=independent(x);prod=generate.evaluate({'x':x});vals[QQ(x)]=v
        ok=inside(v,text[x]) and inside(prod,text[x]) and (v-R(prod)).contains_zero()
        if not ok:failures.append(x)
        rows.append({'x':x,'number':text[x],'independent_ball':str(v),'accuracy_bits':int(v.accuracy()),'inside_stored_interval':ok,'production_type':type(prod).__name__})
    reciprocal=0;triples=[]
    for x,v in vals.items():
        assert (v-R(x)*vals[1/x]).contains_zero();reciprocal+=1
        if x+1 in vals and x/(x+1) in vals:
            assert (v-R(x/(x+1))*vals[x+1]-vals[x/(x+1)]).contains_zero();triples.append(str(x))
    # Bounded research experiment; finite observations never become a theorem.
    experiment=[]
    for x,v in vals.items():
        if x<=1:
            residual=pi*v+(2*pi*R(x)).log()-R.euler_constant();bound=pi*pi/36*R(x)**2
            experiment.append({'x':str(x),'split':'development' if x.denominator()<=12 else 'withheld','R':str(residual),'R_over_leading':str(residual/bound),'positive':bool(residual>0),'below_leading':bool(residual<=bound),'sign_g':1 if v>0 else -1})
    output={'stage':'build','skill_manifest':'../20261117T072043Z-build-skills/manifest.json','checked_entries':len(rows),'total_entries':255,'failures':failures,'known_answer_control':True,'negative_control_rejected':all(negative.values()),'known_answers':known,'negative_controls':negative,'independent_min_accuracy_bits':min(r['accuracy_bits'] for r in rows),'reciprocal_checks':reciprocal,'three_term_arguments':triples,'rows':rows,'proof_facing_experiment':experiment}
    assert not failures
    print('CHECK_JSON '+json.dumps(output))
    print('CHECK_SUMMARY',len(rows),'minimum accuracy',output['independent_min_accuracy_bits'],'reciprocal',reciprocal,'three term',len(triples),'inequality counterexamples',sum(not(e['positive'] and e['below_leading']) for e in experiment),flush=True)
if __name__=='__main__':main()
