#include "fiko/analiz/analiz_nesne.hpp"

#include <algorithm>

namespace fiko::analiz {

const char* analizTipAdi(AnalizTip t) {
  switch (t) {
    case AnalizTip::Draft:      return "Çekme Açısı";
    case AnalizTip::Undercut:   return "Undercut";
    case AnalizTip::Kalinlik:   return "Et Kalınlığı";
    case AnalizTip::Radius:     return "Radius";
    case AnalizTip::Kurvatur:   return "Kurvatür";
    case AnalizTip::Zebra:      return "Zebra";
    case AnalizTip::Sureklilik: return "Süreklilik";
    case AnalizTip::Reflect:    return "Yansıma";
    case AnalizTip::Fark:       return "CAD Fark";
    case AnalizTip::KeskinKenar: return "Keskin Kenar";
  }
  return "Analiz";
}

const char* analizTipSimge(AnalizTip t) {
  switch (t) {
    case AnalizTip::Draft:      return "◿";
    case AnalizTip::Undercut:   return "⛏";
    case AnalizTip::Kalinlik:   return "▤";
    case AnalizTip::Radius:     return "◜";
    case AnalizTip::Kurvatur:   return "◠";
    case AnalizTip::Zebra:      return "▦";
    case AnalizTip::Sureklilik: return "⌇";
    case AnalizTip::Reflect:    return "◎";
    case AnalizTip::Fark:       return "⇄";
    case AnalizTip::KeskinKenar: return "◣";
  }
  return "🔬";
}

const char* hesapModAdi(HesapMod m) {
  switch (m) {
    case HesapMod::Hizli:  return "Hızlı (GPU)";
    case HesapMod::Hibrit: return "Hibrit (GPU + arka rapor)";
    case HesapMod::Kesin:  return "Kesin (tam CPU)";
  }
  return "?";
}

namespace { HesapMod g_varsayilanMod = HesapMod::Hizli; }  // varsayılan: anında görsel, donmasız
HesapMod varsayilanHesapMod() { return g_varsayilanMod; }
void varsayilanHesapModAyarla(HesapMod m) { g_varsayilanMod = m; }

// Undercut görünürlük: varsayılan AÇIK — saf dot(normal,yön) undercut'ı kapalı/dik
// delikte yanlış boyuyordu (yarı yeşil/yarı kırmızı). Kapatınca eski yol birebir döner.
const char* undercutKipAdi(UndercutKip k) {
  switch (k) {
    // Yuz/Hibrit 2026-07-15'te GECICI kapatildi (ayar_kayitlari.cpp kaydinda gerekce +
    // [[fikatia-undercut-gorunurluk]]). Adlar "kusursuz keskin" diyordu, olcum aksini
    // gosterdi (Yuz parcanin %81.8'ini kirmiziya boyuyor) → yanilticiydi, duzeltildi.
    case UndercutKip::Yuz:    return "Yüz (BREP — KAPALI: fazla boyuyor)";
    case UndercutKip::Golge:  return "Gölge (gerçek şekil)";
    case UndercutKip::Hibrit: return "Hibrit (KAPALI: kısmi gölge eksik)";
  }
  return "?";
}

namespace {
// VARSAYILAN = Golge: kullanici dogrulamasi "GOLGE DOGRU, YUZ/BREP TAMAMEN YANLIS".
// Per-fragment golge haritasi ordinal esleme KULLANMAZ → STEP import'ta da dogru.
// BREP/Hibrit yollari acik ama per-yuz ordinal → mesh (cpuAlt) eslemesi HENUZ
// DOGRULANMADI; supheli o. Dogrulanana kadar varsayilan guvenli kip.
UndercutKip g_undercutKip = UndercutKip::Golge;
f32 g_undercutAdim = 0.0f;      // 0 = otomatik (govde kosegeni/150)
u32 g_undercutIzgaraMaks = 24;  // eksen basina tavan → en fazla 576 isin/yuz
bool g_undercutGorunurluk = true;
// 4096² D32 = 64 MB VRAM. Web 2048 kullanir ama frustum'u tum sahneye yayiyor;
// biz XY'yi analiz edilen govdeye daraltiyoruz → ayni bellekte cok daha yogun texel.
// Golge kenari merdivenli gorunurse Ayarlar'dan 8192 (256 MB) yapilabilir.
u32 g_golgeCozunurluk = 4096;
f32 g_golgeEsik = 1e-4f;
// Radius: serbest (B-spline/koni) yuzde analitik yaricap YOKTUR → asal egrilikten
// R = 1/max(|kMin|,|kMaks|). Kapatinca eski yol birebir doner (o yuzler notr).
bool g_radiusSerbestKurvatur = true;
// Kalinlik: yuz basina EN KUCUK ornek (en-kotu-durum). Kapali = eski ORTALAMA
// davranisi (degisken cidarda en ince yer maskelenir — kama testinde 5.5 vs 1.0).
bool g_kalinlikYuzMin = true;
u32 g_kalinlikIzgara = 8;  // eksen basina UV hucre → <= 64 ornek/yuz
// Kalinlik: PER-VERTEX isi haritasi (GPU wall.comp zaten vertex basina olcuyor).
// Kapali = eski PerYuz (yuz basina TEK renk).
bool g_kalinlikPerVertex = true;
// Kalinlik: PER-FRAGMENT GPU isin (BVH). Acik = her piksel kendi kalinligini olcer
// (ucgenlemeden bagimsiz). Kapali = per-vertex/per-yuz alan yolu.
bool g_kalinlikPerFragment = true;
}  // namespace
bool undercutGorunurluk() { return g_undercutGorunurluk; }
void undercutGorunurlukAyarla(bool a) { g_undercutGorunurluk = a; }
UndercutKip undercutKip() { return g_undercutKip; }
void undercutKipAyarla(UndercutKip k) { g_undercutKip = k; }
f32 undercutOrnekAdim() { return g_undercutAdim; }
void undercutOrnekAdimAyarla(f32 mm) { g_undercutAdim = mm; }
u32 undercutIzgaraMaks() { return g_undercutIzgaraMaks; }
void undercutIzgaraMaksAyarla(u32 n) { g_undercutIzgaraMaks = n; }
u32 golgeCozunurluk() { return g_golgeCozunurluk; }
void golgeCozunurlukAyarla(u32 c) { g_golgeCozunurluk = c; }
f32 golgeEsik() { return g_golgeEsik; }
void golgeEsikAyarla(f32 e) { g_golgeEsik = e; }
bool radiusSerbestKurvatur() { return g_radiusSerbestKurvatur; }
void radiusSerbestKurvaturAyarla(bool a) { g_radiusSerbestKurvatur = a; }
bool kalinlikYuzMin() { return g_kalinlikYuzMin; }
void kalinlikYuzMinAyarla(bool a) { g_kalinlikYuzMin = a; }
bool kalinlikPerVertex() { return g_kalinlikPerVertex; }
bool kalinlikPerFragment() { return g_kalinlikPerFragment; }
void kalinlikPerFragmentAyarla(bool a) { g_kalinlikPerFragment = a; }
void kalinlikPerVertexAyarla(bool a) { g_kalinlikPerVertex = a; }
u32 kalinlikIzgara() { return g_kalinlikIzgara; }
void kalinlikIzgaraAyarla(u32 n) { g_kalinlikIzgara = std::clamp(n, 2u, 64u); }

// renkRampa.glsl ikizi (jet/turbo/tolerans) — lejant 3B ile ayni renkleri cizsin.
Vec3f rampaRenk(int tip, f32 t) {
  t = std::clamp(t, 0.0f, 1.0f);
  if (tip == 1) {  // Turbo (polinom — GLSL ile ayni katsayilar)
    const Vec3f c0{0.1140f, 0.0628f, 0.2248f}, c1{6.7164f, 3.1822f, 7.5715f};
    const Vec3f c2{-66.094f, -4.9279f, -10.089f}, c3{228.766f, 25.005f, -91.541f};
    const Vec3f c4{-334.83f, -69.315f, 288.586f}, c5{218.766f, 67.523f, -305.20f};
    const Vec3f c6{-52.889f, -21.549f, 110.514f};
    const f32 t2 = t * t, t3 = t2 * t, t4 = t2 * t2, t5 = t4 * t, t6 = t4 * t2;
    Vec3f v = c0 + c1 * t + c2 * t2 + c3 * t3 + c4 * t4 + c5 * t5 + c6 * t6;
    return {std::clamp(v.x, 0.0f, 1.0f), std::clamp(v.y, 0.0f, 1.0f),
            std::clamp(v.z, 0.0f, 1.0f)};
  }
  if (tip == 3) {  // Tolerans: merkez yesil, uclar kirmizi
    const f32 d = std::abs(t - 0.5f) * 2.0f;
    const Vec3f yesil{0.24f, 0.74f, 0.36f}, sari{0.96f, 0.84f, 0.26f},
                kirm{0.90f, 0.22f, 0.20f};
    const f32 k = d < 0.5f ? d * 2.0f : (d - 0.5f) * 2.0f;
    const Vec3f a = d < 0.5f ? yesil : sari, b = d < 0.5f ? sari : kirm;
    return a + (b - a) * k;
  }
  // Jet (varsayilan): mavi→cyan→yesil→sari→kirmizi
  return {std::clamp(1.5f - std::abs(4.0f * t - 3.0f), 0.0f, 1.0f),
          std::clamp(1.5f - std::abs(4.0f * t - 2.0f), 0.0f, 1.0f),
          std::clamp(1.5f - std::abs(4.0f * t - 1.0f), 0.0f, 1.0f)};
}

OzellikSeti AnalizNesnesi::ozellikler(Dunya&) {
  OzellikSeti o;
  o.push_back(Ozellik::metin(
      "Tip", [this] { return std::string(analizTipAdi(tip_)); }, [](const std::string&) {}));
  o.push_back(Ozellik::bayrak(
      "Aktif", [this] { return aktif; }, [this](bool v) {
        aktif = v;
        if (aktifDegisti) aktifDegisti(v);  // sahne-dugumlu analizlerde gorsel tazele
      }));
  // Cekim yonu (draft/undercut): Vektor ozelligi.
  if (tip_ == AnalizTip::Draft || tip_ == AnalizTip::Undercut) {
    Ozellik cy;
    cy.ad = "Çekim Yönü";
    cy.tur = Ozellik::Tur::Vektor;
    cy.vektorOku = [this] { return cekimYonu; };
    cy.vektorYaz = [this](Vec3f v) {
      cekimYonu = v.uzunlukKare() > 1e-8f ? v.birim() : Vec3f{0, 0, 1};
      bayat_ = true;
    };
    o.push_back(std::move(cy));
  }
  if (tip_ == AnalizTip::Radius) {
    o.push_back(Ozellik::sayi(
        "Min Yarıçap Eşiği", [this] { return (f64)radiusEsik; },
        [this](f64 v) { radiusEsik = (f32)v; bayat_ = true; }));
  }
  if (tip_ == AnalizTip::Kalinlik) {
    o.push_back(Ozellik::sayi(
        "İnce Eşik", [this] { return (f64)kalinlikInce; },
        [this](f64 v) { kalinlikInce = (f32)v; bayat_ = true; }));
  }
  if (tip_ == AnalizTip::Kurvatur) {
    o.push_back(Ozellik::sayi(
        "Egrilik Maks", [this] { return (f64)kurvaturMaks; },
        [this](f64 v) { kurvaturMaks = (f32)v; bayat_ = true; }));
  }
  if (tip_ == AnalizTip::Sureklilik) {
    o.push_back(Ozellik::sayi(
        "G1 Eşik (°)", [this] { return (f64)g1EsikDeg; },
        [this](f64 v) { g1EsikDeg = (f32)v; bayat_ = true; }));
  }
  if (tip_ == AnalizTip::KeskinKenar) {
    o.push_back(Ozellik::sayi(
        "Keskin Eşik (°)", [this] { return (f64)keskinEsikDeg; },
        [this](f64 v) { keskinEsikDeg = (f32)v; bayat_ = true; }));
  }
  if (tip_ == AnalizTip::Zebra || tip_ == AnalizTip::Reflect) {
    o.push_back(Ozellik::sayi(
        "Şerit Sayısı", [this] { return (f64)zebraSerit; },
        [this](f64 v) { zebraSerit = (f32)std::max(1.0, v); }));  // canli-GPU: bayat gerekmez
    o.push_back(Ozellik::sayi(
        "Faz (°)", [this] { return (f64)zebraAci; }, [this](f64 v) { zebraAci = (f32)v; }));
  }
  if (tip_ == AnalizTip::Radius || tip_ == AnalizTip::Kalinlik ||
      tip_ == AnalizTip::Kurvatur) {
    o.push_back(Ozellik::sayi(
        "Renk Rampası (0 jet/1 turbo/3 tolerans)", [this] { return (f64)rampaTip; },
        [this](f64 v) {  // canli-GPU push-constant: bayat gerekmez
          const int t = (int)v;
          rampaTip = (t == 0 || t == 3) ? t : 1;
        }));
  }
  return o;
}

}  // namespace fiko::analiz