"""Scaled GPU proxy for the paper's monochromatic-subgraph experiment.

This is deliberately a small independent implementation: 5x5 grids with
random edge deletions, node colours, a transformer regressor, and optional
spectral WIRE rotations in every self-attention layer.  It is not claimed to
reproduce the paper's full 10k/1k, 250-epoch run.
"""

from __future__ import annotations

import json
import os
import random
import time
from pathlib import Path

import numpy as np
import torch
from torch import nn


N = 25
GRID_EDGES = [(r * 5 + c, r * 5 + c + 1) for r in range(5) for c in range(4)]
GRID_EDGES += [(r * 5 + c, (r + 1) * 5 + c) for r in range(4) for c in range(5)]


def make_dataset(count: int, seed: int, ape_dim: int = 3) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
    rng = np.random.default_rng(seed)
    laplacians = np.zeros((count, N, N), dtype=np.float32)
    colours = rng.integers(0, 2, size=(count, N), dtype=np.int64)
    labels = np.zeros(count, dtype=np.float32)
    for b in range(count):
        edges = [e for e in GRID_EDGES if rng.random() > rng.uniform(0.05, 0.45)]
        # Keep the grid backbone connected enough for meaningful low modes.
        a = np.zeros((N, N), dtype=np.float32)
        for i, j in edges:
            a[i, j] = a[j, i] = 1.0
        laplacians[b] = np.diag(a.sum(axis=1)) - a
        seen = np.zeros(N, dtype=bool)
        best = 0
        for start in range(N):
            if seen[start]:
                continue
            colour = colours[b, start]
            stack = [start]
            seen[start] = True
            size = 0
            while stack:
                node = stack.pop()
                size += 1
                for nxt in np.flatnonzero(a[node]):
                    if not seen[nxt] and colours[b, nxt] == colour:
                        seen[nxt] = True
                        stack.append(int(nxt))
            best = max(best, size)
        labels[b] = best / N
    _, vecs = np.linalg.eigh(laplacians)
    # Include low-frequency spectral coordinates as APE inputs for both arms;
    # WIRE uses the same coordinates to generate rotations.
    spectral = vecs[:, :, : max(ape_dim, 3)]
    colour_onehot = np.eye(2, dtype=np.float32)[colours]
    x = np.concatenate([colour_onehot, spectral], axis=-1).astype(np.float32)
    return torch.from_numpy(x), torch.from_numpy(labels), torch.from_numpy(spectral[:, :, :ape_dim].astype(np.float32))


class WireAttention(nn.Module):
    def __init__(self, d_model: int, heads: int, wire_dim: int):
        super().__init__()
        assert d_model % heads == 0 and (d_model // heads) % 2 == 0
        self.heads = heads
        self.head_dim = d_model // heads
        self.wire_dim = wire_dim
        self.qkv = nn.Linear(d_model, 3 * d_model)
        self.out = nn.Linear(d_model, d_model)
        self.freq = nn.Parameter(torch.randn(heads, self.head_dim // 2, max(wire_dim, 1)) * 0.15)

    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
        batch, nodes, d_model = x.shape
        q, k, v = self.qkv(x).chunk(3, dim=-1)
        q = q.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
        k = k.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
        v = v.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
        if self.wire_dim:
            angles = torch.einsum("bnm,hdm->bhnd", spectral[..., : self.wire_dim], self.freq[..., : self.wire_dim])
            def rotate(z: torch.Tensor) -> torch.Tensor:
                z = z.view(batch, self.heads, nodes, self.head_dim // 2, 2)
                c, s = angles.cos(), angles.sin()
                x0, x1 = z[..., 0], z[..., 1]
                return torch.stack([c * x0 - s * x1, s * x0 + c * x1], dim=-1).flatten(-2)
            q, k = rotate(q), rotate(k)
        weights = torch.softmax(q @ k.transpose(-1, -2) / self.head_dim**0.5, dim=-1)
        return self.out((weights @ v).transpose(1, 2).reshape(batch, nodes, d_model))


class Block(nn.Module):
    def __init__(self, d_model: int, heads: int, wire_dim: int):
        super().__init__()
        self.norm1 = nn.LayerNorm(d_model)
        self.attn = WireAttention(d_model, heads, wire_dim)
        self.norm2 = nn.LayerNorm(d_model)
        self.ff = nn.Sequential(nn.Linear(d_model, 2 * d_model), nn.GELU(), nn.Linear(2 * d_model, d_model))

    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
        x = x + self.attn(self.norm1(x), spectral)
        return x + self.ff(self.norm2(x))


class GraphTransformer(nn.Module):
    def __init__(self, input_dim: int, wire_dim: int):
        super().__init__()
        self.embed = nn.Linear(input_dim, 32)
        self.blocks = nn.ModuleList([Block(32, 4, wire_dim) for _ in range(2)])
        self.head = nn.Sequential(nn.LayerNorm(32), nn.Linear(32, 1))

    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
        h = self.embed(x)
        for block in self.blocks:
            h = block(h, spectral)
        return self.head(h.mean(dim=1)).squeeze(-1)


def train_arm(train: tuple[torch.Tensor, ...], test: tuple[torch.Tensor, ...], wire_dim: int, seed: int, device: torch.device) -> float:
    torch.manual_seed(seed)
    model = GraphTransformer(train[0].shape[-1], wire_dim).to(device)
    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-4)
    x, y, s = [v.to(device) for v in train]
    xt, yt, st = [v.to(device) for v in test]
    for _ in range(80):
        order = torch.randperm(len(x), device=device)
        for idx in order.split(64):
            pred = model(x[idx], s[idx])
            loss = ((pred - y[idx]) ** 2).mean()
            optimizer.zero_grad(set_to_none=True)
            loss.backward()
            optimizer.step()
    model.eval()
    with torch.no_grad():
        rmse = float(torch.sqrt(((model(xt, st) - yt) ** 2).mean()).cpu())
    return rmse


def main() -> None:
    start = time.time()
    random.seed(18382)
    np.random.seed(18382)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    train = make_dataset(1600, 18382)
    test = make_dataset(400, 19382)
    results = {
        "paper": "https://huggingface.co/papers/2509.22259",
        "job_proxy": "monochromatic-subgraph; 1,600/400 graphs vs paper 10,000/1,000; 80 vs 250 epochs; 2-layer 32d model vs 4-layer 32d; 2 seeds",
        "device": str(device),
        "baseline_rmse": [],
        "wire_rmse": [],
    }
    for seed in (0, 1):
        results["baseline_rmse"].append(train_arm(train, test, 0, seed, device))
        results["wire_rmse"].append(train_arm(train, test, 3, seed, device))
    results["baseline_mean"] = float(np.mean(results["baseline_rmse"]))
    results["wire_mean"] = float(np.mean(results["wire_rmse"]))
    results["relative_rmse_change_pct"] = 100 * (results["wire_mean"] / results["baseline_mean"] - 1)
    results["wall_seconds"] = time.time() - start
    out_dir = Path("/data") if Path("/data").exists() else Path(".")
    out_dir.mkdir(parents=True, exist_ok=True)
    (out_dir / "synthetic_results.json").write_text(json.dumps(results, indent=2) + "\n")
    print(json.dumps(results, indent=2))


if __name__ == "__main__":
    main()