"""Full-batch Euclidean GD on the squared loss from small initialisation.

Reproduces Figures 2a/2b/2c of arXiv:2602.02431 and audits Theorem 4.1 (Claim 3)
and the two-phase trajectory decomposition of Section 4 (Claim 4).

    sigma(z) = min(z^2, M),  M = 8,  eta = 0.1 / M^2,  delta = n/d = 10,
    theta_0 ~ Unif(r0 * S^{d-1}),  r0 in {d^-2 (paper figures), d^-15 (Theorem 4.1)}.

All runs are float64 so that r0 = d^-15 (down to ~1e-54) does not underflow.
"""

from __future__ import annotations

import argparse
import csv
import json
import math
import os
import sys
import time

import torch

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import sim


def main():
    p = argparse.ArgumentParser()
    p.add_argument("--act", default="trunc", choices=["quad", "trunc", "smooth"])
    p.add_argument("--dims", default="64,128,256,512,1024,2048,4096")
    p.add_argument("--seeds", default="8", help="int, or one value per dim")
    p.add_argument("--M", type=float, default=8.0)
    p.add_argument("--delta", type=float, default=10.0)
    p.add_argument("--eta-c", type=float, default=0.1, help="eta = c / M^2")
    p.add_argument("--r0-exp", type=float, default=2.0, help="r0 = d^-exp")
    p.add_argument("--T", type=int, default=6000)
    p.add_argument("--record-every", type=int, default=5)
    p.add_argument("--stop-err", type=float, default=1e-13)
    p.add_argument("--out-prefix", required=True)
    args = p.parse_args()

    dev = "cuda" if torch.cuda.is_available() else "cpu"
    dims = [int(v) for v in args.dims.split(",")]
    seed_list = [int(v) for v in args.seeds.split(",")]
    if len(seed_list) == 1:
        seed_list = seed_list * len(dims)
    assert len(seed_list) == len(dims)
    eta = args.eta_c / (args.M ** 2)
    traj_rows, summ_rows = [], []
    t_start = time.time()
    for d, nseeds in zip(dims, seed_list):
        n = int(round(args.delta * d))
        r0 = float(d) ** (-args.r0_exp)
        for s in range(nseeds):
            seed = 90000 + 137 * d + s
            t0 = time.time()
            data = sim.make_data(d, n, seed, args.act, args.M, dev, torch.float64)
            th0 = sim.rand_sphere(d, 800_000 + seed, dev, torch.float64) * r0
            rec = sim.squared_gd(
                data, th0, args.act, args.M, eta, args.T,
                record_every=args.record_every, stop_err=args.stop_err,
            )
            for i in range(len(rec["step"])):
                traj_rows.append(dict(
                    act=args.act, d=d, delta=args.delta, M=args.M, eta=eta,
                    r0_exp=args.r0_exp, seed=seed, step=rec["step"][i],
                    sq_overlap=rec["sq_overlap"][i], norm=rec["norm"][i],
                    dist2=rec["dist2"][i], loss=rec["loss"][i]))
            summ_rows.append(dict(
                act=args.act, d=d, n=n, delta=args.delta, M=args.M, eta=eta,
                r0_exp=args.r0_exp, r0=r0, seed=seed,
                steps_run=rec["step"][-1], final_sq_overlap=rec["sq_overlap"][-1],
                final_norm=rec["norm"][-1], final_dist2=rec["dist2"][-1],
                final_loss=rec["loss"][-1], secs=round(time.time() - t0, 2)))
            del data
            torch.cuda.empty_cache() if dev == "cuda" else None
        fin = [r["final_dist2"] for r in summ_rows if r["d"] == d]
        stp = [r["steps_run"] for r in summ_rows if r["d"] == d]
        print(f"[{time.time()-t_start:7.1f}s] d={d:5d} n={n} r0={r0:.3e} "
              f"median dist2={sorted(fin)[len(fin)//2]:.3e} median steps={sorted(stp)[len(stp)//2]}",
              flush=True)

    with open(args.out_prefix + "_traj.csv", "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=list(traj_rows[0].keys()))
        w.writeheader()
        w.writerows(traj_rows)
    with open(args.out_prefix + "_summary.csv", "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=list(summ_rows[0].keys()))
        w.writeheader()
        w.writerows(summ_rows)
    print(f"wrote {args.out_prefix}_{{traj,summary}}.csv "
          f"({len(traj_rows)} traj rows, {time.time()-t_start:.1f}s)")


if __name__ == "__main__":
    main()