#pragma once
// ── OrkestraKule — Fiko Orchestrator'ın uygulama tarafı köprüsü (yerel temel) ──
// NodeKayitDefteri'ni (motor/orkestra) YEREL makinenin ilanıyla besler ve defter
// diff'lerini OlayGunlugu'na NodeKatildi/NodeAyrildi/NodeDurumDegisti olarak
// yayınlar. Süreç yöneticisi paneli KAPALIYKEN tek karşılaştırmayla döner (sıcak
// yola iş eklemez); açıkken orkestra.tazele_ms throttle'ıyla süreç kaydını okur.
// LAN/WAN taşıma sürücüleri ileride AYNI defteri uzak ilanlarla besleyecek
// (bkz. docs/fiko_orchestrator_tasarim.md §2-3).
#include <cstdint>
#include <memory>
#include <string>

#include <vector>

#include <unordered_map>

#include "fiko/orkestra/akis.hpp"
#include "fiko/orkestra/dosya_transfer.hpp"
#include "fiko/orkestra/eslesme.hpp"
#include "fiko/orkestra/node_kayit.hpp"
#include "fiko/orkestra/task.hpp"
#include "fiko/orkestra/tasima_lan.hpp"
#include "orkestra_metrik.hpp"
#include "orkestra_soket_win.hpp"
#include "orkestra_tcp_win.hpp"

namespace fiko {

class OlayGunlugu;
class SurecKopru;

// AyarSistemi köprüleri (ayar_kayitlari.cpp tanımlar: orkestra.* kayıtları).
uint64_t orkestraYanitsizEsikMs();
uint64_t orkestraOfflineEsikMs();
uint64_t orkestraTazelemeMs();
bool orkestraLanKesif();
uint16_t orkestraLanPort();
uint64_t orkestraBeaconSn();
uint64_t orkestraMetrikAralikMs();
uint16_t orkestraTcpPort();
uint32_t orkestraTcpMaksBaglanti();
uint64_t orkestraTcpMaksGovdeMB();
uint64_t orkestraEslesmeTtlSn();
orkestra::YerlestirmeAgirlik orkestraYerlestirmeAgirlik();
uint32_t orkestraTransferParcaKB();

// Kriptografik rastgelelik (BCryptGenRandom sarmalı; eşleştirme nonce'u).
void orkestraRastgeleDoldur(uint8_t* p, size_t n);
// Binary ↔ hex (ayar deposu metin tabanlı — eşleştirme anahtarı hex saklanır).
std::string orkestraHexKodla(const std::string& binary);
std::string orkestraHexCoz(const std::string& hex);

// ── Saf yardımcılar (birim test: test/test_orkestra_kule.cpp) ────────────────
// Makine adından kalıcı node kimliği (FNV-1a 64). 0 dönmez — 0 "yerel kısayol"
// adresidir (NodeAdres), kimlik olarak kullanılamaz.
inline uint64_t orkestraNodeId(const std::string& makineAd) {
  uint64_t h = 1469598103934665603ull;
  for (unsigned char c : makineAd) {
    h ^= c;
    h *= 1099511628211ull;
  }
  return h ? h : 1;
}

// Yerel makinenin NodeIlan gövdesi (kendi makinemiz → doğrulanmış doğar).
inline orkestra::NodeBilgi yerelIlanKur(uint64_t nodeId, const std::string& ad,
                                        const char* surum, uint32_t runtimeSayisi,
                                        uint32_t aktifTask) {
  orkestra::NodeBilgi n;
  n.nodeId = nodeId;
  n.ad = ad;
  n.surum = surum ? surum : "";
  n.runtimeSayisi = runtimeSayisi;
  n.aktifTask = aktifTask;
  n.dogrulanmis = true;
  return n;
}

class OrkestraKule {
 public:
  // Kare-başına çağrılır (drain bloğu). aktif = dashboard/panel açık mı;
  // aktifGorev = bu süreçte çalışan GorevSistemi görevi sayısı; simdiMs = tick.
  void tik(SurecKopru& kopru, OlayGunlugu& olaylar, uint32_t aktifGorev, bool aktif,
           uint64_t simdiMs);

  orkestra::NodeKayitDefteri& defter() { return defter_; }
  uint64_t yerelNodeId() const { return yerelNodeId_; }
  // LAN keşif teşhisi (panel satırı) — bayrak kapalıyken nullptr.
  const orkestra::LanKesif* lan() const { return lan_.get(); }
  // TCP kanal teşhisi (panel satırı).
  bool tcpDinliyorMu() const { return tcpDinleyici_.acikMi(); }
  size_t tcpBaglantiSayisi() const { return kanallar_.size(); }
  uint64_t tcpAlinanCerceve() const { return tcpAlinanCerceve_; }

  // Eşleştirme yönetimi (panel + kalıcılık). Kurulmadan önce boş dönebilir.
  orkestra::EslesmeYonetici& eslesme();
  // Kalıcı depo (belge_penceresi startup/exit → ayarOku/ayarYaz; hex kodlu).
  std::string eslesmeKaydet() const;
  void eslesmeYukle(const std::string& hex);
  // Panel onayı: bekleyen gelen isteği onayla → o node'un kanalına EslesmeOnay yaz.
  // false = kanal kapanmış / bekleyen yok (panel kartı düşer).
  bool eslesmeOnayla(uint64_t nodeId);
  void eslesmeReddet(uint64_t nodeId);
  // Dosya gönder: yol'u oku + parçala + hedef node kanalına DosyaParca yaz. false =
  // okuma/kanal hatası. Alan taraf gecici/orkestra/aktarim'a birleştirip yazar.
  bool dosyaGonder(uint64_t nodeId, const std::string& yol);
  uint64_t tamamlananTransfer() const { return tamamlananTransfer_; }

