"""Grafikler (1600×900, @zekayapar). Veri: results/eval.json, results/train.json, tokenizers/*.json"""
import json, math, re
from collections import Counter
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont
from tokenizers import Tokenizer
import tiktoken

ROOT = Path(__file__).resolve().parent
OUT = ROOT / 'charts'; OUT.mkdir(exist_ok=True)
D = json.load(open(ROOT / 'results/eval.json'))
R = {r['label']: r for r in D['results']}
T = {r['name']: r for r in json.load(open(ROOT / 'results/train.json'))['runs']}
W, H = 1600, 900
BG, FG, MUTED, GRID = (24, 26, 22), (240, 234, 220), (170, 165, 150), (60, 62, 56)
BLUE, AMBER, GREEN, RED, PURPLE = (110, 170, 230), (240, 170, 70), (120, 200, 120), (225, 95, 85), (180, 140, 230)
B = '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf'
RG = '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf'
MONO = '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf'
f = lambda p, s: ImageFont.truetype(p, s)
c = lambda x, n=2: f'{x:.{n}f}'.replace('.', ',')
th = lambda x: f'{int(round(x)):,}'.replace(',', '.')
GPT, QW, LL, KU, YT = 'GPT-4o ailesi (o200k)', 'Qwen3.8', 'Llama 4', 'Kumru (VNGRS)', 'Türkçe GPT-2 (YTÜ)'
tok = lambda n: Tokenizer.from_file(str(ROOT / 'tokenizers' / f'{n}.json'))
O200 = tiktoken.get_encoding('o200k_base')


def canvas(title, sub):
    im = Image.new('RGB', (W, H), BG); d = ImageDraw.Draw(im)
    d.text((60, 44), title, font=f(B, 46), fill=FG)
    d.text((60, 106), sub, font=f(RG, 24), fill=MUTED)
    return im, d


def sign(d):
    d.text((W - 48, H - 30), '@zekayapar', font=f(B, 30), fill=FG, anchor='rd')


def legend(d, items, y=842, x=60):
    for lab, col in items:
        d.rounded_rectangle((x, y - 13, x + 26, y + 13), radius=4, fill=col)
        d.text((x + 36, y), lab, font=f(RG, 22), fill=FG, anchor='lm')
        x += 50 + d.textlength(lab, font=f(RG, 22))


def pieces_o200(s):
    return [O200.decode_single_token_bytes(i).decode('utf-8', 'replace') for i in O200.encode(s)]


def pieces_own(t, s):
    return [t.decode([i]) for i in t.encode(s, add_special_tokens=False).ids]


# 1 — ana sonuç
def sonuc():
    rows = [(QW, 'Qwen3.8 · 248k sözlük', BLUE), (GPT, 'GPT-4o ailesi · 200k', BLUE), (LL, 'Llama 4 · 201k', BLUE),
            ('tr_100M_8k', 'Benim · 8k sözlük', AMBER), ('tr_100M_32k', 'Benim · 32k sözlük', AMBER),
            (KU, 'Kumru (VNGRS) · 50k', GREEN), (YT, 'Türkçe GPT-2 (YTÜ) · 50k', GREEN), ('tr_100M_256k', 'Benim · 256k sözlük', AMBER)]
    im, d = canvas('Kendi tokenizer’ım Türkçede kaç token tutuyor?',
                   'FLORES-200 · aynı 2009 Türkçe cümlenin toplam token sayısı · az olan daha iyi')
    x0, y0, rh, mx = 470, 175, 76, 80000
    sc = (W - x0 - 230) / mx
    for i, (k, lab, col) in enumerate(rows):
        y = y0 + i * rh; v = R[k]['tr_tokens']
        d.text((x0 - 20, y + rh / 2 - 2), lab, font=f(B if col == AMBER else RG, 26), fill=FG, anchor='rm')
        d.rounded_rectangle((x0, y + 10, x0 + v * sc, y + rh - 12), radius=6, fill=col)
        pct = (v / R[GPT]['tr_tokens'] - 1) * 100
        txt = th(v) + ('' if k == GPT else f'  ({"+" if pct > 0 else "−"}%{c(abs(pct), 0)})')
        d.text((x0 + v * sc + 14, y + rh / 2 - 2), txt, font=f(B, 26), fill=FG, anchor='lm')
    legend(d, [('hazır genel modeller', BLUE), ('Türkçe için eğitilmiş modeller', GREEN), ('benim eğittiklerim (100M karakter Wikipedia)', AMBER)])
    d.text((W - 48, 790), 'parantez: GPT-4o ailesine göre fark', font=f(RG, 20), fill=MUTED, anchor='rm')
    sign(d); im.save(OUT / 'sonuc.png')


