"""Replace arbitrary affine patches by the convex envelope of count tangents."""
from datetime import datetime, timezone
from fractions import Fraction
from hashlib import sha256
from importlib.util import spec_from_file_location, module_from_spec
from pathlib import Path
import json

import mpmath as mp
import numpy as np
import sympy as sp

ROOT = Path(__file__).resolve().parent
spec = spec_from_file_location('forward', ROOT/'forward-count-action.py')
forward = module_from_spec(spec)
spec.loader.exec_module(forward)
COUNTS, ERRORS = {}, {}


def check(value, label):
    if not bool(value):
        raise AssertionError(label)
    COUNTS[label] = COUNTS.get(label, 0)+1


def close(actual, expected, label, tolerance=3e-8):
    error = float(np.linalg.norm(np.asarray(actual)-np.asarray(expected))/max(1., np.linalg.norm(expected)))
    ERRORS[label] = max(ERRORS.get(label, 0.), error)
    check(error < tolerance, label)


def high(value):
    return mp.mpf(value.numerator)/value.denominator


def depth_carrier(depth):
    epsq = Fraction(3, 10)/max(forward.count_data(depth, n-1)[1]
                             for _, d, n in forward.radial.ASSIGNMENTS if d == depth)
    candidates = []
    level = 0
    while True:
        count, first, second = forward.count_data(depth, level)
        cq, hhq = epsq*first, Fraction(2*level+depth, 2)
        if cq >= 1:
            break
        # Strict convexity condition for the original f as a function of scalar ratio.
        curvature_numerator = hhq*epsq*second-cq*(1-cq*cq)
        if curvature_numerator > 0:
            c, x, h = high(cq), mp.sqrt(1-high(cq)**2), high(hhq)
            frequency = high(epsq*count)
            candidates.append(dict(level=level, c=c, x=x, h=h,
                                   m=h*x/c, eta=frequency-h/c, omega=frequency,
                                   c_exact=str(cq), count_exact=str(count)))
        level += 1
    return epsq, candidates, level