  // GİDEN eşleştirme: keşfedilen node'a bağlan + EslesmeIste yaz (panel "Eşleştir").
  // false = ip bilinmiyor / bağlanılamadı. Kanal listeye eklenir (onay bu kanaldan gelir).
  bool eslesmeBaslat(uint64_t nodeId);

  // Rol/yetki teşhisi + panel köprüsü.
  bool rolAyarla(uint64_t nodeId, orkestra::Rol rol);
  uint64_t redUzakKomut() const { return redUzakKomut_; }
  orkestra::TaskYonetici& tasklar() { return tasklar_; }
  const orkestra::TaskYonetici& tasklar() const { return tasklar_; }
  // Task oluştur + hedef seç (Otomatik/Belirli/Etiket) + atanan node'a TaskAta yaz.
  // Dönen taskId (0 = hedef bulunamadı → Kuyrukta bekler; kanal yoksa atanır ama gönderilmez).
  uint64_t taskOlusturVeGonder(const std::string& tur,
                               const std::vector<std::pair<std::string, std::string>>& param,
                               const orkestra::TaskHedef& hedef);
  // Rol kapısını GEÇEN uzak komutlar (belge_penceresi drain'i tüketir → komutCalistir).
  // Şu an yürütme BAĞLANMADI (güvenlik zinciri önce); drain sonraki dalga.
  struct UzakKomut {
    uint64_t nodeId;
    SurecMesajTip tip;
    std::string ad;
    std::vector<std::pair<std::string, std::string>> parametreler;
  };
  std::vector<UzakKomut> beklemedekiUzakKomutlar();

  // Bu node'a atanmış işleri başlat (Atandi→Calisiyor + kaynağa TaskDurumu) → yürütülecek
  // {taskId,tur,param}. belge_penceresi drain komutCalistir'a verir, sonra taskTamamla çağırır.
  struct AtanmisTask {
    uint64_t taskId;
    std::string tur;
    std::vector<std::pair<std::string, std::string>> param;
  };
  std::vector<AtanmisTask> beklemedekiAtanmisTasklar();
  // Yürütme bitti → Bitti/Hata + kaynağa TaskDurumu.
  void taskTamamla(uint64_t taskId, bool basarili);
  void taskDurumGeriGonder(const orkestra::Task& t);  // kaynak node kanalına TaskDurumu

 private:
  void lanTik(const orkestra::NodeBilgi& yerelIlan, uint64_t simdiMs);
  void tcpTik(uint64_t simdiMs);
  orkestra::EslesmeYonetici& eslesmeKur();  // gecikmeli kurulum (rastgele fn bağlar)

  orkestra::NodeKayitDefteri defter_;
  std::string makineAd_;
  uint64_t yerelNodeId_ = 0;
  uint64_t sonTikMs_ = 0;
  bool kuruldu_ = false;

  // LAN keşif yaşam döngüsü (orkestra.lan_kesif bayrağı; kapalı → soket YOK).
  UdpSoketWin lanSoket_;
  std::unique_ptr<orkestra::LanKesif> lan_;
  uint64_t sonSoketDenemeMs_ = 0;  // açılamazsa 5 sn arayla yeniden dene

  // Yerel kaynak nabzı (panel açıkken metrik_aralik_ms throttle).
  MetrikToplayici metrik_;
  uint64_t sonMetrikMs_ = 0;
  orkestra::NodeMetrikOzet sonMetrikDeger_;  // LAN yayını için son ölçüm
  bool metrikHazir_ = false;

  // TCP çerçeve kanalı (İSKELET: kanal kurulur + çerçeve SAYILIR; komut işleme
  // eşleştirme+rol kapısıyla birlikte gelecek — o zamana dek gövde YOK SAYILIR).
  struct TcpKanal {
    TcpBaglantiWin baglanti;
    orkestra::AkisCozucu cozucu;
    uint64_t nodeId = 0;  // ilk EslesmeIste/Onay'dan öğrenilir (onay yazımı için)
    explicit TcpKanal(uintptr_t soket, size_t maksGovde)
        : baglanti(soket), cozucu(maksGovde) {}
  };
  void eslesmeCerceveIsle(TcpKanal& k, const SurecCerceve& c, uint64_t simdiMs);
  TcpDinleyiciWin tcpDinleyici_;
  std::vector<std::unique_ptr<TcpKanal>> kanallar_;
  uint64_t sonTcpDenemeMs_ = 0;
  uint64_t tcpAlinanCerceve_ = 0;
  uint64_t redUzakKomut_ = 0;               // rol kapısında reddedilen uzak komut sayısı
  std::vector<UzakKomut> onayliUzakKomut_;  // rol-geçen komutlar (drain bekliyor)
  orkestra::TaskYonetici tasklar_;          // dağıtık görev kuyruğu (D3)
  std::unordered_map<uint64_t, orkestra::ParcaBirlestirici> aktarimlar_;  // transferId→birleştirici
  uint64_t sonTransferId_ = 0;
  uint64_t tamamlananTransfer_ = 0;

  // Eşleştirme (TOFU kimlik). Kurulmadan yüklenen depo bekletilir.
  std::unique_ptr<orkestra::EslesmeYonetici> eslesme_;
  std::string bekleyenDepo_;  // eslesme_ kurulmadan önce yüklenen hex (ilk tik'te uygulanır)
  uint64_t sonEslesmeTemizMs_ = 0;
};

// App-global kule (belge_penceresi.cpp tanımlar; panel node şeridi okur).
extern OrkestraKule g_orkestraKule;

}  // namespace fiko