import json,sys,time,hashlib,itertools,math,platform,importlib.metadata
from pathlib import Path
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
import generate
R=RealBallField(numberdb.bits(100,losing=192))

def endpoints(v):
    return [str(x.exact_rational()) for x in v.endpoints()]

def emit(kind,data):
    print(json.dumps({'kind':kind,**data}),flush=True)

cache={}
cp=Path(__file__).with_name('moments-checkpoint.json')
if cp.exists():
    saved=json.loads(cp.read_text())
    assert saved['generator_sha256']==hashlib.sha256(Path(generate.__file__).read_bytes()).hexdigest()
    for rec in saved['moments']:
        cache[tuple(rec[k] for k in ['a','b','r'])]=(R(QQ(rec['endpoints'][0])).union(R(QQ(rec['endpoints'][1]))),rec)
original=generate.moment

def moment(a,b,r,digits=100):
    key=(a,b,r)
    if key not in cache:
        st=time.time();v,e=original(a,b,r,digits)
        e.update(endpoints=endpoints(v),seconds=time.time()-st)
        cache[key]=(v,e);emit('moment',e)
    return cache[key]
generate.moment=moment
emit('versions',{'python':sys.version,'numberdb':importlib.metadata.version('numberdb'),
                 'mpmath':importlib.metadata.version('mpmath'),
                 'sage':__import__('sage.version',fromlist=['version']).version,
                 'generator_sha256':hashlib.sha256(Path(generate.__file__).read_bytes()).hexdigest()})
for a,b,r,target in [(0,1,1,R(1)),(0,2,1,R(QQ(1)/2))]:
    v,e=moment(a,b,r)
    assert target in v
    emit('known-control',{'a':a,'b':b,'r':r,'target':str(target),'passed':True})
for params in generate.OddBesselPeriods().enumerate():
    n=params['n'];st=time.time();v=generate.determinant(n);d=generate.dimension(n)
    # Leibniz absolute sum quantifies cancellation independently of elimination.
    rows=[[moment(2*i-1,n+1-2*i,2*j-1)[0] for j in range(1,d+1)] for i in range(1,d+1)]
    absolute=R(0)
    for p in itertools.permutations(range(d)):
        product=R(1)
        for i,j in enumerate(p):product*=rows[i][j]
        absolute+=abs(product)
    text=to_text(v,digits=100)
    emit('determinant',{'n':n,'dimension':d,'number':text,'endpoints':endpoints(v),
                        'accuracy_bits':int(v.accuracy()),'cancellation_digits_upper':str((absolute/v).log()/R(10).log()),
                        'seconds':time.time()-st,'native_type':type(v).__name__})
# Exercise existing deterministic checks using already-computed certified values.
import importlib.util
spec=importlib.util.spec_from_file_location('dry_run',str(Path(__file__).with_name('dry_run.py')))
m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m)
m.load=lambda path:generate.OddBesselPeriods()
assert m.main([str(Path(generate.__file__))])==0
emit('complete',{'moments':len(cache),'entries':13})
