#!/usr/bin/env python3
"""Generate exact tables and explicitly labeled model illustrations.

Run from any working directory. No network access is required. Figures are not
experimental physical data; CSV/JSON values follow the manuscript's formulas.
"""
from __future__ import annotations
import csv
import json
import math
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'src'))
import numpy as np
import sympy as sp
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from noulith import TwistedAlgebra
from noulith.protocols import root_profile
from noulith.geometry import line_arrangement_generators


def write_csv(name: str, rows: list[dict]) -> None:
    with (ROOT / 'data' / name).open('w', newline='', encoding='utf-8') as file:
        writer = csv.DictWriter(file, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)


def save(fig, name: str) -> None:
    fig.tight_layout()
    fig.savefig(ROOT / 'figures' / f'{name}.pdf', bbox_inches='tight')
    fig.savefig(ROOT / 'figures' / f'{name}.png', dpi=180, bbox_inches='tight')
    plt.close(fig)


def main() -> None:
    (ROOT / 'data').mkdir(exist_ok=True)
    (ROOT / 'figures').mkdir(exist_ok=True)
    gap_rows = []
    for p in range(2, 17):
        m = 2
        while math.comb(m, 2) < p + 1:
            m += 1
        gap_rows.append(dict(p=p, channels=m, state_dimension=2**m,
            length_J=p*p, length_K=p*(p+1)//2,
            length_gap=p*(p-1)//2, minimal_protocols_J=2**m+1,
            minimal_protocols_K=2**m+p, protocol_gap=p-1))
    write_csv('arc_blind_family.csv', gap_rows)
    fig, ax = plt.subplots(figsize=(6.6, 3.9))
    ax.plot([r['p'] for r in gap_rows], [r['length_J'] for r in gap_rows], 'o-', label=r'$\dim R/(a^p,b^p)=p^2$')
    ax.plot([r['p'] for r in gap_rows], [r['length_K'] for r in gap_rows], 's-', label=r'$\dim R/(a,b)^p=p(p+1)/2$')
    ax.set(xlabel='Power p', ylabel='Local algebra length', title='Equal arc orders, different analytic defects')
    ax.legend(); ax.grid(True, alpha=.25)
    save(fig, 'arc_blind_lengths')

    root_rows = []
    for ell in range(2, 8):
        for d in range(0, 25):
            for r in range(1, 9):
                root_rows.append(dict(root_order=ell, degree=d, blocks=r,
                    exponent=int(root_profile(d, r, ell))))
    write_csv('root_budget_profiles.csv', root_rows)
    fig, ax = plt.subplots(figsize=(6.6, 3.9))
    degrees = list(range(25))
    for r in (1, 2, 3, 5):
        ax.step(degrees, [root_profile(d,r,3) for d in degrees], where='mid', label=f'{r} block(s)')
    ax.set(xlabel='Complement degree d', ylabel='Vanishing exponent', title='Third-root resonance: block budget versus order')
    ax.set_xticks(range(0,25,3)); ax.legend(); ax.grid(True, alpha=.25)
    save(fig, 'root_budget_profiles')

    jet_rows=[]
    m, ell = 12, 3
    grid=[]
    for k in range(5):
        gridrow=[]
        for r in range(1,7):
            threshold=min(m, r*(ell-1)+ell*k)
            rank=sum(math.comb(m,d) for d in range(threshold+1))
            jet_rows.append(dict(channels=m, root_order=ell, blocks=r, jet_order=k, rank=rank, dimension=2**m))
            gridrow.append(rank/(2**m))
        grid.append(gridrow)
    for r in range(1,5):
        for k in range(3):
            rank=sum(math.comb(8,d) for d in range(min(8,2*r+3*k)+1))
            jet_rows.append(dict(channels=8,root_order=3,blocks=r,jet_order=k,rank=rank,dimension=256))
    write_csv('root_jet_visibility.csv',jet_rows)
    fig, ax = plt.subplots(figsize=(6.6, 3.9))
    im=ax.imshow(np.array(grid),origin='lower',aspect='auto',extent=(.5,6.5,-.5,4.5),vmin=0,vmax=1)
    ax.set(xlabel='Block budget r',ylabel='Parameter jet order k',title='Visible constant-state fraction: m = 12, root order 3')
    fig.colorbar(im,ax=ax,label='Visible fraction')
    save(fig,'jet_visibility')

    hilbert_rows=[]
    for m in range(4,11):
        for degree in range(8):
            value = 1 if degree==0 else (m-1 if degree==1 else m)
            hilbert_rows.append(dict(channels=m,degree=degree,hilbert_function=value))
    write_csv('branch_hilbert_functions.csv',hilbert_rows)
    fig,ax=plt.subplots(figsize=(6.6,3.9))
    for m in (4,6,8):
        ax.plot(range(8), [1,m-1]+[m]*6,'o-',label=f'{m} branches')
    ax.set(xlabel='Degree',ylabel='Graded dimension',title='Exact second-deficit branch-ring Hilbert functions')
    ax.set_xticks(range(8)); ax.legend(); ax.grid(True,alpha=.25)
    save(fig,'branch_hilbert')

    # Geometric illustration of the exact normal form in three log-coordinates.
    fig=plt.figure(figsize=(6.3,4.5))
    ax=fig.add_subplot(projection='3d')
    ts=np.linspace(-1,1,101)
    for direction,label in (([1,0,0],'channel 2 outlier'),([0,1,0],'channel 3 outlier'),
                            ([0,0,1],'channel 4 outlier'),([1,1,1],'channel 1 outlier')):
        a=np.outer(ts,np.array(direction,dtype=float))
        ax.plot(a[:,0],a[:,1],a[:,2],label=label)
    ax.set(xlabel=r'$z_2$',ylabel=r'$z_3$',zlabel=r'$z_4$',title='Four-channel resonance germ in logarithmic coordinates')
    ax.legend(loc='upper left',fontsize=7)
    save(fig,'four_branch_geometry')

    # Numerical illustration only; exact valuation claims have independent tests.
    import mpmath as mp
    mp.mp.dps=65
    zeta=mp.exp(2*mp.pi*1j/3)
    def qfac(d,q):
        return mp.fprod(mp.fsum(q**j for j in range(k)) for k in range(1,d+1))
    detuning_rows=[]
    figureseries=[]
    for composition in ((6,),(2,4),(2,2,2)):
        values=[]
        for exponent in np.linspace(-5,-1,41):
            t=mp.mpf(str(10**float(exponent)))
            value=abs(mp.fprod(qfac(d,zeta*(1+t)) for d in composition))
            values.append(float(value))
            detuning_rows.append(dict(composition='+'.join(map(str,composition)),t=float(t),amplitude=float(value),
                predicted_order=sum(d//3 for d in composition)))
        figureseries.append((composition, values))
    write_csv('detuning_amplitudes.csv',detuning_rows)
    fig,ax=plt.subplots(figsize=(6.6,3.9))
    ts=np.logspace(-5,-1,41)
    for composition,values in figureseries:
        ax.loglog(ts,values,label=' + '.join(map(str,composition))+f' ; order {sum(d//3 for d in composition)}')
    ax.set(xlabel='Detuning t',ylabel='Normalized isolated coefficient magnitude',title='Depth six: the cost of restricting block changes')
    ax.legend(); ax.grid(True,which='both',alpha=.25)
    save(fig,'detuning_amplitudes')

    A,B,C=sp.symbols('A B C')
    algebra=TwistedAlgebra(3,{(0,1):-1+A,(0,2):-1+B,(1,2):-1+C})
    triple=sp.expand(algebra.shuffle_table()[-1])
    z=sp.symbols('z2:5')
    certificate=dict(triple_shuffle=str(triple),
        expected_triple='A*B*C - A*C + A - B + C',
        four_branch_ideal=[str(x) for x in line_arrangement_generators(z)],
        definitions='Illustrations of proved abstract-model formulas; not physical experiments.',
        exactness={'tables':'integer arithmetic except detuning_amplitudes.csv',
            'detuning':'65-digit mpmath evaluation exported as binary64 decimal values'})
    assert sp.expand(triple-(A*B*C-A*C+A-B+C))==0
    (ROOT/'data'/'symbolic_certificates.json').write_text(json.dumps(certificate,indent=2)+'\n')

    # Exact full-state ranks, distinct from the scalar branch curve.
    strata=[]
    for m in range(4,13):
        n=2**m
        for stratum,loss in [('outside_stars',0),('generic_single_star',1),
            ('nonzero_outlier_branch',2),('nonzero_two_star_intersection',2),('exterior_origin',m+1)]:
            strata.append(dict(channels=m,blocks=m-2,stratum=stratum,rank=n-loss,state_dimension=n))
    write_csv('full_state_rank_strata.csv',strata)

    # Editable TeX tables are generated from exact data, not handwritten values.
    arc=[r'\begin{center}',r'\begin{tabular}{rrrrrrr}',r'\toprule',
         r'$p$ & $m$ & $2^m$ & $\dim R/J_p$ & $\dim R/K_p$ & $N(J_p)$ & $N(K_p)$\\',r'\midrule']
    for row in gap_rows[:7]:
        keys=['p','channels','state_dimension','length_J','length_K','minimal_protocols_J','minimal_protocols_K']
        arc.append(' & '.join(str(row[key]) for key in keys)+r'\\')
    arc += [r'\bottomrule',r'\end{tabular}',r'\end{center}']
    (ROOT/'manuscript'/'generated_arc_table.tex').write_text('\n'.join(arc)+'\n')
    jet=[r'\begin{center}',r'\begin{tabular}{rrrr}',r'\toprule',
         r'Blocks $r$ & Jet $k=0$ & Jet $k=1$ & Jet $k=2$\\',r'\midrule']
    for r in range(1,5):
        counts=[next(row['rank'] for row in jet_rows if row['channels']==8 and row['blocks']==r and row['jet_order']==k) for k in range(3)]
        jet.append(' & '.join(map(str,[r]+counts))+r'\\')
    jet += [r'\bottomrule',r'\end{tabular}',r'\end{center}']
    (ROOT/'manuscript'/'generated_jet_table.tex').write_text('\n'.join(jet)+'\n')

    print('Generated six figures, six CSV tables, two TeX tables, and symbolic_certificates.json.')

if __name__=='__main__':
    main()