# 2 — sözlük büyüklüğü eğrisi
def sozluk():
    ks = [8, 16, 32, 64, 128, 256]
    vals = [R[f'tr_100M_{k}k']['tr_tokens'] for k in ks]
    im, d = canvas('Sözlüğü büyütünce ne kadar kazanıyorum?',
                   'aynı 100 milyon karakterlik Türkçe metinle 6 ayrı eğitim · 2009 FLORES cümlesindeki toplam token')
    x0, x1, y0, y1, lo, hi = 170, 1480, 190, 760, 40000, 80000
    X = lambda i: x0 + i * (x1 - x0) / (len(ks) - 1)
    Y = lambda v: y1 - (v - lo) / (hi - lo) * (y1 - y0)
    for t in range(lo, hi + 1, 10000):
        d.line((x0, Y(t), x1, Y(t)), fill=GRID); d.text((x0 - 14, Y(t)), th(t), font=f(RG, 20), fill=MUTED, anchor='rm')
    for i, k in enumerate(ks):
        d.text((X(i), y1 + 16), f'{k}k', font=f(B, 24), fill=FG, anchor='mt')
    d.text(((x0 + x1) / 2, y1 + 52), 'sözlükteki parça sayısı (her adım iki katı)', font=f(RG, 22), fill=MUTED, anchor='mt')
    for k, col, lab in [(GPT, BLUE, 'GPT-4o ailesi (200k sözlük)'), (KU, GREEN, 'Kumru (50k sözlük)')]:
        y = Y(R[k]['tr_tokens'])
        for xx in range(x0, x1, 24): d.line((xx, y, xx + 12, y), fill=col, width=3)
        d.text((x1, y - 8), f'{lab} · {th(R[k]["tr_tokens"])}', font=f(RG, 22), fill=col, anchor='rd')
    pts = [(X(i), Y(v)) for i, v in enumerate(vals)]
    d.line(pts, fill=AMBER, width=6, joint='curve')
    for i, ((x, y), v) in enumerate(zip(pts, vals)):
        d.ellipse((x - 10, y - 10, x + 10, y + 10), fill=AMBER)
        d.text((x + (14 if i == 0 else 6), y + 18), th(v), font=f(B, 24), fill=FG, anchor='lt')
        if i:
            dp = (v / vals[i - 1] - 1) * 100
            mxp, myp = (pts[i - 1][0] + x) / 2, (pts[i - 1][1] + y) / 2
            d.text((mxp + 14, myp - 12 - (34 if abs(myp - 12 - Y(R[KU]['tr_tokens'])) < 30 else 0)), f'−%{c(-dp, 1)}', font=f(B, 22), fill=AMBER, anchor='lb')
    sign(d); im.save(OUT / 'sozluk-egrisi.png')


