"""Full-batch spherical GD on the correlation loss: overlap vs delta = n/d.

Reproduces Figures 1a/1b of arXiv:2602.02431 (paper #26332).
  quad  -> Theorem 3.1 (Claim 1): threshold delta grows with log d
  trunc -> Theorem 3.2 (Claims 2/5): threshold delta is d-independent
"""

from __future__ import annotations

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

import torch

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


def a_star_chunked(X, y, chunk=16384):
    n, d = X.shape
    A = torch.zeros(d, d, device=X.device, dtype=X.dtype)
    for i in range(0, n, chunk):
        Xi = X[i : i + chunk]
        A += Xi.T @ (y[i : i + chunk, None] * Xi)
    return (2.0 / n) * A


def top2(A):
    """Top two eigenvalues + top eigenvector.

    Full eigendecomposition is faster than LOBPCG below d ~ 3000 (LOBPCG is
    kernel-launch bound at small d); above that we fall back to LOBPCG with k=2.
    """
    d = A.shape[0]
    if d <= 3000:
        ev, evec = torch.linalg.eigh(A.double())
        return float(ev[-1]), float(ev[-2]), evec[:, -1]
    try:
        vals, vecs = torch.lobpcg(A.double(), k=2, largest=True, niter=400, tol=1e-10)
        return float(vals[0]), float(vals[1]), vecs[:, 0]
    except Exception:
        ev, evec = torch.linalg.eigh(A.double())
        return float(ev[-1]), float(ev[-2]), evec[:, -1]


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("--delta-min", type=float, default=0.5)
    p.add_argument("--delta-max", type=float, default=11.0)
    p.add_argument("--delta-step", type=float, default=0.5)
    p.add_argument("--seeds", default="32,32,32,16,16,8,8", help="per dim")
    p.add_argument("--M", type=float, default=8.0)
    p.add_argument("--eta", type=float, default=0.1)
    p.add_argument("--T", type=int, default=3000, help="steps for non-quad activations")
    p.add_argument("--spectrum", action="store_true", help="also record lam1/lam2/v1(A*)")
    p.add_argument("--out", required=True)
    args = p.parse_args()

    dev = "cuda" if torch.cuda.is_available() else "cpu"
    dims = [int(v) for v in args.dims.split(",")]
    seeds = [int(v) for v in args.seeds.split(",")]
    assert len(seeds) == len(dims)
    deltas = [
        round(args.delta_min + i * args.delta_step, 4)
        for i in range(int(round((args.delta_max - args.delta_min) / args.delta_step)) + 1)
    ]
    print(f"device={dev} act={args.act} dims={dims} seeds={seeds} deltas={deltas}", flush=True)

    rows = []
    t_start = time.time()
    for d, ns in zip(dims, seeds):
        # quadratic: A* is constant along the flow -> iterate on the d x d matrix (exact,
        # and far cheaper); truncated: A(theta) is time-varying -> matrix-free matvecs.
        use_matrix = args.act == "quad"
        T = sim.log2_steps(d) if use_matrix else args.T
        for delta in deltas:
            n = int(round(delta * d))
            for s in range(ns):
                seed = 1000 * d + 7 * s + int(delta * 2)
                t0 = time.time()
                data = sim.make_data(d, n, seed, args.act, args.M, dev, torch.float32)
                lam1 = lam2 = ov_v1 = float("nan")
                if use_matrix or args.spectrum:
                    A = a_star_chunked(data.X, data.y).double()
                    lam1, lam2, v1 = top2(A)
                    ov_v1 = float((v1 @ data.theta_star.double()) ** 2)
                th0 = sim.rand_sphere(d, 500_000 + seed, dev, torch.float32)
                if use_matrix:
                    dd = sim.Data(data.X, data.y, data.theta_star.double())
                    theta = th0.double()
                    ts = dd.theta_star
                    prev_r = prev_o = None
                    steps = T
                    for t in range(T):
                        Ath = A @ theta
                        ray = theta @ Ath
                        grad = Ath - ray * theta
                        theta = theta + args.eta * grad
                        theta = theta / theta.norm()
                        if (t + 1) % 200 == 0:
                            r, o = float(ray), float((theta @ ts) ** 2)
                            if (
                                prev_r is not None
                                and abs(r - prev_r) <= 1e-13 * abs(r)
                                and abs(o - prev_o) <= 1e-13
                            ):
                                steps = t + 1
                                break
                            prev_r, prev_o = r, o
                    ov = float((theta @ ts) ** 2)
                else:
                    theta, steps, _ = sim.spherical_flow(
                        data, th0, args.act, args.M, eta=args.eta, T=T,
                        tol=0.0, check_every=10 ** 9,
                    )
                    ov = float((theta @ data.theta_star) ** 2)
                rows.append(
                    dict(act=args.act, d=d, delta=delta, n=n, seed=seed, M=args.M,
                         eta=args.eta, T=T, steps=steps, sq_overlap=round(ov, 6),
                         lam1=lam1, lam2=lam2, sq_overlap_v1Astar=ov_v1,
                         secs=round(time.time() - t0, 3))
                )
                del data
                if use_matrix or args.spectrum:
                    del A
            torch.cuda.empty_cache() if dev == "cuda" else None
            m = [r["sq_overlap"] for r in rows if r["d"] == d and r["delta"] == delta]
            print(
                f"[{time.time()-t_start:7.1f}s] d={d:5d} delta={delta:5.1f} "
                f"mean ov2={sum(m)/len(m):.4f}  (n={n}, {ns} seeds)",
                flush=True,
            )

    with open(args.out, "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
        w.writeheader()
        w.writerows(rows)
    print(f"wrote {args.out} ({len(rows)} rows, {time.time()-t_start:.1f}s)")


if __name__ == "__main__":
    main()