#include "fiko/sahne/geometri_nesne.hpp"

#include <algorithm>
#include <cstdio>
#include <numbers>
#include <string>

namespace fiko {

// ---- GeometriNesnesi ----

std::string GeometriNesnesi::ad() const {
  const Dugum* d = dugum();
  return d ? d->ad : std::string();
}

void GeometriNesnesi::adAyarla(const std::string& yeni) {
  if (Dugum* d = dugum()) d->ad = yeni;
}

OzellikSeti GeometriNesnesi::ozellikler(Dunya& dunya) {
  OzellikSeti s;
  const Varlik k = kimlik_;
  Dugum* d = dunya.bul<Dugum>(k);
  if (!d) return s;

  // Konum (Vektor) — mesh yeniden inşa gerektirmez (yalnız matris)
  Ozellik konum;
  konum.ad = "Konum";
  konum.tur = Ozellik::Tur::Vektor;
  konum.vektorOku = [&dunya, k] {
    Dugum* d = dunya.bul<Dugum>(k);
    return d ? Vec3f{(f32)d->donusum.konum.x, (f32)d->donusum.konum.y,
                     (f32)d->donusum.konum.z}
             : Vec3f{};
  };
  konum.vektorYaz = [&dunya, k](Vec3f v) {
    if (Dugum* d = dunya.bul<Dugum>(k))
      d->donusum.konum = {(f64)v.x, (f64)v.y, (f64)v.z};
  };
  s.push_back(std::move(konum));

  // Dönüş Z (Sayi) — matris, yeniden inşa yok
  s.push_back(Ozellik::sayi(
      "Dönüş Z",
      [&dunya, k] { Dugum* d = dunya.bul<Dugum>(k); return d ? (f64)d->aciZDerece : 0.0; },
      [&dunya, k](f64 v) {
        if (Dugum* d = dunya.bul<Dugum>(k)) {
          d->aciZDerece = (f32)v;
          d->donusum.yonelim =
              Quatd::eksenAci({0, 0, 1}, v * std::numbers::pi / 180.0);
        }
      }));

  // Boyut parametreleri (tipe göre) — yeniden inşa GEREKİR
  auto boyut = [&](const char* ad, f32 Dugum::*alan) {
    return Ozellik::sayi(
        ad,
        [&dunya, k, alan] { Dugum* d = dunya.bul<Dugum>(k); return d ? (f64)(d->*alan) : 0.0; },
        [&dunya, k, alan](f64 v) {
          if (Dugum* d = dunya.bul<Dugum>(k)) { d->*alan = (f32)v; d->yenidenInsaGerek = true; }
        });
  };
  switch (d->tip) {
    case DugumTip::Kutu:
      s.push_back(boyut("Genişlik", &Dugum::p1));
      s.push_back(boyut("Derinlik", &Dugum::p2));
      s.push_back(boyut("Yükseklik", &Dugum::p3));
      break;
    case DugumTip::Silindir:
    case DugumTip::Koni:
      s.push_back(boyut("Yarıçap", &Dugum::p1));
      s.push_back(boyut("Yükseklik", &Dugum::p3));
      break;
    case DugumTip::Kure:
      s.push_back(boyut("Yarıçap", &Dugum::p1));
      break;
    default:
      break;
  }

  // Renk (Renk) — mesh vertex renklerine gömülü → yeniden inşa GEREKİR
  Ozellik renk = Ozellik::renk(
      "Renk",
      [&dunya, k] { Dugum* d = dunya.bul<Dugum>(k); return d ? d->renk : Vec3f{}; },
      [&dunya, k](Vec3f c) {
        if (Dugum* d = dunya.bul<Dugum>(k)) { d->renk = c; d->yenidenInsaGerek = true; }
      });
  s.push_back(std::move(renk));

  // Görünür (Bayrak)
  s.push_back(Ozellik::bayrak(
      "Görünür",
      [&dunya, k] { Dugum* d = dunya.bul<Dugum>(k); return d ? d->gorunur : false; },
      [&dunya, k](bool g) { if (Dugum* d = dunya.bul<Dugum>(k)) d->gorunur = g; }));

  // Saydamlık (1 = opak; <1 hayalet — saydam geçişte blend ile çizilir)
  s.push_back(Ozellik::sayi(
      "Saydamlık",
      [&dunya, k] { Dugum* d = dunya.bul<Dugum>(k); return d ? (f64)d->saydamlik : 1.0; },
      [&dunya, k](f64 v) {
        if (Dugum* d = dunya.bul<Dugum>(k))
          d->saydamlik = (f32)std::clamp(v, 0.05, 1.0);
      }));

  // Hacim / Alan (salt okunur)
  Ozellik hacim = Ozellik::sayi(
      "Hacim", [&dunya, k] { Dugum* d = dunya.bul<Dugum>(k); return d ? d->hacim : 0.0; }, nullptr);
  hacim.saltOkunur = true;
  s.push_back(std::move(hacim));
  Ozellik alan = Ozellik::sayi(
      "Alan", [&dunya, k] { Dugum* d = dunya.bul<Dugum>(k); return d ? d->alan : 0.0; }, nullptr);
  alan.saltOkunur = true;
  s.push_back(std::move(alan));

  return s;
}

// ---- GeometriGorunum ----

bool GeometriGorunum::gorunur() const {
  const Dugum* d = dugum();
  return d ? d->gorunur : false;
}

void GeometriGorunum::gorunurAyarla(bool g) {
  if (Dugum* d = dugum()) d->gorunur = g;
}

const char* GeometriGorunum::agacSimgesi() const {
  // Primitif + boolean (Kutu..Ithal) simgeleri; GSD Tel/Yüzey ayrı işaretlenir.
  static const char* simgeler[] = {"◼", "▮", "●", "▲", "∪", "∖", "∩", "▣"};
  const Dugum* d = dugum();
  if (!d) return "▪";
  if (d->tip == DugumTip::Tel) return "〜";     // GSD wireframe
  if (d->tip == DugumTip::Yuzey) return "▱";    // GSD açık yüzey
  const int i = (int)d->tip;
  return (i >= 0 && i < 8) ? simgeler[i] : "▪";
}

Vec3f GeometriGorunum::agacRengi() const {
  const Dugum* d = dugum();
  return d ? d->renk : Vec3f{0.6f, 0.6f, 0.6f};
}

Arketip GeometriGorunum::agacArketip() const {
  const Dugum* d = dugum();
  if (!d) return Arketip::Govde;
  switch (d->tip) {
    case DugumTip::Tel: return Arketip::Tel;
    case DugumTip::Yuzey: return Arketip::Yuzey;
    case DugumTip::Duzlem:
    case DugumTip::Eksen:
    case DugumTip::EksenSistemi:
    case DugumTip::Nokta:
    case DugumTip::Cizgi: return Arketip::Datum;
    default: return Arketip::Govde;
  }
}

std::string GeometriGorunum::agacMiniBilgi(Dunya&) const {
  const Dugum* d = dugum();
  if (!d) return {};
  if (d->hacim > 1e-9) {  // precomputed (BRep yeniden-walk YOK → sıcak yolda ucuz)
    char buf[48];
    if (d->hacim >= 1000.0) std::snprintf(buf, sizeof buf, "%.1f cm³", d->hacim / 1000.0);
    else std::snprintf(buf, sizeof buf, "%.0f mm³", d->hacim);
    return buf;
  }
  if (d->indeksSayi >= 3) return std::to_string(d->indeksSayi / 3) + " üçgen";
  return {};
}

}  // namespace fiko