def boxes(d, pcs, x, y, xmax, col_a, col_b, fs=24, h=40):
    fo = f(MONO, fs); x00 = x
    for j, p in enumerate(pcs):
        lab = p.replace(' ', '·')
        tw = d.textlength(lab, font=fo)
        if x + tw + 12 > xmax:
            x = x00; y += h + 8
        d.rounded_rectangle((x, y, x + tw + 12, y + h), radius=6, fill=col_a if j % 2 == 0 else col_b)
        d.text((x + 6, y + h / 2), lab, font=fo, fill=(20, 20, 20), anchor='lm')
        x += tw + 16
    return y + h


# 3 — tek cümle
def cumle():
    s = D['sentence0'].split('. ')[0] + '.'
    t32, t256 = tok('tr_100M_32k'), tok('tr_100M_256k')
    rows = [('GPT-4o ailesi', pieces_o200(s), ((150, 195, 240), (110, 160, 215))),
            ('Benim 32k', pieces_own(t32, s), ((250, 195, 110), (225, 160, 70))),
            ('Benim 256k', pieces_own(t256, s), ((250, 220, 160), (235, 185, 100)))]
    im, d = canvas('Aynı cümle, üç tokenizer', 'FLORES-200’ün ilk Türkçe cümlesinin ilk yarısı · her kutu bir token · boşluk “·” ile gösterildi')
    y = 168
    for lab, pcs, cols in rows:
        d.text((60, y), f'{lab}', font=f(B, 28), fill=FG)
        d.text((60, y + 36), f'{len(pcs)} token', font=f(B, 34), fill=cols[1])
        y = boxes(d, pcs, 300, y, W - 50, *cols, fs=22, h=36) + 34
    s_ = re.sub(r'\s+', ' ', s)
    sign(d); im.save(OUT / 'cumle.png'); return {lab: len(p) for lab, p, _ in rows}


# 4 — veri miktarı
def veri():
    ms = [1, 3, 10, 30, 100, 300]
    names = [f'tr_{m}M_32k' if m != 100 else 'tr_100M_32k' for m in ms]
    vals = [R[n]['tr_tokens'] for n in names]
    im, d = canvas('Ne kadar Türkçe metin yetiyor?', '32k sözlük · eğitim metni 1 milyon → 300 milyon karakter · Wikipedia makaleleri')
    x0, x1, y0, y1, lo, hi = 170, 1480, 200, 700, 50000, 80000
    X = lambda i: x0 + i * (x1 - x0) / (len(ms) - 1)
    Y = lambda v: y1 - (v - lo) / (hi - lo) * (y1 - y0)
    for t in range(lo, hi + 1, 5000):
        d.line((x0, Y(t), x1, Y(t)), fill=GRID); d.text((x0 - 14, Y(t)), th(t), font=f(RG, 20), fill=MUTED, anchor='rm')
    y = Y(R[GPT]['tr_tokens'])
    for xx in range(x0, x1, 24): d.line((xx, y, xx + 12, y), fill=BLUE, width=3)
    d.text((x1, y - 8), f'GPT-4o ailesi · {th(R[GPT]["tr_tokens"])}', font=f(RG, 22), fill=BLUE, anchor='rd')
    pts = [(X(i), Y(v)) for i, v in enumerate(vals)]
    d.line(pts, fill=AMBER, width=6, joint='curve')
    for i, ((x, yy), v) in enumerate(zip(pts, vals)):
        d.ellipse((x - 10, yy - 10, x + 10, yy + 10), fill=AMBER)
        d.text((x, yy - 18), th(v), font=f(B, 24), fill=FG, anchor='mb')
        n = names[i]
        d.text((x, y1 + 18), f'{ms[i]} milyon', font=f(B, 24), fill=FG, anchor='mt')
        d.text((x, y1 + 50), f'{c(T[n]["train_seconds"], 1)} sn · {th(T[n]["peak_rss_mib"])} MB', font=f(RG, 20), fill=MUTED, anchor='mt')
    d.text((60, 800), 'alt satır: eğitim süresi ve en yüksek RAM kullanımı (Threadripper PRO 5955WX, GPU yok)', font=f(RG, 22), fill=MUTED)
    d.text((60, 834), f'1 milyon karakterde sözlük {th(R["tr_1M_32k"]["vocab"])} parçada doldu: o kadar küçük metinde 32k’ya yetecek tekrar yok', font=f(RG, 22), fill=MUTED)
    sign(d); im.save(OUT / 'veri-miktari.png')


