#pragma once
// ── SurecKopru — süreçler-arası MERKEZİ SÜREÇ YÖNETİCİSİ (IPC) ──────────────
// "Yeni Belge" = ayrı fikocad.exe süreci olduğundan, tüm örnekler tek merkezden
// komut/olay alışverişi yapar (görev yöneticisi + merkezi takip). Her süreç:
//   • açılışta paylaşılan kayıt dosyasına kendini yazar (PID + belge + durum + heartbeat)
//   • kendi named-pipe GELEN-KUTUSU'nu açar (arka iplik) → gelen çerçeveleri ayrıştırır
//   • ana iplik her kare drain() ile komut/kapat kuyruğunu + gelen olayları boşaltır
//   • periyodik heartbeat ile kaydına belge adı/durum/uptime/bellek yazar (canlılık)
//   • dashboard açıksa diğer süreçlere OlayAbone yollar; aboneli süreçler olaylarını
//     delta+batch+throttle ile merkeze forward eder → merkez SurecOlayAlindi re-publish.
//
// PROTOKOL: tip-çerçeveli, uzunluk-önekli binary (SurecCerceve). Eski "komut\t<ad>"
// metin biçimiyle GERİ-UYUMLU (sihir baytı yoksa Komut çerçevesi sayılır). Her süreç
// hem gönderen hem alıcı: komut merkez→süreç, Olay/Onay süreç→merkez — çift-yönlü akış
// her sürecin kendi GELEN-KUTUSU (INBOUND pipe) üzerinden (aktör modeli; duplex gerekmez).
//
// Çerçeve serialize/deserialize + parametre ayrıştırma SAF (Win32/olay bağımsız) →
// birim-test edilebilir (bkz. test/test_surec_kopru.cpp).
#include <cstdint>
#include <mutex>
#include <string>
#include <thread>
#include <utility>
#include <vector>

#include "fiko/orkestra/protokol.hpp"  // SurecMesajTip/SurecCerceve/surecproto (motor'a TAŞINDI)

namespace fiko {

class OlayGunlugu;  // forward: olay.hpp yalnız .cpp'de (header Win32/olay-nötr kalır)

// ── Süreç durumu (kayıt + SurecDurumDegisti olayı ile paylaşılır). ───────────
enum class SurecDurum : uint32_t { Aktif = 0, Mesgul = 1, Yanitsiz = 2 };

// ── Ana-iplik dispatch birimi (komut/parametre/kapat) — drain çıktısı. ───────
struct IpcKomut {
  SurecMesajTip tip = SurecMesajTip::Komut;
  std::string ad;                                              // komut adı
  std::vector<std::pair<std::string, std::string>> parametreler;
  uint32_t kaynakPid = 0;
  uint64_t korelasyon = 0;
  bool zorla = false;  // Kapat: zorla mı (nazik değil)
};

// ── Onay (süreç→çağıran): korelasyonlu SONUÇ. İstek/yanıt (sorgu) akışının
//    taşıyıcısı — MCP sunucusu "makro çalıştır" gibi araçların çıktısını buradan
//    okur. Gövde: [u8 basarili][str sonuc]. ─────────────────────────────────
struct IpcOnay {
  uint32_t kaynakPid = 0;   // yanıtı üreten süreç
  uint64_t korelasyon = 0;  // isteğin korelasyon numarası
  bool basarili = false;
  std::string sonuc;        // metin çıktı (hata mesajı ya da makro çıktısı)
};

// ── Forward edilmiş tek olay (OlayKaydi aynası; header olay-nötr kalsın diye
//    POD kopyası). Merkez bunu SurecOlayAlindi olarak re-publish eder. ─────────
struct ForwardOlay {
  uint32_t kaynakPid = 0;
  uint16_t tur = 0;    // OlayTuru (u16)
  uint32_t varlik = 0;
  double zaman = 0.0;
  uint64_t sira = 0;
  char ozet[48] = {};
};

// ── Canlı süreç bilgisi (kayıt dosyasından; ölü/yanıtsız tespitli). ──────────
struct SurecBilgi {
  uint32_t pid = 0;
  std::string belge = "Adsız";  // aktif belge adı (statik başlık yerine)
  uint64_t baslatUnix = 0;      // süreç kayda katılma anı (uptime = simdi - bu)
  SurecDurum durum = SurecDurum::Aktif;
  uint64_t sonHeartbeatUnix = 0;
  uint32_t bellekKB = 0;
};

// (SAF SERİLEŞTİRME surecproto → fiko/orkestra/protokol.hpp'ye TAŞINDI;
//  isimler fiko:: altında aynen — çağrı yerleri değişmedi.)

class SurecKopru {
 public:
  ~SurecKopru() { durdur(); }

  // Bu süreci kaydet + gelen-kutusu sunucusunu başlat (arka iplik).
  // baslik = ilk belge adı; anaMi = bu süreç ilk/ana açılan mı (guard için).
  void baslat(const std::string& baslik, bool anaMi = true);
  void durdur();

