#include "fiko/parca/feature.hpp"

#include <algorithm>
#include <cstdio>
#include <map>
#include <string>

#include "fiko/parametre/depo.hpp"
#include "fiko/parametre/ifade.hpp"
#include "fiko/parca/feature_registry.hpp"
#include "fiko/parca/part_design_sistemi.hpp"
#include "fiko/sahne/sahne.hpp"

namespace fiko::parca {

void Feature::hesapla(Dunya& dunya, OlayGunlugu& gunluk) {
  (void)dunya;
  (void)gunluk;
  if (bastirildi_) return;  // Suppress: devre dışı → recompute'ta B-rep üretilmez.
  // Rollback: geri-sar noktasından sonraki feature → recompute'ta atlanır (Suppress'ten
  // bağımsız; ikisi de devre dışı olabilir). Sonuç gizleme rollbackAyarla'da yapılır.
  if (sistem_ && !sistem_->featureAktifMi(kimlik())) return;
  // RecomputeMotor DAG: sketch/parametre degisince tetiklenir → B-rep yeniden uret.
  if (sistem_) sistem_->yenidenInsa(*this);
}

f64 Feature::pEfektif(const std::string& anahtar, const parametre::ParametreDeposu& depo,
                      f64 varsayilan) const {
  const auto it = formuller_.find(anahtar);
  if (it == formuller_.end() || it->second.empty()) return p(anahtar, varsayilan);
  // Depo çözülmüş değerleri → ifade değişken tablosu (ad → deger).
  std::map<std::string, f64> degiskenler;
  for (const parametre::Parametre& pr : depo.hepsi()) degiskenler[pr.ad] = pr.deger;
  const parametre::IfadeSonuc s = parametre::hesapla(it->second, degiskenler);
  return s.basarili ? s.deger : p(anahtar, varsayilan);  // formül hatalı → sabit değere düş
}

std::vector<Varlik> Feature::bagimliliklar() const {
  std::vector<Varlik> dep;
  if (sketch_ != 0) dep.push_back(sketch_);
  if (sistem_ && !formuller_.empty()) {
    Sahne& s = sistem_->sahne();
    for (const auto& [anahtar, ifade] : formuller_) {
      if (ifade.empty()) continue;
      for (const std::string& ad : parametre::bagimliliklar(ifade))
        if (const u32 pv = s.parametreVarlik(ad))
          if (std::find(dep.begin(), dep.end(), pv) == dep.end()) dep.push_back(pv);
    }
  }
  return dep;
}

OzellikSeti Feature::ozellikler(Dunya& dunya) {
  (void)dunya;
  const FeatureTanim* td = featureTanimBul(tip_);
  OzellikSeti set;
  set.push_back(Ozellik::metin(
      "Tip", [this] { return tip_; }, [](const std::string&) {}));
  if (!td) return set;
  for (const FeatureParam& fp : td->parametreler) {
    const std::string anahtar = fp.anahtar;
    if (fp.tip == ParamTip::Bayrak) {
      set.push_back(Ozellik::bayrak(
          fp.etiket, [this, anahtar] { return this->p(anahtar) > 0.5; },
          [this, anahtar](bool v) { pAyarla(anahtar, v ? 1.0 : 0.0); }));
    } else {
      set.push_back(Ozellik::sayi(
          fp.etiket, [this, anahtar] { return this->p(anahtar); },
          [this, anahtar](f64 v) { pAyarla(anahtar, v); }));
    }
  }
  return set;
}

bool FeatureGorunum::gorunur() const {
  if (!sistem_) return true;
  // Gorunurluk sonuc dugumunden okunur (feature'in gorsel temsili).
  auto* nesne = const_cast<PartDesignSistemi*>(sistem_)->bul(kimlik_);
  if (!nesne) return true;
  const u32 d = nesne->sonucDugum();
  if (Dugum* dg = const_cast<PartDesignSistemi*>(sistem_)->sahne().bul(d)) return dg->gorunur;
  return true;
}

void FeatureGorunum::gorunurAyarla(bool g) {
  if (!sistem_) return;
  auto* nesne = sistem_->bul(kimlik_);
  if (!nesne) return;
  if (Dugum* dg = sistem_->sahne().bul(nesne->sonucDugum())) dg->gorunur = g;
}

Durum FeatureGorunum::agacDurum() const {
  if (!sistem_) return Durum::Normal;
  auto* sis = const_cast<PartDesignSistemi*>(sistem_);
  Feature* f = sis->bul(kimlik_);
  if (f && f->bastirildi()) return Durum::Bastik;          // Suppress rozeti (soluk/gri)
  if (!sis->featureAktifMi(kimlik_)) return Durum::Bastik;  // rollback sonrası → soluk
  return (f && !f->hata().empty()) ? Durum::Hata : Durum::Normal;
}

void FeatureGorunum::agacRozetleri(Dunya&, std::vector<AgacRozet>& out) const {
  if (!sistem_) return;
  // Rollback noktası feature'ında ⏪ rozeti (buradan sonrakiler devre dışı).
  if (const_cast<PartDesignSistemi*>(sistem_)->rollbackNoktasi() == kimlik_)
    out.push_back(AgacRozet{"", "⏪", agacRenk(255, 170, 60), true});
}

std::string FeatureGorunum::agacMiniBilgi(Dunya&) const {
  if (!sistem_) return {};
  Feature* f = const_cast<PartDesignSistemi*>(sistem_)->bul(kimlik_);
  if (!f) return {};
  if (!f->hata().empty()) return f->hata();  // hatalı feature → satırda sebep (kırmızı ⚠ yanında)
  const FeatureTanim* td = featureTanimBul(f->tip());
  if (!td) return {};
  for (const FeatureParam& fp : td->parametreler)  // ilk boyutsal param = ana ölçü
    if (fp.tip == ParamTip::Mesafe) {
      char buf[56];
      std::snprintf(buf, sizeof buf, "%.4g %s", f->p(fp.anahtar), fp.birim.c_str());
      std::string s = buf;
      while (!s.empty() && s.back() == ' ') s.pop_back();
      return s;
    }
  return {};
}

}  // namespace fiko::parca