"""Small exact-arithmetic checks, including trajectories with wrap."""
from fractions import Fraction
import numpy as np
from .core import Model, round_ratio, centered, _safe_int64


def run_tests():
    if not __debug__:
        raise RuntimeError("Run verification without Python optimization (-O), which disables assertions")
    for den in range(1,13):
        for num in range(-80,81):
            r=round_ratio(num,den)
            assert r == -round_ratio(-num,den)
            assert abs(Fraction(num,den)-r)<=Fraction(1,2)
    assert round_ratio(1,2)==1 and round_ratio(-1,2)==-1
    rng=np.random.default_rng(20261022)
    model=Model(17,Fraction(8),species=2,modulus=257,mass_phi_sq=Fraction(1,3),
                mass_chi_sq=Fraction(2,5),eta=Fraction(1,4),lambda_phi=Fraction(3,10),
                lambda_chi=Fraction(1,10),g=Fraction(1,10))
    q=rng.integers(-128,129,(2,17)).astype(object)
    p=rng.integers(-128,129,(2,17)).astype(object)
    initialq,initialp=q.copy(),p.copy()
    for _ in range(37):q,p=model.step(q,p,True)
    for _ in range(37):q,p=model.inverse(q,p,True)
    assert np.array_equal(q,initialq) and np.array_equal(p,initialp)
    lifted_q,lifted_p=model.step(initialq,initialp,False)
    modular_q,modular_p=model.step(initialq,initialp,True)
    assert np.array_equal(centered(lifted_q,257),modular_q)
    assert np.array_equal(centered(lifted_p,257),modular_p)
    huge=10**30
    numerator=7*huge**3-3*huge
    assert abs(Fraction(numerator,13)-round_ratio(numerator,13))<=Fraction(1,2)
    oracle_model=Model(7,Fraction(7),species=2,mass_phi_sq=Fraction(1,3),
        mass_chi_sq=Fraction(2,5),eta=Fraction(1,4),lambda_phi=Fraction(3,10),
        lambda_chi=Fraction(1,10),g=Fraction(1,10))
    values=np.array([[huge,-huge,3,0,10*huge,-7,huge+1],
                     [-9,huge+2,-10*huge,2,huge,0,-huge]],dtype=object)
    actual=oracle_model.force(values)
    for a in range(2):
        for x in range(7):
            current=int(values[a,x]);other=int(values[1-a,x])
            spatial=0
            for neighbor in ((x-1)%7,(x+1)%7):
                edge=oracle_model.nu_sq*(int(values[a,neighbor])-current)
                spatial+=round_ratio(edge.numerator,edge.denominator)
            mass=(oracle_model.mass_phi_sq,oracle_model.mass_chi_sq)[a]
            coupling=(oracle_model.lambda_phi,oracle_model.lambda_chi)[a]
            polynomial=oracle_model.tau**2*(mass*current+oracle_model.eta*(current-other)
                +oracle_model.delta**2*(coupling*current**3+oracle_model.g*current*other**2))
            expected=spatial-round_ratio(polynomial.numerator,polynomial.denominator)
            assert actual[a,x]==expected
    rejected_overflow=False
    try:_safe_int64(values)
    except OverflowError:rejected_overflow=True
    assert rejected_overflow
    for num in [-1001,-3,-2,-1,0,1,2,3,1001]:
        assert round_ratio(num,4)+round_ratio(-num,4)==0
    return dict(passed=True,rounding_cases=12*161,modular_roundtrip_steps=37,
                roundtrip_modulus=257,overflow_case_digits=len(str(numerator)),
                independent_fraction_force_components=14,int64_overflow_rejected=True,
                tests=['odd exact rational rounding and ties','37-step wrap-permitting inverse',
                       'one-step reduction/lift equality','large polynomial arithmetic',
                       'independent Fraction force oracle with 31-digit registers',
                       'explicit rejection of overflowing int64 serialization','antisymmetric edge forces'])