"""Küçük Türkçe GPT (kucuk-gpt-egitimi-2026-10-23/train.py ile aynı mimari) + nöron (spike) simülasyonu.

FFN etkinleştirmesi seçilebilir: gelu (orijinal), relu, qrelu (kırpılmış+kuantize, nöron-uyumlu eğitim).
Spike modu: seçilen noktalardaki sinyaller IF (integrate-and-fire) nöronlarının T adımlık
spike sayısına çevrilir; katman sonraki işlemi yalnız spike'lardan (oran x eşik) yapar.
"""
import math
from pathlib import Path
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

ROOT = Path(__file__).resolve().parent
SRC = ROOT.parent / 'kucuk-gpt-egitimi-2026-10-23'
TOKENIZER = ROOT.parent / 'turkce-tokenizer-egitimi-2026-10-21/tokenizers/tr_100M_32k.json'


class Block(nn.Module):
    def __init__(s, d, H):
        super().__init__()
        s.d, s.H = d, H
        s.ln1, s.ln2 = nn.LayerNorm(d), nn.LayerNorm(d)
        s.qkv, s.proj = nn.Linear(d, 3 * d, bias=False), nn.Linear(d, d, bias=False)
        s.fc, s.out = nn.Linear(d, 4 * d, bias=False), nn.Linear(4 * d, d, bias=False)


class GPT(nn.Module):
    def __init__(s, V, d, L, H, ctx):
        super().__init__()
        s.ctx = ctx
        s.wte, s.wpe = nn.Embedding(V, d), nn.Embedding(ctx, d)
        s.blocks = nn.ModuleList(Block(d, H) for _ in range(L))
        s.ln = nn.LayerNorm(d)
        s.head = nn.Linear(d, V, bias=False); s.head.weight = s.wte.weight
        # nöron-uyumlu eğitim için katman başına öğrenilen eşik (qrelu modunda kullanılır)
        s.theta = nn.Parameter(torch.full((L,), 4.0))
        s.act, s.qlevels = 'gelu', 8
        s.spike = None  # None ya da Spiker

    def forward(s, idx, y=None):
        x = s.wte(idx) + s.wpe(torch.arange(idx.shape[1], device=idx.device))
        for i, b in enumerate(s.blocks):
            x = s._block(i, b, x)
        h = s.ln(x)
        if s.spike is not None: h = s.spike(h, f'head', signed=True)
        logits = s.head(h)
        if y is None: return logits
        return F.cross_entropy(logits.float().view(-1, logits.shape[-1]), y.view(-1))

    def _block(s, i, b, x):
        B, T, C = x.shape
        sp = s.spike
        h = b.ln1(x)
        if sp is not None: h = sp(h, f'{i}.qkv', signed=True)
        q, k, v = b.qkv(h).split(C, 2)
        q, k, v = (t.view(B, T, b.H, C // b.H).transpose(1, 2) for t in (q, k, v))
        y = F.scaled_dot_product_attention(q, k, v, is_causal=True).transpose(1, 2).reshape(B, T, C)
        if sp is not None: y = sp(y, f'{i}.proj', signed=True)
        x = x + b.proj(y)
        h = b.ln2(x)
        if sp is not None: h = sp(h, f'{i}.fc', signed=True)
        z = b.fc(h)
        if sp is not None and sp.has(f'{i}.ffn'):
            a = sp(z, f'{i}.ffn', signed=False)  # nöron: yalnız pozitif akım spike üretir (ReLU benzeri)
        elif s.act == 'gelu':
            a = F.gelu(z)
        elif s.act == 'relu':
            a = F.relu(z)
        else:  # qrelu: [0, theta] arası kırp, qlevels basamağa kuantize et (düz geçişli gradyan)
            th = s.theta[i].abs() + 1e-3
            c = torch.clamp(z, min=0.0)
            c = torch.minimum(c, th)
            q = torch.floor(c / th * s.qlevels + 0.5) / s.qlevels * th
            a = c + (q - c).detach()
        return x + b.out(a)


class Spiker:
    """IF nöronları: sabit giriş akımı T adım boyunca zara eklenir; zar eşiği geçince spike + yumuşak sıfırlama.
    Çıkış = spike_sayısı / T * eşik (hız kodlaması). İşaretli sinyaller için +/- iki nöron grubu.
    Eşikler kalibrasyon verisinden (|a| yüzdeliği) ya da öğrenilmiş theta'dan gelir.
    """

    def __init__(s, T, thresholds, sites):
        s.T, s.th, s.sites = T, thresholds, set(sites)
        s.reset_counts()

    def has(s, name): return name in s.sites

    def reset_counts(s):
        s.spikes, s.neurons, s.fanout_events = {}, {}, {}

    def __call__(s, a, name, signed):
        if name not in s.sites: return a
        th = s.th[name]
        out = torch.zeros_like(a); nsp = torch.zeros((), device=a.device, dtype=torch.float64)
        for sign in ((1.0, -1.0) if signed else (1.0,)):
            I = torch.clamp(sign * a, min=0.0)
            v = torch.full_like(I, 0.5 * th)  # yarım eşikten başlat (yuvarlama hatasını azaltır)
            cnt = torch.zeros_like(I)
            for _ in range(s.T):
                v = v + I
                sp = (v >= th).to(I.dtype)
                v = v - sp * th
                cnt = cnt + sp
            out = out + sign * cnt * (th / s.T)
            nsp += cnt.sum(dtype=torch.float64)
        s.spikes[name] = s.spikes.get(name, 0.0) + float(nsp)
        s.neurons[name] = s.neurons.get(name, 0) + a.numel() * (2 if signed else 1)
        return out


def load(name, device='cuda'):
    from tokenizers import Tokenizer
    tok = Tokenizer.from_file(str(TOKENIZER))
    p = SRC / 'ckpt' / f'{name}.pt'
    if not p.exists(): p = ROOT / 'ckpt' / f'{name}.pt'
    ck = torch.load(p, map_location='cpu', weights_only=False)
    c = ck['cfg']
    m = GPT(c['vocab'], c['d'], c['L'], c['H'], c['ctx'])
    missing, unexpected = m.load_state_dict(ck['model'], strict=False)
    assert set(missing) <= {'theta'} and not unexpected, (missing, unexpected)
    if 'act' in ck: m.act = ck['act']
    if 'qlevels' in ck: m.qlevels = ck['qlevels']
    return m.to(device), tok, c


def data():
    train = np.memmap(SRC / 'data/train.bin', dtype=np.uint16, mode='r')
    val = np.memmap(SRC / 'data/val.bin', dtype=np.uint16, mode='r')
    return train, val


def batch(src, idx, ctx, device='cuda'):
    x = torch.from_numpy(np.stack([src[i:i + ctx].astype(np.int64) for i in idx]))
    y = torch.from_numpy(np.stack([src[i + 1:i + 1 + ctx].astype(np.int64) for i in idx]))
    return x.to(device), y.to(device)
