"""ST-GFN and baseline GFlowNet models.

Reimplemented from the paper text (Sec. 3, Def. 5, Alg. 1, App. C) since no
author code accompanies the submission.

IMPORTANT INTERPRETATION NOTE (documented in the logbook):
The paper's Unified Spectral Loss (Definition 5) contains only
    ||P_F_hat(s,t) - P_B_hat(s,t)||^2  +  lambda * E_a[ ||V_hat(s,a)||_H^2 ]
i.e. it has NO reward/terminal term. Taken literally that objective is
reward-independent and cannot train a GFlowNet to sample proportional to R
(its global minimum is P_F == P_B with zero spectral energy). Definition 2
does carry the reward terms (r_term, r_int), so we read Definition 5 as the
*regularizer pair* that rides on top of a standard reward-matching GFlowNet
objective. We therefore implement

    L_STGFN = L_TB(with intrinsic AC reward)  +  w_c * L_spectral_consistency
                                              +  lambda * L_spectral_reg

with lambda adaptive (lambda = exp(theta_lambda)) per Eq. 14-15. All baselines
share the identical backbone/optimizer so the comparison isolates the spectral
machinery.
"""
from __future__ import annotations

import math
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F


class RFF(nn.Module):
    """Random Fourier Feature map z(s) = sqrt(2/D)[cos(w_i^T s + b_i)]_{i<D}.
    Gaussian kernel k(s,s') = exp(-||s-s'||^2 / (2 sigma^2))  (App. C.1.3)."""

    def __init__(self, in_dim: int, D: int = 256, sigma: float = 1.0, seed: int = 0):
        super().__init__()
        g = torch.Generator().manual_seed(seed)
        omega = torch.randn(D, in_dim, generator=g) / sigma
        b = torch.rand(D, generator=g) * 2 * math.pi
        self.register_buffer("omega", omega)
        self.register_buffer("bias", b)
        self.D = D

    def forward(self, x):
        proj = x @ self.omega.T + self.bias
        return math.sqrt(2.0 / self.D) * torch.cos(proj)


class GFNNet(nn.Module):
    """Shared backbone: 3 layers, 256 hidden units (App. C.1.1).

    Heads: forward-policy logits, backward-policy logits (over the same
    successor/action set, used by the spectral consistency term and by TB when
    a state has multiple parents), and log-flow log F(s,t)."""

    def __init__(self, state_dim: int, n_actions: int, max_t: int, hidden: int = 256, n_layers: int = 3):
        super().__init__()
        self.max_t = max_t
        in_dim = state_dim + max_t + 1
        layers = []
        d = in_dim
        for _ in range(n_layers):
            layers += [nn.Linear(d, hidden), nn.LeakyReLU()]
            d = hidden
        self.trunk = nn.Sequential(*layers)
        self.pf_head = nn.Linear(hidden, n_actions)
        self.pb_head = nn.Linear(hidden, n_actions)
        self.logF_head = nn.Linear(hidden, 1)
        self.logZ = nn.Parameter(torch.zeros(1))

    def _time_emb(self, t, device, batch):
        te = torch.zeros(batch, self.max_t + 1, device=device)
        te[torch.arange(batch, device=device), t.clamp(max=self.max_t)] = 1.0
        return te

    def forward(self, s, t):
        te = self._time_emb(t, s.device, s.shape[0])
        h = self.trunk(torch.cat([s, te], dim=-1))
        return self.pf_head(h), self.pb_head(h), self.logF_head(h).squeeze(-1)


class RNDNet(nn.Module):
    """Random Network Distillation bonus (Burda et al. 2018) for TB+RND."""

    def __init__(self, state_dim: int, hidden: int = 128, out: int = 64, seed: int = 0):
        super().__init__()
        torch.manual_seed(seed)
        self.target = nn.Sequential(
            nn.Linear(state_dim, hidden), nn.ReLU(), nn.Linear(hidden, out)
        )
        for p in self.target.parameters():
            p.requires_grad_(False)
        self.pred = nn.Sequential(
            nn.Linear(state_dim, hidden), nn.ReLU(), nn.Linear(hidden, out)
        )

    def bonus(self, s):
        with torch.no_grad():
            t = self.target(s)
        p = self.pred(s)
        return ((p - t) ** 2).mean(-1)


class ICMNet(nn.Module):
    """Intrinsic Curiosity Module forward-model error (Pathak et al. 2017)."""

    def __init__(self, state_dim: int, n_actions: int, hidden: int = 128):
        super().__init__()
        self.fwd = nn.Sequential(
            nn.Linear(state_dim + n_actions, hidden), nn.ReLU(), nn.Linear(hidden, state_dim)
        )
        self.n_actions = n_actions

    def error(self, s, a, s_next):
        a1h = F.one_hot(a, self.n_actions).float()
        pred = self.fwd(torch.cat([s, a1h], dim=-1))
        return ((pred - s_next) ** 2).mean(-1)


class AutocorrIntrinsic:
    """Online autocorrelated intrinsic reward (Alg. 1, lines 11-19).

    Maintains a circular buffer of raw local rewards and EMA estimates of the
    autocorrelation R_rr[tau_i], then r_AC(t) = sum_i w_i * R_rr_hat[tau_i]_t.

    `mode` controls the lag weights w_i, which the paper under-specifies:
      "uniform" - w_i = 1/K, the stated initialisation (App C.1.3). With uniform
                  weights r_AC sums every lag, so it tracks overall reward
                  magnitude and is NOT period-selective.
      "peak"    - mass concentrated on the strongest ACF lag (softmax over the
                  ACF). This is the charitable reading of Fig. 9(d), which shows
                  "learned lag weights concentrating on the period and its
                  harmonics" but gives no update rule anywhere in the paper.
    """

    def __init__(self, k_max: int = 8, alpha: float = 0.1, mode: str = "uniform",
                 temp: float = 0.5):
        self.k_max = k_max
        self.alpha = alpha
        self.mode = mode
        self.temp = temp
        self.weights = np.ones(k_max) / k_max
        self.reset()

    def reset(self):
        self.buf: list[float] = []
        self.acf = np.zeros(self.k_max)

    def update(self, r_t: float) -> float:
        self.buf.append(r_t)
        for i in range(1, self.k_max + 1):
            if len(self.buf) > i:
                prod = r_t * self.buf[-1 - i]
                self.acf[i - 1] = (1 - self.alpha) * self.acf[i - 1] + self.alpha * prod
        if self.mode == "peak":
            a = self.acf / (np.abs(self.acf).max() + 1e-12)
            e = np.exp((a - a.max()) / self.temp)
            self.weights = e / e.sum()
        return float((self.weights * self.acf).sum())

    def periodicity_score(self) -> float:
        m = np.abs(self.acf).mean()
        return float(np.abs(self.acf).max() / m) if m > 1e-12 else 0.0