#pragma once
#include <algorithm>
#include <atomic>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>

#include "fiko/core/mat/vec.hpp"
#include "fiko/kutuk/kutuk_motor.hpp"
#include "fiko/render/mesh_veri.hpp"

namespace fiko {

// Tek carve noktasi — worker'in ihtiyaci. HareketTuru/cam BAGIMLILIGI YOK: main
// thread snapshot'ta onceden cozer (TakimGeo + kesme bayragi). Boylece worker
// tamamen kendi kendine yeter, main-thread verisine (cam takim tablosu, g_prog)
// hic dokunmaz → veri yarisi yok.
struct KarveNokta {
  Vec3d p{};
  bool kesme = false;         // Isleme/Yaklasma → sweptUygula; degilse yalniz konum ilerlet
  kutuk::TakimGeo tg{};       // onceden cozulmus kesici geometri (takim-uzat dahil)
};

// ============================================================================
// KutukAsyncCarve — arka plan GERCEK ZAMANLI kutuk (talas kaldirma) carve'i.
// ----------------------------------------------------------------------------
// Kendi worker thread'i (isin_bvh/dokum async kalibi). Motor + grid'i SAHIPLENIR;
// yalniz worker thread'i dokunur. Main-thread hedef poz atar, worker oraya kadar
// zaman-butceli oyar, periyodik render MeshVeri (gri stok — worker uretir) posta
// kutusuna birakir. Main-thread her kare poll'lar → hazirMeshGuncelle (GPU upload).
// Sahne/Vulkan/olay ASLA worker'da (dokum async sozlesmesi; Vulkan submit main-only).
// ============================================================================
class KutukAsyncCarve {
 public:
  ~KutukAsyncCarve();

  // Motor sahipligini devral + nokta snapshot'i; worker baslar. kip yalniz log icin.
  void baslat(std::unique_ptr<kutuk::KutukSimMotoru> motor,
              std::vector<KarveNokta> noktalar, f32 batchMs, f32 meshMs, int kip);
  // Worker'i durdur + join (bloklar; kisa). Cagrilabilir tekrar (idempotent).
  void durdur();
  bool calisiyorMu() const { return calisiyor_; }

  // Worker buraya kadar oyar. ucPoz = interpolasyonlu takim ucu (cizgi uzerinde
  // kayarken point[poz]->ucPoz kismi swept islenir -> kutuk bosaltma ucu takip eder).
  // poz < oyulan (geri-scrub) -> worker en yakin checkpoint'ten geri yukler (O(1)),
  // 0'dan yeniden oymaz. kismiVar=false -> yalniz tam hamleler.
  void hedefAta(int poz, Vec3d ucPoz, bool kismiVar);
  void sifirlaVeHedef(int poz);  // HARD reset: grid sifirla + checkpoint temizle + yeniden oy
  void keskinAta(bool v);        // Dual Contouring (keskin mesh) aç/kapa — worker uygular + re-mesh

  // Hazir mesh varsa disari MOVE eder → true. Yoksa false (dokunmaz).
  bool meshDevral(MeshVeri& disari);
  f64 hacim() const { return hacim_.load(std::memory_order_relaxed); }
  int oyulanPoz() const { return oyulan_.load(std::memory_order_relaxed); }
  // ÖLÇÜM (Perf HUD; TAHMİN DEĞİL — gerçek-zaman darboğazı carve mi mesh mi?):
  // worker'ın son 1 sn'deki carve ve mesh-çıkarma toplam ms'si + saniyedeki hamle.
  f64 carveMsSn() const { return carveMsSn_.load(std::memory_order_relaxed); }
  f64 meshMsSn() const { return meshMsSn_.load(std::memory_order_relaxed); }
  f64 hamleSn() const { return hamleSn_.load(std::memory_order_relaxed); }
  int backlog() const {
    return std::max(0, hedef_.load(std::memory_order_relaxed) -
                           oyulan_.load(std::memory_order_relaxed));
  }

 private:
  void dongu();

  std::unique_ptr<kutuk::KutukSimMotoru> motor_;  // yalniz worker dokunur
  std::vector<KarveNokta> noktalar_;              // immutable snapshot (baslat sonrasi)
  std::thread isci_;
  bool calisiyor_ = false;
  int kip_ = 0;
  f32 batchMs_ = 5.0f;
  f32 meshMs_ = 100.0f;

  std::atomic<bool> dur_{false};
  std::atomic<int> hedef_{0};
  std::atomic<int> oyulan_{0};
  std::atomic<bool> sifirla_{false};
  std::atomic<bool> keskin_{false};  // DC (keskin) istegi — worker uygular
  std::atomic<f64> hacim_{0.0};

  // İnterpolasyon ucu (main yazar, worker okur; mutex — kare başı bir kez, ucuz).
  std::mutex ucKilit_;
  Vec3d ucPoz_{};
  bool ucVar_ = false;

  // Checkpoint ring (yalnız worker dokunur): poz→snapshot, artan sırada. Geri-scrub
  // undo erişemezse (jurnal taştı) fallback anchor. Bellek bütçeli (kaba, az sayıda).
  std::vector<std::pair<int, std::shared_ptr<void>>> kontroller_;
  int kontrolAralik_ = 0;   // kaç hamlede bir checkpoint (0 = devre dışı/desteksiz)
  size_t kontrolBellekBucesi_ = 384ull * 1024 * 1024;  // toplam snapshot tavanı

  // Undo token'ları (İNCE geri-scrub → anında): poz→undoIsaret(). Ucuz (16B); sık.
  // Geri-scrub'ta en yakın ≤ hedef token'a undoGeri → O(değişen voxel), kopya yok.
  std::vector<std::pair<int, u64>> undoTokenlar_;
  int undoAralik_ = 0;      // kaç hamlede bir token (0 = motor undo desteklemiyor)

  std::atomic<f64> carveMsSn_{0.0};  // ölçüm: son 1 sn carve toplam ms
  std::atomic<f64> meshMsSn_{0.0};   // ölçüm: son 1 sn mesh-çıkarma toplam ms
  std::atomic<f64> hamleSn_{0.0};    // ölçüm: son 1 sn işlenen hamle sayısı

  std::mutex meshKilit_;
  MeshVeri hazirMesh_;
  bool meshHazir_ = false;

  std::mutex uyanKilit_;
  std::condition_variable uyandir_;
};

}  // namespace fiko