  // ---- Ana iplik: kare-başına çağrılan drain'ler ----
  // Gelen komut/parametre/kapat çerçevelerini al (kuyruğu boşaltır).
  std::vector<IpcKomut> beklemedekiCerceveler();
  // Geri-uyum: yalnız komut adlarını döner (Komut/Parametre çerçeveleri).
  std::vector<std::string> beklemedekiKomutlar();
  // Merkeze forward edilmiş olayları al (SurecOlayAlindi re-publish için).
  std::vector<ForwardOlay> beklemedekiOlaylar();
  // Gelen Onay (korelasyonlu sonuç) çerçevelerini al — istek/yanıt akışı.
  std::vector<IpcOnay> beklemedekiOnaylar();

  // Kendi durum alanlarını ayarla (dosya aç/kaydet → belge adı; meşgul → durum).
  void belgeAdiAyarla(const std::string& ad);
  void durumAyarla(SurecDurum durum);
  const std::string& belgeAdi() const { return belgeAdi_; }

  // Periyodik heartbeat: kendi kayıt satırını tazele (belge/durum/uptime/bellek).
  // Her kare çağrılabilir; içeride ~1 sn throttle (ayarlı belge adı + durumu yazar).
  void kalpAt();

  // Dashboard açık: aboneli süreçlerin olaylarını merkeze forward et (delta+batch+throttle).
  // Her kare çağrılabilir; içeride ~250 ms throttle. glog = bu sürecin olay günlüğü.
  void olaylariForwardEt(OlayGunlugu& glog);

  // Dashboard: bu süreci olay-merkezi ilan et (diğer süreçlere OlayAbone yolla).
  // Her kare çağrılabilir; içeride ~2 sn throttle (yeni süreçler de yakalanır). acik=false → iptal.
  void olayAboneligiYayinla(bool acik);

  // ---- Süreç listesi ----
  std::vector<SurecBilgi> surecler() const;

  // ---- Gönderim ----
  bool gonder(uint32_t pid, const std::string& komutAd) const;  // Komut çerçevesi
  bool gonder(uint32_t pid, const std::string& komutAd,
              const std::vector<std::pair<std::string, std::string>>& parametreler) const;
  int hepsineGonder(const std::string& komutAd) const;  // kendi hariç; dönen: ulaşan
  int hepsineGonder(const std::string& komutAd,
                    const std::vector<std::pair<std::string, std::string>>& parametreler) const;
  // Korelasyonlu parametreli gönderim (yanıt bekleyen istek). Korelasyon numarası
  // çağıran tarafından üretilir ve Onay çerçevesinde aynen geri döner.
  bool gonderKorelasyonlu(uint32_t pid, const std::string& komutAd,
                          const std::vector<std::pair<std::string, std::string>>& parametreler,
                          uint64_t korelasyon) const;
  // Onay (sonuç) gönder — isteği alan süreç, isteyene yanıt yollar.
  bool onayGonder(uint32_t hedefPid, uint64_t korelasyon, bool basarili,
                  const std::string& sonuc) const;

  // ---- Sonlandırma (güvenlik guard'lı) ----
  // Nazik: hedefe Kapat çerçevesi yollar (süreç kaydet-sor → WM_CLOSE). zorla=true →
  // OpenProcess+TerminateProcess. Guard: hedef kayıtta+fikocad pipe'ı var+kendisi değil.
  bool sonlandir(uint32_t pid, bool zorla) const;

  uint32_t benimPid() const { return benimPid_; }
  bool anaMi() const { return anaMi_; }

 private:
  void sunucuDongusu();  // arka iplik: pipe accept + çerçeve ayrıştır → kuyruk/olay/abone
  bool gonderCerceve(uint32_t pid, const SurecCerceve& c) const;
  void heartbeatYaz(const std::string& belge, SurecDurum durum);  // kayıt satırı tazele

  uint32_t benimPid_ = 0;
  bool anaMi_ = true;
  std::string baslik_;
  std::string belgeAdi_ = "Adsız";      // güncel belge adı (dosya_islemleri set eder)
  SurecDurum durumSelf_ = SurecDurum::Aktif;
  uint64_t baslatUnix_ = 0;
  std::thread sunucu_;
  volatile bool calisiyor_ = false;
  void* pipeIptal_ = nullptr;  // sunucu iplik iptal event'i (HANDLE)

  // Heartbeat/forward/abone throttle imleçleri (ana iplik).
  uint64_t sonHeartbeatMs_ = 0;
  uint64_t sonForwardMs_ = 0;
  uint64_t sonAboneMs_ = 0;
  uint64_t sonForwardSira_ = 0;  // OlayGunlugu delta imleci

  // Bu süreci dinleyen merkez (dashboard) — arka iplikte set, ana iplikte oku.
  volatile uint32_t merkezPid_ = 0;
  volatile uint64_t merkezAboneMs_ = 0;  // son OlayAbone anı (TTL için)

  mutable std::mutex kilit_;
  std::vector<IpcKomut> kuyruk_;         // gelen komut/kapat (main-thread drain)
  std::vector<ForwardOlay> gelenOlaylar_;  // merkeze ulaşan forward olaylar
  std::vector<IpcOnay> gelenOnaylar_;      // korelasyonlu sonuç yanıtları (istek/yanıt)
};

}  // namespace fiko