# 5 — eğitim maliyeti (sözlük büyüklüğüne göre)
def egitim():
    ks = [8, 16, 32, 64, 128, 256]
    im, d = canvas('Eğitmek ne kadar sürdü?', '100 milyon karakter Türkçe · Hugging Face tokenizers · Threadripper PRO 5955WX · GPU kullanılmadı')
    x0, y1, bw, gap, hi = 200, 720, 120, 88, 16
    for t in range(0, hi + 1, 4):
        y = y1 - t / hi * 480
        d.line((150, y, 1500, y), fill=GRID); d.text((136, y), f'{t} sn', font=f(RG, 20), fill=MUTED, anchor='rm')
    for i, k in enumerate(ks):
        r = T[f'tr_100M_{k}k']; x = x0 + i * (bw + gap)
        h = r['train_seconds'] / hi * 480
        d.rounded_rectangle((x, y1 - h, x + bw, y1), radius=6, fill=AMBER)
        d.text((x + bw / 2, y1 - h - 10), c(r['train_seconds'], 1) + ' sn', font=f(B, 26), fill=FG, anchor='mb')
        d.text((x + bw / 2, y1 + 16), f'{k}k', font=f(B, 26), fill=FG, anchor='mt')
        d.text((x + bw / 2, y1 + 52), f'{th(r["peak_rss_mib"])} MB', font=f(RG, 20), fill=MUTED, anchor='mt')
    d.text((60, 830), 'alt satır: en yüksek RAM · sözlük 32 kat büyüdü, süre 2 katına çıktı', font=f(RG, 22), fill=MUTED)
    sign(d); im.save(OUT / 'egitim-suresi.png')


# 6 — iki dil
def iki_dil():
    rows = [(GPT, 'GPT-4o ailesi'), ('tr_100M_32k', 'Benim · yalnız Türkçe · 32k'), ('en_100M_32k', 'Benim · yalnız İngilizce · 32k'),
            ('mix_100M_32k', 'Benim · yarı yarıya · 32k'), ('mix_100M_64k', 'Benim · yarı yarıya · 64k')]
    im, d = canvas('Yalnız Türkçe öğretince İngilizce ne oluyor?', 'aynı 2009 cümlenin Türkçe ve İngilizce hali · toplam token · az olan daha iyi')
    x0, y0, rh, mx = 520, 170, 122, 130000
    sc = (W - x0 - 190) / mx
    for i, (k, lab) in enumerate(rows):
        y = y0 + i * rh; r = R[k]
        d.text((x0 - 20, y + 42), lab, font=f(B, 25), fill=FG, anchor='rm')
        for j, (v, col) in enumerate([(r['tr_tokens'], RED), (r['en_tokens'], BLUE)]):
            yy = y + j * 46
            d.rounded_rectangle((x0, yy, x0 + v * sc, yy + 38), radius=5, fill=col)
            d.text((x0 + v * sc + 12, yy + 19), th(v), font=f(B, 23), fill=FG, anchor='lm')
    legend(d, [('Türkçe', RED), ('İngilizce', BLUE)], y=820)
    sign(d); im.save(OUT / 'iki-dil.png')


