#include "fiko/geometri/kalite.hpp"

#include <algorithm>
#include <cmath>
#include <cstring>

namespace fiko::geometri {

namespace {
// Log-uzayda enterpolasyon (sapma degerleri carpimsal → dogru his icin log-lerp).
f64 logLerp(f64 a, f64 b, f64 t) {
  return std::exp(std::log(a) + (std::log(b) - std::log(a)) * t);
}
// Seviye → (linOran, yuzAngRad, kenarAngRad). Dusuk→Ultra: acisal sapma
// kuculdukce egriler puruzsuzlesir (asil knob = acisal). Varsayilan Yuksek.
constexpr KaliteAyar SEVIYE[] = {
    {0.0100, 0.50, 0.50},  // Dusuk  — hizli onizleme
    {0.0040, 0.30, 0.25},  // Orta   — ~bugunku dogrusal, acisal iyilesir
    {0.0015, 0.15, 0.12},  // Yuksek — VARSAYILAN, puruzsuz
    {0.0006, 0.08, 0.06},  // Ultra  — render/ekran goruntusu
};
constexpr const char* AD[] = {"Düşük", "Orta", "Yüksek", "Ultra"};

KaliteAyar g_kalite = SEVIYE[(int)KaliteSeviye::Yuksek];
}  // namespace

KaliteAyar& kalite() { return g_kalite; }

void kaliteSeviyeAta(KaliteSeviye s) {
  const int i = (int)s;
  if (i >= 0 && i < 4) g_kalite = SEVIYE[i];
}

KaliteSeviye kaliteSeviye() {
  // linOran'a gore en yakin seviye (float esitlik toleransi).
  for (int i = 0; i < 4; ++i)
    if (g_kalite.linOran <= SEVIYE[i].linOran * 1.0001 &&
        g_kalite.linOran >= SEVIYE[i].linOran * 0.9999)
      return (KaliteSeviye)i;
  return KaliteSeviye::Yuksek;
}

const char* kaliteSeviyeAd(KaliteSeviye s) {
  const int i = (int)s;
  return (i >= 0 && i < 4) ? AD[i] : AD[(int)KaliteSeviye::Yuksek];
}

KaliteSeviye kaliteSeviyeCoz(const char* ad) {
  if (ad)
    for (int i = 0; i < 4; ++i)
      if (std::strcmp(ad, AD[i]) == 0) return (KaliteSeviye)i;
  return KaliteSeviye::Yuksek;
}

void kaliteFaktorAta(f64 t01) {
  const f64 t = std::clamp(t01, 0.0, 1.0);
  const KaliteAyar& lo = SEVIYE[(int)KaliteSeviye::Dusuk];  // t=0
  const KaliteAyar& hi = SEVIYE[(int)KaliteSeviye::Ultra];  // t=1
  g_kalite.linOran     = logLerp(lo.linOran, hi.linOran, t);
  g_kalite.yuzAngRad   = logLerp(lo.yuzAngRad, hi.yuzAngRad, t);
  g_kalite.kenarAngRad = logLerp(lo.kenarAngRad, hi.kenarAngRad, t);
}

f64 kaliteFaktor() {
  const f64 lo = SEVIYE[(int)KaliteSeviye::Dusuk].linOran;
  const f64 hi = SEVIYE[(int)KaliteSeviye::Ultra].linOran;
  const f64 t = (std::log(g_kalite.linOran) - std::log(lo)) / (std::log(hi) - std::log(lo));
  return std::clamp(t, 0.0, 1.0);
}

namespace { f64 g_kabaLodSapma = 0.015; }  // ~10× ince (Yüksek linOran 0.0015)
f64 kabaLodSapma() { return g_kabaLodSapma; }
void kabaLodSapmaAta(f64 v) { g_kabaLodSapma = std::clamp(v, 0.006, 0.05); }

namespace { bool g_sapmaKuantala = true; }
bool sapmaKuantala() { return g_sapmaKuantala; }
void sapmaKuantalaAta(bool v) { g_sapmaKuantala = v; }

namespace { f64 g_filletDenemeMs = 3000.0; }
f64 filletDenemeMs() { return g_filletDenemeMs; }
void filletDenemeMsAta(f64 v) { g_filletDenemeMs = std::clamp(v, 250.0, 60000.0); }

// 1000→20000 (07-13): eşik, birleştirme+remesh ANA thread'i kilitlerken konmuştu; artık
// OCCT+mesh async worker'da VE usdUcgenlemeTasi 1:1 yüzlerin üçgenlemesini koruyor.
// Düşük eşik uzatılan yan duvarı komşusuyla BİRLEŞTİRMEYİP yama görünümü bırakıyordu.
namespace { u32 g_usdYuzEsigi = 20000; }
u32 usdYuzEsigi() { return g_usdYuzEsigi; }
void usdYuzEsigiAta(u32 v) { g_usdYuzEsigi = std::clamp<u32>(v, 100, 1000000); }

}  // namespace fiko::geometri