#include "fiko/gsd/gsd_registry.hpp"

namespace fiko::gsd {

namespace {

// Kisa kurucu yardimcilari (okunabilirlik).
FeatureParam mesafe(std::string a, std::string e, f64 v, std::string birim = "mm",
                    parca::GorunurYordam g = {}) {
  FeatureParam p;
  p.anahtar = std::move(a);
  p.etiket = std::move(e);
  p.tip = ParamTip::Mesafe;
  p.varsayilan = v;
  p.minVeya = -1e9;  // negatif de gecerli (yon/ofset)
  p.adim = 0.1;
  p.birim = std::move(birim);
  p.gorunurMu = std::move(g);
  return p;
}
FeatureParam sayi(std::string a, std::string e, f64 v, f64 mn, f64 mx, f64 adim,
                  parca::GorunurYordam g = {}) {
  FeatureParam p;
  p.anahtar = std::move(a);
  p.etiket = std::move(e);
  p.tip = ParamTip::Sayi;
  p.varsayilan = v;
  p.minVeya = mn;
  p.maksVeya = mx;
  p.adim = adim;
  p.gorunurMu = std::move(g);
  return p;
}
FeatureParam secim(std::string a, std::string e, std::vector<std::string> sec) {
  FeatureParam p;
  p.anahtar = std::move(a);
  p.etiket = std::move(e);
  p.tip = ParamTip::Secim;
  p.varsayilan = 0;
  p.secenekler = std::move(sec);
  return p;
}
// Sahneden-seç nokta: taban ad (baz → bazx/bazy/bazz) + 🎯 buton + ince-ayar.
// varsayilanlar (vx/vy/vz) drag başlangıcı; pencere tık ile üzerine yazar.
FeatureParam sahneNokta(std::string baz, std::string e, f64 vx, f64 vy, f64 vz,
                        parca::GorunurYordam g = {}) {
  FeatureParam p;
  p.anahtar = std::move(baz);
  p.etiket = std::move(e);
  p.tip = ParamTip::SahneNokta;
  p.varsayilan = vx;
  p.minVeya = vy;   // SahneNokta'da Y varsayilanı taşır
  p.maksVeya = vz;  // SahneNokta'da Z varsayilanı taşır
  p.adim = 0.1;
  p.birim = "mm";
  p.gorunurMu = std::move(g);
  return p;
}

}  // namespace

const std::vector<FeatureTanim>& gsdTanimlari() {
  static const std::vector<FeatureTanim> tanimlar = [] {
    std::vector<FeatureTanim> t;

    // ---- WIREFRAME (grup = "GSD-Tel") ----

    // Nokta: sahneden tık (yüz üstü / kenar ucu / serbest) + ince-ayar XYZ.
    {
      FeatureTanim f;
      f.id = "nokta";
      f.ad = "Nokta";
      f.simge = "•";
      f.grup = "GSD-Tel";
      f.parametreler = {
          sahneNokta("p", "Nokta", 0.0, 0.0, 0.0),
      };
      t.push_back(std::move(f));
    }

    // Cizgi: iki-nokta (sahneden sırayla tık) / nokta-yon (baslangic + yon + uzunluk).
    {
      FeatureTanim f;
      f.id = "cizgi";
      f.ad = "Çizgi";
      f.simge = "╱";
      f.grup = "GSD-Tel";
      f.parametreler = {
          secim("cizgiTip", "Tür", {"İki Nokta", "Nokta-Yön"}),
          sahneNokta("a", "Başlangıç", 0.0, 0.0, 0.0),
          sahneNokta("b", "Bitiş", 10.0, 0.0, 0.0, modEsit("cizgiTip", 0)),
          mesafe("dx", "Yön X", 1.0, "", modEsit("cizgiTip", 1)),
          mesafe("dy", "Yön Y", 0.0, "", modEsit("cizgiTip", 1)),
          mesafe("dz", "Yön Z", 0.0, "", modEsit("cizgiTip", 1)),
          sayi("uzunluk", "Uzunluk", 10.0, 0.001, 0.0, 0.1, modEsit("cizgiTip", 1)),
      };
      t.push_back(std::move(f));
    }

    // Cember: merkez+R (merkez sahneden tık + R sayısal) / 3-nokta (3 tık).
    {
      FeatureTanim f;
      f.id = "cember";
      f.ad = "Çember";
      f.simge = "◯";
      f.grup = "GSD-Tel";
      f.parametreler = {
          secim("cemberTip", "Tür", {"Merkez + Yarıçap", "Üç Nokta"}),
          // Merkez + R
          sahneNokta("c", "Merkez", 0.0, 0.0, 0.0, modEsit("cemberTip", 0)),
          mesafe("nx", "Normal X", 0.0, "", modEsit("cemberTip", 0)),
          mesafe("ny", "Normal Y", 0.0, "", modEsit("cemberTip", 0)),
          mesafe("nz", "Normal Z", 1.0, "", modEsit("cemberTip", 0)),
          sayi("yaricap", "Yarıçap", 5.0, 0.001, 0.0, 0.1, modEsit("cemberTip", 0)),
          sayi("aci", "Açı (°)", 360.0, 1.0, 360.0, 1.0, modEsit("cemberTip", 0)),
          // Üç nokta
          sahneNokta("p1", "1. Nokta", 5.0, 0.0, 0.0, modEsit("cemberTip", 1)),
          sahneNokta("p2", "2. Nokta", 0.0, 5.0, 0.0, modEsit("cemberTip", 1)),
          sahneNokta("p3", "3. Nokta", -5.0, 0.0, 0.0, modEsit("cemberTip", 1)),
      };
      t.push_back(std::move(f));
    }

    // Spline: N kontrol noktasi (sahneden sırayla tık, Enter/çift-tık bitir).
    {
      FeatureTanim f;
      f.id = "spline";
      f.ad = "Spline";
      f.simge = "∿";
      f.grup = "GSD-Tel";
      // Nokta sayısı koşullu görünürlük ile her P<i> ancak i < sayı ise gösterilir.
      const auto pVarMi = [](int idx) {
        return [idx](const std::unordered_map<std::string, f64>& d) {
          const auto it = d.find("nokta");
          return it != d.end() && idx < (int)(it->second + 0.5);
        };
      };
      f.parametreler = {
          sayi("nokta", "Nokta Sayısı", 4, 2, 8, 1),
          sahneNokta("s0", "P0", 0.0, 0.0, 0.0, pVarMi(0)),
          sahneNokta("s1", "P1", 5.0, 5.0, 0.0, pVarMi(1)),
          sahneNokta("s2", "P2", 10.0, -3.0, 0.0, pVarMi(2)),
          sahneNokta("s3", "P3", 15.0, 4.0, 0.0, pVarMi(3)),
          sahneNokta("s4", "P4", 20.0, 0.0, 0.0, pVarMi(4)),
          sahneNokta("s5", "P5", 25.0, 5.0, 0.0, pVarMi(5)),
          sahneNokta("s6", "P6", 30.0, -2.0, 0.0, pVarMi(6)),
          sahneNokta("s7", "P7", 35.0, 3.0, 0.0, pVarMi(7)),
      };
      t.push_back(std::move(f));
    }

    // Polyline: N kontrol noktasi (duz segment zinciri) + kapali secenegi.
    {
      FeatureTanim f;
      f.id = "polyline";
      f.ad = "Polyline";
      f.simge = "⋀";
      f.grup = "GSD-Tel";
      const auto pVarMi = [](int idx) {
        return [idx](const std::unordered_map<std::string, f64>& d) {
          const auto it = d.find("nokta");
          return it != d.end() && idx < (int)(it->second + 0.5);
        };
      };
      f.parametreler = {
          sayi("nokta", "Nokta Sayısı", 4, 2, 12, 1),
          FeatureParam{"kapali", "Kapalı", ParamTip::Bayrak, 0, 0, 0, 0, "", {}, {}},
          sahneNokta("s0", "P0", 0.0, 0.0, 0.0, pVarMi(0)),
          sahneNokta("s1", "P1", 10.0, 0.0, 0.0, pVarMi(1)),
          sahneNokta("s2", "P2", 10.0, 10.0, 0.0, pVarMi(2)),
          sahneNokta("s3", "P3", 0.0, 10.0, 0.0, pVarMi(3)),
          sahneNokta("s4", "P4", -5.0, 5.0, 0.0, pVarMi(4)),
          sahneNokta("s5", "P5", 0.0, -5.0, 0.0, pVarMi(5)),
          sahneNokta("s6", "P6", 5.0, -8.0, 0.0, pVarMi(6)),
          sahneNokta("s7", "P7", 12.0, -3.0, 0.0, pVarMi(7)),
          sahneNokta("s8", "P8", 15.0, 5.0, 0.0, pVarMi(8)),
          sahneNokta("s9", "P9", 12.0, 12.0, 0.0, pVarMi(9)),
          sahneNokta("s10", "P10", 5.0, 15.0, 0.0, pVarMi(10)),
          sahneNokta("s11", "P11", -3.0, 12.0, 0.0, pVarMi(11)),
      };
      t.push_back(std::move(f));
    }

    // Helix: merkez + eksen (X/Y/Z) + yaricap + adim (pitch) + tur + sarim yonu.
    {
      FeatureTanim f;
      f.id = "helix";
      f.ad = "Helis";
      f.simge = "➰";
      f.grup = "GSD-Tel";
      f.parametreler = {
          sahneNokta("c", "Merkez", 0.0, 0.0, 0.0),
          secim("eksen", "Eksen", {"Z", "X", "Y"}),
          sayi("yaricap", "Yarıçap", 5.0, 0.001, 0.0, 0.1),
          sayi("adim", "Adım (pitch)", 5.0, 0.001, 0.0, 0.1),
          sayi("tur", "Tur", 3.0, 0.1, 100.0, 0.1),
          FeatureParam{"sol", "Sol Sarım", ParamTip::Bayrak, 0, 0, 0, 0, "", {}, {}},
      };
      t.push_back(std::move(f));
    }

    // Konik: 3 nokta (baslangic/omuz/bitis) + rho gerginligi (parabol/elips/hiperbol).
    {
      FeatureTanim f;
      f.id = "konik";
      f.ad = "Konik";
      f.simge = "◡";
      f.grup = "GSD-Tel";
      f.parametreler = {
          sahneNokta("p1", "Başlangıç", 0.0, 0.0, 0.0),
          sahneNokta("p2", "Omuz", 5.0, 8.0, 0.0),
          sahneNokta("p3", "Bitiş", 10.0, 0.0, 0.0),
          sayi("rho", "Gerginlik (rho)", 0.5, 0.02, 0.98, 0.01),
      };
      t.push_back(std::move(f));
    }

    // Kose: iki dogrunun kose noktasinda tegetsel yuvarlatma yayi.
    {
      FeatureTanim f;
      f.id = "kose";
      f.ad = "Köşe";
      f.simge = "⌒";
      f.grup = "GSD-Tel";
      f.parametreler = {
          sahneNokta("u1", "1. Uç", -10.0, 0.0, 0.0),
          sahneNokta("c", "Köşe", 0.0, 0.0, 0.0),
          sahneNokta("u2", "2. Uç", 0.0, 10.0, 0.0),
          sayi("yaricap", "Yarıçap", 2.0, 0.001, 0.0, 0.1),
      };
      t.push_back(std::move(f));
    }

    // ---- TEMEL YUZEY (grup = "GSD-Yuzey") — aktif sketch profili gerekli ----

    // Yuzey Extrude: sketch profilini normal boyunca uzat → acik shell.
    {
      FeatureTanim f;
      f.id = "yuzeyExtrude";
      f.ad = "Yüzey Extrude";
      f.simge = "▱";
      f.grup = "GSD-Yuzey";
      f.parametreler = {
          mesafe("mesafe", "Uzatma", 10.0),
          FeatureParam{"tersYon", "Yön Ters", ParamTip::Bayrak, 0, 0, 0, 0, "", {}, {}},
      };
      t.push_back(std::move(f));
    }

    // Yuzey Revolve: sketch profilini eksen etrafinda dondur → donel yuzey.
    {
      FeatureTanim f;
      f.id = "yuzeyRevolve";
      f.ad = "Yüzey Revolve";
      f.simge = "◗";
      f.grup = "GSD-Yuzey";
      f.parametreler = {
          sayi("aci", "Açı (°)", 360.0, 1.0, 360.0, 1.0),
          secim("eksen", "Eksen", {"X", "Y", "Z"}),
      };
      t.push_back(std::move(f));
    }

    // Yuzey Fill: kapali sketch profilini dolu yuzey ile kaplar (parametresiz).
    {
      FeatureTanim f;
      f.id = "yuzeyFill";
      f.ad = "Yüzey Fill";
      f.simge = "▰";
      f.grup = "GSD-Yuzey";
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // ---- YUZEY-UZERI OP (grup = "GSD-YuzeyOp") — kaynak GSD yuzey dugumu gerekli ----

    // Yuzey Offset: kaynak yuzeyi normal boyunca mesafe kadar paralel otele.
    {
      FeatureTanim f;
      f.id = "yuzeyOffset";
      f.ad = "Yüzey Offset";
      f.simge = "⇉";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {mesafe("mesafe", "Offset", 5.0)};
      t.push_back(std::move(f));
    }

    // Yuzey Extrapolate: kaynak yuzeyi dogal sinirlari boyunca uzat.
    {
      FeatureTanim f;
      f.id = "yuzeyExtrapolate";
      f.ad = "Yüzey Uzat";
      f.simge = "⤢";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {mesafe("mesafe", "Uzatma", 5.0)};
      t.push_back(std::move(f));
    }

    // Yuzey Thicken: kaynak acik yuzeyi kalinlik kadar sisir → KATI.
    {
      FeatureTanim f;
      f.id = "yuzeyThicken";
      f.ad = "Yüzey Kalınlaştır";
      f.simge = "▤";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {mesafe("kalinlik", "Kalınlık", 2.0)};
      t.push_back(std::move(f));
    }

    // Boundary: kaynak yuzeyin dis sinir telini cikar (sonuc TEL — geometriden belirlenir).
    {
      FeatureTanim f;
      f.id = "sinir";
      f.ad = "Yüzey Sınırı";
      f.simge = "◌";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Extract (Yuze Cikar): katinin bir yuzunu BAGIMSIZ GSD yuzeye kopyalar. Kaynak =
    // kati dugum; yuzOrd = kopyalanacak yuz ordinali (1-tabanli, secimden gelir).
    {
      FeatureTanim f;
      f.id = "yuzeyCikart";
      f.ad = "Yüzeye Çıkar";
      f.simge = "⧉";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {sayi("yuzOrd", "Yüz No", 1, 1, 100000, 1)};
      t.push_back(std::move(f));
    }

    // Yüzey Şişir/İndir (NURBS Inflate — Plasticity): kaynak yuzeyi hedef nokta cevresinde
    // yaricap etkisiyle normal boyunca miktar kadar yerel sisir(+)/indir(−).
    {
      FeatureTanim f;
      f.id = "yuzeySisir";
      f.ad = "Yüzey Şişir";
      f.simge = "◒";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {
          mesafe("miktar", "Miktar", 5.0),
          sayi("yaricap", "Etki Yarıçapı", 20.0, 0.1, 100000.0, 0.5),
          mesafe("hedefX", "Hedef X", 0.0),
          mesafe("hedefY", "Hedef Y", 0.0),
          mesafe("hedefZ", "Hedef Z", 0.0),
      };
      t.push_back(std::move(f));
    }

    // Yüzey Düzelt/Yumuşat (Smooth — Plasticity relax): ic pole'lari komsu ortalamasina
    // dogru kaydir (kubbe/puruz yumusar).
    {
      FeatureTanim f;
      f.id = "yuzeyDuzelt";
      f.ad = "Yüzey Yumuşat";
      f.simge = "≈";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {
          sayi("miktar", "Güç", 0.5, 0.0, 1.0, 0.05),
          sayi("iterasyon", "Tekrar", 3, 1, 50, 1),
      };
      t.push_back(std::move(f));
    }

    // Kenar Extrude (tek-kenar uzat): kaynak yuzeyin/telin TEK kenarini (kenarOrd) yon
    // boyunca supur → yeni strip yuzey. Gizmo kenardan tutup cekince.
    {
      FeatureTanim f;
      f.id = "kenarExtrude";
      f.ad = "Kenar Uzat";
      f.simge = "↦";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {
          sayi("kenarOrd", "Kenar No", 1, 1, 100000, 1),
          mesafe("mesafe", "Uzatma", 10.0),
          mesafe("yonX", "Yön X", 0.0),
          mesafe("yonY", "Yön Y", 0.0),
          mesafe("yonZ", "Yön Z", 0.0),
      };
      t.push_back(std::move(f));
    }

    // Tel Extrude: GSD teli (wire/edge) yon boyunca supur → yuzey. yon 0 ise tel'in
    // duzlem normali kullanilir (gizmo yon param'larini doldurur).
    {
      FeatureTanim f;
      f.id = "telExtrude";
      f.ad = "Tel Extrude";
      f.simge = "⇑";
      f.grup = "GSD-YuzeyOp";  // kaynak GSD Tel (seciliGsdTel fallback)
      f.parametreler = {
          mesafe("mesafe", "Uzatma", 10.0),
          mesafe("yonX", "Yön X", 0.0),
          mesafe("yonY", "Yön Y", 0.0),
          mesafe("yonZ", "Yön Z", 0.0),
      };
      t.push_back(std::move(f));
    }

    // Heal: kaynak yuzeyi/govdeyi ShapeFix ile onar (tolerans/oryantasyon/bosluk).
    {
      FeatureTanim f;
      f.id = "onar";
      f.ad = "Onar (Heal)";
      f.simge = "✚";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {sayi("tol", "Tolerans", 0.01, 1e-5, 10.0, 0.001)};
      t.push_back(std::move(f));
    }

    // Concatenate: cok-kenarli GSD telin kenarlarini tek B-spline egriye birlestir.
    {
      FeatureTanim f;
      f.id = "birlestir";
      f.ad = "Eğri Birleştir";
      f.simge = "⌇";
      f.grup = "GSD-YuzeyOp";  // kaynak tek GSD ogesi (Tel); fallback seciliGsdTel
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Bridge: iki kenar/tel arasina puruzsuz kopru yuzeyi (Plasticity bridge).
    {
      FeatureTanim f;
      f.id = "koprule";
      f.ad = "Köprüle";
      f.simge = "◠";
      f.grup = "GSD-2Kaynak";
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Sweep: profil teli (1. seçili) yol teli (2. seçili) boyunca süpürülür → açık yüzey.
    {
      FeatureTanim f;
      f.id = "supurmeYuzey";
      f.ad = "Süpürme Yüzey";
      f.simge = "⇝";
      f.grup = "GSD-2Kaynak";
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Loft (çok-kesitli yüzey): sıralı seçili teller (2+) ardışık geçirilir → açık shell.
    {
      FeatureTanim f;
      f.id = "loftYuzey";
      f.ad = "Loft Yüzey";
      f.simge = "⧢";
      f.grup = "GSD-2Kaynak";  // ilk 2 kesit zorunlu; 3+ ekKaynaklar ile
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Kılavuzlu Loft (Loft+Spine): kesit telleri KILAVUZ omurga boyunca geçirilir.
    // kaynak = KILAVUZ tel, kaynak2 = ilk kesit, ekKaynaklar = diğer kesitler.
    {
      FeatureTanim f;
      f.id = "loftKilavuz";
      f.ad = "Kılavuzlu Loft";
      f.simge = "⤳";
      f.grup = "GSD-2Kaynak";
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Trim (yüzey kırp/böl): kaynak yüzeyi kesici (2. seçili yüzey/eğri) ile parçalara böler.
    {
      FeatureTanim f;
      f.id = "yuzeyKirp";
      f.ad = "Yüzey Kırp";
      f.simge = "✂";
      f.grup = "GSD-2Kaynak";
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Yama (N-kenarlı patch): seçili sınır kenarlarından (kapalı tel ya da 3+ kenar) pürüzsüz yüzey.
    {
      FeatureTanim f;
      f.id = "yamaYuzey";
      f.ad = "Yama Yüzey";
      f.simge = "▨";
      f.grup = "GSD-YuzeyOp";  // 1+ kaynak (kapalı tel); 3+ kenar ekKaynaklar ile
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Kenar Kaydır (Edge Push/Pull): yüzeyin bir sınır kenarını vec kadar taşı → pürüzsüz reshape.
    {
      FeatureTanim f;
      f.id = "kenarKaydir";
      f.ad = "Kenar Kaydır";
      f.simge = "⇔";
      f.grup = "GSD-YuzeyOp";  // kaynak = yüzey; knx/kny/knz = kenar noktası, vx/vy/vz = yön×mesafe
      f.parametreler = {
          mesafe("knx", "Kenar X", 0.0), mesafe("kny", "Kenar Y", 0.0), mesafe("knz", "Kenar Z", 0.0),
          mesafe("vx", "Yön X", 0.0), mesafe("vy", "Yön Y", 0.0), mesafe("vz", "Yön Z", 5.0),
      };
      t.push_back(std::move(f));
    }

    // Intersection: iki kaynak govdenin kesisim EGRISI (Tel — geometriden belirlenir).
    {
      FeatureTanim f;
      f.id = "kesisimEgri";
      f.ad = "Kesişim Eğrisi";
      f.simge = "✕";
      f.grup = "GSD-2Kaynak";
      f.parametreler = {};
      t.push_back(std::move(f));
    }

    // Affinity: kaynak geometriyi eksen-bagimsiz (non-uniform) olcekle.
    {
      FeatureTanim f;
      f.id = "afin";
      f.ad = "Afin (Non-uniform)";
      f.simge = "⤡";
      f.grup = "GSD-YuzeyOp";
      f.parametreler = {
          sayi("oranX", "X Oran", 1.0, -10.0, 10.0, 0.05),
          sayi("oranY", "Y Oran", 1.0, -10.0, 10.0, 0.05),
          sayi("oranZ", "Z Oran", 1.0, -10.0, 10.0, 0.05),
      };
      t.push_back(std::move(f));
    }

    return t;
  }();
  return tanimlar;
}

const FeatureTanim* gsdTanimBul(const std::string& id) {
  for (const FeatureTanim& t : gsdTanimlari())
    if (t.id == id) return &t;
  return nullptr;
}

bool gsdTelMi(const FeatureTanim& t) { return t.grup == "GSD-Tel"; }

bool gsdKaynakYuzeyMi(const FeatureTanim& t) { return t.grup == "GSD-YuzeyOp"; }

bool gsdIkiKaynakMi(const FeatureTanim& t) { return t.grup == "GSD-2Kaynak"; }

}  // namespace fiko::gsd