# 7 — kelimeler
def kelimeler():
    t32 = tok('tr_100M_32k')
    ws = ['yapabileceklerimizden', 'gözlükçülerden', 'kitaplarımızdaki', 'Çekoslovakyalılaştıramadıklarımızdan', 'teşekkür ederim', 'computer']
    im, d = canvas('Kelimeyi nereden bölüyor?', 'üstte GPT-4o ailesi, altta benim 32k Türkçe tokenizer’ım · her kutu bir token')
    y = 160
    for w in ws:
        d.text((60, y + 6), w, font=f(B, 26), fill=FG)
        a, b = pieces_o200(w), pieces_own(t32, w)
        yb = boxes(d, a, 700, y, W - 60, (150, 195, 240), (110, 160, 215), fs=25, h=34)
        d.text((660, y + 16), str(len(a)), font=f(B, 24), fill=BLUE, anchor='rm')
        d.text((660, yb + 24), str(len(b)), font=f(B, 24), fill=AMBER, anchor='rm')
        yb = boxes(d, b, 700, yb + 8, W - 60, (250, 195, 110), (225, 160, 70), fs=25, h=34)
        y = yb + 26
    sign(d); im.save(OUT / 'kelimeler.png')


# 8 — ilk öğrendikleri
def ilk():
    m = D['vocab']['tr_100M_32k']['first_merges'][:40]
    im, d = canvas('Eğitim sırasında ilk öğrendiği 40 parça', 'BPE en sık yan yana gelen iki parçayı birleştirerek başlar · sıra numarası = öğrenme sırası')
    TRL = set('çğıöşüÇĞİÖŞÜ')
    x, y = 60, 175; fo = f(MONO, 36)
    for i, p in enumerate(m):
        col = GREEN if p in TRL else (PURPLE if p.startswith(' ') else AMBER)
        lab = p.replace(' ', '·')
        tw = d.textlength(lab, font=fo); bw = max(tw + 30, 96)
        if x + bw > W - 60: x = 60; y += 120
        d.rounded_rectangle((x, y, x + bw, y + 70), radius=10, fill=col)
        d.text((x + bw / 2, y + 35), lab, font=fo, fill=(20, 20, 20), anchor='mm')
        d.text((x + bw / 2, y + 80), str(i + 1), font=f(RG, 18), fill=MUTED, anchor='mt')
        x += bw + 18
    legend(d, [('tek Türkçe harf (2 bayt birleşti)', GREEN), ('kelime başı (·= boşluk)', PURPLE), ('hece / ek parçası', AMBER)], y=830)
    sign(d); im.save(OUT / 'ilk-ogrendikleri.png')


# 9 — en çok kullanılan ek parçaları (FLORES Türkçe, kelime içi tokenlar)
def ekler():
    t = tok('tr_100M_32k'); F = ROOT / 'data/flores200_dataset'
    TR = (F / 'dev/tur_Latn.dev').read_text().splitlines() + (F / 'devtest/tur_Latn.devtest').read_text().splitlines()
    cnt = Counter()
    for s in TR:
        for p in pieces_own(t, s):
            if not p.startswith(' ') and re.fullmatch(r'[^\W\d_]+', p) and p[0].islower(): cnt[p] += 1
    top = cnt.most_common(16)
    im, d = canvas('Kelimelerin içinde en çok hangi parçaları kullandı?', 'benim 32k tokenizer · 2009 Türkçe FLORES cümlesi · kelimenin başında olmayan, yalnız harften oluşan tokenlar')
    x0, y0, rh, mx = 220, 165, 40, top[0][1]
    sc = (W - x0 - 160) / mx
    for i, (p, n) in enumerate(top):
        y = y0 + i * rh
        d.text((x0 - 18, y + rh / 2), '-' + p, font=f(MONO, 26), fill=FG, anchor='rm')
        d.rounded_rectangle((x0, y + 5, x0 + n * sc, y + rh - 5), radius=4, fill=AMBER)
        d.text((x0 + n * sc + 10, y + rh / 2), th(n), font=f(B, 22), fill=FG, anchor='lm')
    sign(d); im.save(OUT / 'ekler.png'); return top