def main():
    mp.mp.dps = 100
    # An exact common convexity proof covers every depth >=3.
    for depth in [3, 4, 5, 6, 10]:
        hd = sum(Fraction(1, j) for j in range(1, depth+1))
        h2 = sum(Fraction(1, j*j) for j in range(1, depth+1))
        check(Fraction(depth, 2)*(hd*hd-h2)-hd > 0,
              'exact ground count derivatives start the all-shell strict-convexity proof at each maintained depth above two')
    data = {depth: depth_carrier(depth) for depth in forward.radial.DEPTHS}
    cases = []
    rng = np.random.default_rng(202610120823)
    for name, depth, index in forward.radial.ASSIGNMENTS:
        epsq, candidates, endpoint = data[depth]
        matches = [c for c in candidates if c['level'] == index-1]
        check(len(matches) == 1, 'every maintained assignment belongs to the common strictly convex count chart')
        selected = matches[0]
        x, c, h = selected['x'], selected['c'], selected['h']
        values = [candidate['m']*x+candidate['eta'] for candidate in candidates]
        winner = max(range(len(values)), key=values.__getitem__)
        check(candidates[winner]['level'] == index-1,
              'the maximum over every admissible geometric tangent uniquely selects the maintained branch')
        correct = selected['omega']-h*c
        check(abs(values[winner]-correct) < mp.mpf('1e-80'),
              'the selected envelope tangent preserves the complete stationary interaction value')
        gap = min(values[winner]-value for j, value in enumerate(values) if j != winner)
        check(gap > 0, 'the finite geometric envelope has a strict open winner gap at each maintained state')
        lower, upper = mp.mpf(-1), mp.mpf(1)
        for candidate in candidates:
            if candidate is selected:
                continue
            slope = selected['m']-candidate['m']
            crossing = (candidate['eta']-selected['eta'])/slope
            if slope > 0:
                lower = max(lower, crossing)
            else:
                upper = min(upper, crossing)
        check(lower < x < upper,
              'all competing tangent inequalities give a nonempty exact local scalar-ratio winner interval')
        for fraction in [mp.mpf('-.3'), mp.mpf('.2')]:
            ratio = x+fraction*min(x-lower, upper-x)
            trial = [candidate['m']*ratio+candidate['eta'] for candidate in candidates]
            check(max(range(len(trial)), key=trial.__getitem__) == winner,
                  'finite ratio displacements remain inside the exact affine winner chart')
        # Direct arbitrary matrix variation verifies the preferred-time local envelope source.
        generators = forward.radial.gammas(depth+1)
        alpha, beta = generators[:depth], generators[depth]
        rank, eye = len(beta), np.eye(len(beta))
        a, b = mp.sqrt((1+c)/2), mp.sqrt((1-c)/2)
        field = (float(a)*eye+float(b)*beta)/np.sqrt(rank)
        delta = rng.normal(size=field.shape)+1j*rng.normal(size=field.shape)
        delta /= np.linalg.norm(delta)
        # High-precision invariant differences avoid the tiny matter chart widths.
        scalar_variation = mp.mpf(float(2*np.vdot(delta, beta@field).real))
        density_variation = mp.mpf(float(2*np.vdot(delta, field).real))
        step = min(x-lower, upper-x)*mp.mpf('1e-3')
        def invariant_potential(density, scalar):
            return max(candidate['m']*scalar+candidate['eta']*density for candidate in candidates)
        fd = (invariant_potential(1+step*density_variation, x+step*scalar_variation)
              -invariant_potential(1-step*density_variation, x-step*scalar_variation))/(2*step)
        analytic = selected['m']*scalar_variation+selected['eta']*density_variation
        check(abs(fd-analytic)/max(1, abs(analytic)) < mp.mpf('1e-65'),
              'independent variation of the actual envelope gives the complete preferred-time source')
        for spatial_level in [0, index-1, index, index+5, 1000]:
            bare = spatial_level+depth/2
            operator = np.array([[bare, float(selected['m'])], [float(selected['m']), -bare]])-float(h/c)*np.eye(2)
            check(np.array_equal(operator, operator.T),
                  'every retained complete spatial block has an exactly Hermitian generator')
            close(np.linalg.eigvalsh(operator),
                  [-np.hypot(bare, float(selected['m']))-float(h/c), np.hypot(bare, float(selected['m']))-float(h/c)],
                  'independent massive spatial block diagonalization agrees with the full linear spectrum')
        cases.append(dict(particle=name, depth=depth, inferred_index=index,
                          epsilon_exact=str(epsq), candidate_count=len(candidates),
                          first_eligible_level=candidates[0]['level'], first_ineligible_c_one_level=endpoint,
                          canonical_c_exact=selected['c_exact'], count_exact=selected['count_exact'],
                          unique_winner_gap=str(gap), scalar_ratio=str(x),
                          scalar_ratio_winner_interval=[str(lower), str(upper)],
                          scalar_ratio_margin=str(min(x-lower, upper-x)),
                          classification='explicit finite envelope with an open exact quadratic field chart'))
        print(json.dumps(dict(completed=name, depth=depth, eligible_count=len(candidates))), flush=True)
    stamp = datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S.%fZ')
    report = dict(experiment_key='convex-count-quadratic-envelope', created_utc=datetime.now(timezone.utc).isoformat(),
                  sources={'experiments/'+p.name: sha256(p.read_bytes()).hexdigest() for p in
                           [Path(__file__), ROOT/'forward-count-action.py', ROOT/'inverse-current-radial.py',
                            ROOT/'excited-shell-orientation-current.py']},
                  evaluations=sum(COUNTS.values()), conditions=COUNTS, maximum_errors=ERRORS, cases=cases,
                  limits=['the envelope is a specified effective constitutive action derived from geometric count tangents',
                          'the preferred-time realization has exact local quadratic dynamics and its existing Sobolev persistence argument applies',
                          'proper-current and responding-clock choices retain their current response and require separate persistence analysis',
                          'the strict convexity chart excludes the low depth-two tangents; every maintained massive depth-two assignment remains included',
                          'the global evolution at tied charts is unassigned; small-persistence neighborhoods stay inside their unique winner chart',
                          'no new sector-depth preference, localized particle, complete boost inertia or physical contact-source origin follows'])
    output = ROOT/('convex-count-envelope-results-'+stamp+'.json')
    output.write_text(json.dumps(report, indent=2)+'\n')
    print(json.dumps(dict(report=str(output), evaluations=report['evaluations'], maximum_errors=ERRORS)), flush=True)


if __name__ == '__main__':
    main()