# 10 — gizli maliyet: gömme tablosu (hesap)
def gizli():
    ks = [8, 16, 32, 64, 128, 256]
    im, d = canvas('Büyük sözlüğün gizli bedeli', 'sol: ölçüm (Türkçe token) · sağ: hesap (sözlük × 512 boyut, küçük bir modelin giriş tablosu)')
    # sol
    x0, y1, bw, gap = 110, 760, 82, 30
    mx = 70000
    d.text((x0, 170), 'Türkçe toplam token (ölçüm)', font=f(B, 26), fill=FG)
    for i, k in enumerate(ks):
        v = R[f'tr_100M_{k}k']['tr_tokens']; x = x0 + i * (bw + gap); h = v / mx * 480
        d.rounded_rectangle((x, y1 - h, x + bw, y1), radius=5, fill=AMBER)
        d.text((x + bw / 2, y1 - h - 8), f'{c(v / 1000, 1)} bin', font=f(B, 22), fill=FG, anchor='mb')
        d.text((x + bw / 2, y1 + 14), f'{k}k', font=f(B, 24), fill=FG, anchor='mt')
    # sağ
    x0 = 860; mxp = 140
    d.text((x0, 170), 'giriş tablosu parametresi (hesap, milyon)', font=f(B, 26), fill=FG)
    for i, k in enumerate(ks):
        p = k * 1024 * 512 / 1e6; x = x0 + i * (bw + gap); h = p / mxp * 480
        d.rounded_rectangle((x, y1 - h, x + bw, y1), radius=5, fill=PURPLE)
        d.text((x + bw / 2, y1 - h - 8), c(p, 1), font=f(B, 22), fill=FG, anchor='mb')
        d.text((x + bw / 2, y1 + 14), f'{k}k', font=f(B, 24), fill=FG, anchor='mt')
    d.text((60, 815), 'sözlük 8k’dan 256k’ya: Türkçe token %34 azaldı, giriş tablosu 32 kat büyüdü', font=f(RG, 22), fill=MUTED)
    d.text((60, 850), '30 milyon parametrelik küçük bir model için 64k sözlüğün tablosu tek başına 33,6 milyon: bütçeyi aşıyor', font=f(RG, 22), fill=MUTED)
    sign(d); im.save(OUT / 'gizli-maliyet.png')


# 11 — günlük anlamı: 1000 Türkçe kelime kaç token
def gunluk():
    rows = [(QW, 'Qwen3.8', BLUE), (GPT, 'GPT-4o ailesi', BLUE), ('tr_100M_32k', 'benim 32k', AMBER), (KU, 'Kumru', GREEN),
            ('mix_100M_64k', 'benim karışık 64k', AMBER), ('tr_100M_256k', 'benim 256k', AMBER)]
    im, d = canvas('1000 Türkçe kelimelik bir metin kaç token tutar?', 'FLORES ortalamasından: kelime başına token × 1000 · aynı metin, farklı sözlük')
    x, y = 70, 210
    for i, (k, lab, col) in enumerate(rows):
        v = R[k]['tr_tokens_per_word'] * 1000
        xx, yy = x + (i % 3) * 500, y + (i // 3) * 290
        d.rounded_rectangle((xx, yy, xx + 450, yy + 240), radius=18, outline=col, width=4)
        d.text((xx + 225, yy + 50), lab, font=f(B, 30), fill=col, anchor='mm')
        d.text((xx + 225, yy + 130), th(v), font=f(B, 72), fill=FG, anchor='mm')
        d.text((xx + 225, yy + 200), 'token', font=f(RG, 24), fill=MUTED, anchor='mm')
    sign(d); im.save(OUT / 'gunluk.png')


sonuc(); sozluk(); n = cumle(); veri(); egitim(); iki_dil(); kelimeler(); ilk(); top = ekler(); gizli(); gunluk()
json.dump({'sentence_half_tokens': n, 'top_inner_pieces': top}, open(ROOT / 'results/chart_numbers.json', 'w'), ensure_ascii=False, indent=1)
print(n, top)
