#include "fiko/betik/makro_motor.hpp"

#include <algorithm>
#include <filesystem>

#include "fiko/cekirdek/cekirdek.hpp"
#include "fiko/sahne/sahne.hpp"
#include "makro_ic.hpp"

extern "C" {
#include "lauxlib.h"
#include "lua.h"
#include "lualib.h"
}

namespace fiko::betik {

using makroic::alanYaz;

MakroMotor::MakroMotor(Cekirdek& cekirdek, Sahne& sahne)
    : cekirdek_(cekirdek), sahne_(sahne) {
  L_ = luaL_newstate();
  luaL_openlibs(L_);
  apiKur();
  olayKopruleriKur();
}

MakroMotor::~MakroMotor() {
  if (L_) lua_close(L_);
}

MakroMotor* MakroMotor::kendisi(lua_State* L) {
  return static_cast<MakroMotor*>(lua_touserdata(L, lua_upvalueindex(1)));
}

void MakroMotor::fonksiyon(const char* ad, int (*f)(lua_State*)) {
  lua_pushlightuserdata(L_, this);
  lua_pushcclosure(L_, f, 1);
  lua_setfield(L_, -2, ad);
}

void MakroMotor::hataYaz() {
  const char* mesaj = lua_tostring(L_, -1);
  cikti_.push_back(std::string("HATA: ") + (mesaj ? mesaj : "bilinmeyen hata"));
  lua_pop(L_, 1);
}

void MakroMotor::apiKur() {
  lua_pushlightuserdata(L_, this);
  lua_pushcclosure(L_, l_print, 1);
  lua_setglobal(L_, "print");

  lua_createtable(L_, 0, 8);

  fonksiyon("log", l_print);
  fonksiyon("guncelle", l_guncelle);
  fonksiyon("geriAl", l_geriAl);
  fonksiyon("yinele", l_yinele);

  lua_createtable(L_, 0, 1);
  fonksiyon("dinle", l_olayDinle);
  lua_setfield(L_, -2, "olay");

  lua_createtable(L_, 0, 14);
  fonksiyon("ekle", l_sahneEkle);
  fonksiyon("sil", l_sahneSil);
  fonksiyon("dugumler", l_sahneDugumler);
  fonksiyon("ad", l_sahneAd);
  fonksiyon("adAyarla", l_sahneAdAyarla);
  fonksiyon("konum", l_sahneKonum);
  fonksiyon("konumAyarla", l_sahneKonumAyarla);
  fonksiyon("renkAyarla", l_sahneRenkAyarla);
  fonksiyon("gorunurAyarla", l_sahneGorunurAyarla);
  fonksiyon("parametreAyarla", l_sahneParametreAyarla);
  fonksiyon("boolean", l_sahneBoolean);
  fonksiyon("stepIceAktar", l_sahneStepIceAktar);
  fonksiyon("stepDisaAktar", l_sahneStepDisaAktar);
  fonksiyon("alanSec", l_sahneAlanSec);
  fonksiyon("olcu", l_sahneOlcu);  // salt-okuma ölçüm (doğrulama)
  lua_setfield(L_, -2, "sahne");

  lua_createtable(L_, 0, 7);
  fonksiyon("secililer", l_secimSecililer);
  fonksiyon("temizle", l_secimTemizle);
  fonksiyon("sec", l_secimSec);
  fonksiyon("kip", l_secimKip);
  fonksiyon("kimlik", l_secimKimlik);           // KYA kalıcı ad al
  fonksiyon("kimlikSec", l_secimKimlikSec);     // KYA kalıcı ad ile seç
  fonksiyon("kimlikListe", l_secimKimlikListe); // KYA gövde yüz KID listesi
  lua_setfield(L_, -2, "secim");

  lua_createtable(L_, 0, 4);
  fonksiyon("listesi", l_komutListesi);
  fonksiyon("calistir", l_komutCalistir);
  fonksiyon("tanimla", l_komutTanimla);
  fonksiyon("kaldir", l_komutKaldir);
  lua_setfield(L_, -2, "komut");

  lua_createtable(L_, 0, 3);
  fonksiyon("aktif", l_workbenchAktif);
  fonksiyon("ayarla", l_workbenchAyarla);
  fonksiyon("liste", l_workbenchListe);
  lua_setfield(L_, -2, "workbench");

  lua_createtable(L_, 0, 5);
  fonksiyon("tema", l_uiTema);
  fonksiyon("temaAktif", l_uiTemaAktif);
  fonksiyon("temalar", l_uiTemalar);
  fonksiyon("vurgu", l_uiVurgu);
  fonksiyon("simgeYukle", l_uiSimgeYukle);
  lua_setfield(L_, -2, "ui");

  lua_createtable(L_, 0, 4);
  fonksiyon("al", l_ayarAl);
  fonksiyon("ata", l_ayarAta);
  fonksiyon("liste", l_ayarListe);
  fonksiyon("sifirla", l_ayarSifirla);
  lua_setfield(L_, -2, "ayar");

  lua_createtable(L_, 0, 15);
  fonksiyon("islemEkle", l_camIslemEkle);
  fonksiyon("islemSil", l_camIslemSil);
  fonksiyon("islemler", l_camIslemler);
  fonksiyon("geometriAta", l_camGeometriAta);
  fonksiyon("hesapla", l_camHesapla);
  fonksiyon("gkodYaz", l_camGkodYaz);
  fonksiyon("aptYaz", l_camAptYaz);
  fonksiyon("takimlar", l_camTakimlar);
  fonksiyon("opEkle", l_camOpEkle);
  fonksiyon("opSil", l_camOpSil);
  fonksiyon("opHesapla", l_camOpHesapla);
  fonksiyon("oplar", l_camOplar);
  fonksiyon("parcaOpEkle", l_camParcaOpEkle);
  fonksiyon("parcaOplar", l_camParcaOplar);
  fonksiyon("secimBaslat", l_camSecimBaslat);
  fonksiyon("secimBitir", l_camSecimBitir);
  fonksiyon("takimEkseniPencere", l_camTakimEkseniPencere);
  lua_setfield(L_, -2, "cam");

  lua_createtable(L_, 0, 8);
  fonksiyon("liste", l_malzemeListe);
  fonksiyon("bul", l_malzemeBul);
  fonksiyon("olustur", l_malzemeOlustur);
  fonksiyon("ayarla", l_malzemeAyarla);
  fonksiyon("doku", l_malzemeDoku);
  fonksiyon("sil", l_malzemeSil);
  fonksiyon("ata", l_malzemeAta);
  fonksiyon("coz", l_malzemeCoz);
  lua_setfield(L_, -2, "malzeme");

  // Sketch (2B eskiz) — parametrik modellemenin girişi.
  lua_createtable(L_, 0, 6);
  fonksiyon("ekle", l_sketchEkle);
  fonksiyon("cizgi", l_sketchCizgi);
  fonksiyon("daire", l_sketchDaire);
  fonksiyon("yay", l_sketchYay);
  fonksiyon("dikdortgen", l_sketchDikdortgen);
  fonksiyon("yenile", l_sketchYenile);
  lua_setfield(L_, -2, "sketch");

  // Part Design — feature kataloğu VERİ-GÜDÜMLÜ olduğundan tek `ekle` tüm tipleri açar
  // (pad/pocket/shaft/hole/fillet/pattern/…); yeni feature eklenince Lua kendiliğinden kazanır.
  lua_createtable(L_, 0, 5);
  fonksiyon("tipler", l_parcaTipler);
  fonksiyon("ekle", l_parcaEkle);
  fonksiyon("guncelle", l_parcaGuncelle);
  fonksiyon("featureler", l_parcaFeatureler);
  fonksiyon("sil", l_parcaSil);
  fonksiyon("formul", l_parcaFormul);
  lua_setfield(L_, -2, "parca");

  // Parametre tablosu + formül (CATIA f(x)) — motor tarafı vardı, yüzeyi yoktu.
  lua_createtable(L_, 0, 4);
  fonksiyon("ekle", l_parametreEkle);
  fonksiyon("ayarla", l_parametreAyarla);
  fonksiyon("liste", l_parametreListe);
  fonksiyon("sil", l_parametreSil);
  lua_setfield(L_, -2, "parametre");

  // GSD (Generative Shape Design) — katalog veri-güdümlü, tek `ekle` 31 op'u açar.
  lua_createtable(L_, 0, 5);
  fonksiyon("tipler", l_gsdTipler);
  fonksiyon("ekle", l_gsdEkle);
  fonksiyon("guncelle", l_gsdGuncelle);
  fonksiyon("featureler", l_gsdFeatureler);
  fonksiyon("sil", l_gsdSil);
  lua_setfield(L_, -2, "gsd");

  // Analiz — kalıp/yüzey kalite raporları (sayısal; yapay zeka doğrulama yapabilsin).
  lua_createtable(L_, 0, 4);
  fonksiyon("tipler", l_analizTipler);
  fonksiyon("ekle", l_analizEkle);
  fonksiyon("sonuc", l_analizSonuc);
  fonksiyon("sil", l_analizSil);
  lua_setfield(L_, -2, "analiz");

  // Kinematik — mekanizma (uzuv+mafsal) + ileri kinematik → sahne dönüşümleri.
  lua_createtable(L_, 0, 6);
  fonksiyon("sifirla", l_kinSifirla);
  fonksiyon("uzuvEkle", l_kinUzuvEkle);
  fonksiyon("mafsalEkle", l_kinMafsalEkle);
  fonksiyon("surus", l_kinSurus);
  fonksiyon("uygula", l_kinUygula);
  fonksiyon("durum", l_kinDurum);
  fonksiyon("yasa", l_kinYasa);
  fonksiyon("yasaAnahtar", l_kinYasaAnahtar);
  fonksiyon("zaman", l_kinZaman);
  fonksiyon("coz", l_kinCoz);
  fonksiyon("carpismaTara", l_kinCarpisma);
  fonksiyon("sabitle", l_kinSabitle);
  fonksiyon("isaretTemizle", l_kinIsaretTemizle);
  fonksiyon("oner", l_kinOner);
  fonksiyon("onerEkle", l_kinOnerEkle);
  lua_setfield(L_, -2, "kinematik");

  // CAE — lineer elastik FEM (hex8 voxel kafesi).
  lua_createtable(L_, 0, 1);
  fonksiyon("coz", l_caeCoz);
  fonksiyon("kurulumKaydet", l_caeKurulumKaydet);
  fonksiyon("kurulumlar", l_caeKurulumlar);
  lua_setfield(L_, -2, "cae");

  // Performans — canlı kare/CPU/GPU metrikleri (uygulama köprüsü varsa).
  lua_createtable(L_, 0, 1);
  fonksiyon("metrik", l_perfMetrik);
  lua_setfield(L_, -2, "perf");

  // Arka plan işleri — "kaydet/aç/import bitti mi?" (async çağrılar hemen döner).
  lua_createtable(L_, 0, 2);
  fonksiyon("liste", l_gorevListe);
  fonksiyon("mesgul", l_gorevMesgul);
  lua_setfield(L_, -2, "gorev");

  // Belge dosya işlemleri (diyalogsuz) — makro/MCP otomasyonu.
  lua_createtable(L_, 0, 2);
  fonksiyon("kaydet", l_belgeKaydet);
  fonksiyon("ac", l_belgeAc);
  lua_setfield(L_, -2, "belge");

  // Geometri Zekâ Motoru — graf sorgu/pipeline (fiko.zeka.*).
  lua_createtable(L_, 0, 4);
  fonksiyon("coz", l_zekaCoz);
  fonksiyon("pipeline", l_zekaPipeline);
  fonksiyon("dugum", l_zekaDugum);
  fonksiyon("ozet", l_zekaOzet);
  lua_setfield(L_, -2, "zeka");

  // İş Takip — merkezi teklif/sipariş/iş emri (fiko.istakip.*).
  lua_createtable(L_, 0, 3);
  fonksiyon("liste", l_istakipListe);
  fonksiyon("kayit", l_istakipKayit);
  fonksiyon("yaz", l_istakipYaz);
  lua_setfield(L_, -2, "istakip");

  lua_setglobal(L_, "fiko");
}

template <class Olay, class Doldur>
void MakroMotor::koprule(Doldur doldur) {
  cekirdek_.olaylar().abone<Olay>([this, doldur](const Olay& o) {
    auto& liste = dinleyiciler_[static_cast<std::size_t>(Olay::tur())];
    if (liste.empty()) return;
    for (std::size_t i = 0; i < liste.size();) {
      lua_rawgeti(L_, LUA_REGISTRYINDEX, liste[i]);
      lua_createtable(L_, 0, 3);
      doldur(L_, o);
      if (lua_pcall(L_, 1, 0, 0) != LUA_OK) {
        hataYaz();
        luaL_unref(L_, LUA_REGISTRYINDEX, liste[i]);
        liste.erase(liste.begin() + static_cast<std::ptrdiff_t>(i));
      } else {
        ++i;
      }
    }
  });
}

void MakroMotor::olayKopruleriKur() {
  const auto varlikli = [](lua_State* L, const auto& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
  };
  koprule<VarlikEklendi>(varlikli);
  koprule<VarlikSilindi>(varlikli);
  koprule<DonusumDegisti>(varlikli);
  koprule<BrepDegisti>(varlikli);
  koprule<RenkDegisti>(varlikli);
  koprule<OlcumEklendi>(varlikli);
  koprule<OlcumSilindi>(varlikli);
  koprule<ParametreDegisti>(varlikli);
  koprule<SketchGirildi>([](lua_State* L, const SketchGirildi& o) {
    alanYaz(L, "sketch", static_cast<lua_Integer>(o.sketch));
  });
  koprule<SketchCikildi>([](lua_State* L, const SketchCikildi& o) {
    alanYaz(L, "sketch", static_cast<lua_Integer>(o.sketch));
  });
  koprule<HesaplamaBitti>([](lua_State* L, const HesaplamaBitti& o) {
    alanYaz(L, "sayi", static_cast<lua_Integer>(o.sayi));
  });
  koprule<WorkbenchDegisti>([](lua_State*, const WorkbenchDegisti&) {});
  koprule<GorunurlukDegisti>([](lua_State* L, const GorunurlukDegisti& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
    lua_pushboolean(L, o.gorunur ? 1 : 0);
    lua_setfield(L, -2, "gorunur");
  });
  koprule<SecimDegisti>([](lua_State*, const SecimDegisti&) {});
  koprule<KipDegisti>([](lua_State* L, const KipDegisti& o) {
    alanYaz(L, "kip", static_cast<lua_Integer>(o.kip));
  });
  koprule<VurguDegisti>([](lua_State* L, const VurguDegisti& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
    alanYaz(L, "alt", static_cast<lua_Integer>(o.alt));
    alanYaz(L, "eleman", static_cast<lua_Integer>(o.eleman));
  });
  koprule<GorevBasladi>([](lua_State* L, const GorevBasladi& o) {
    alanYaz(L, "kimlik", static_cast<lua_Integer>(o.kimlik));
  });
  koprule<GorevBitti>([](lua_State* L, const GorevBitti& o) {
    alanYaz(L, "kimlik", static_cast<lua_Integer>(o.kimlik));
    lua_pushboolean(L, o.hataliMi ? 1 : 0);
    lua_setfield(L, -2, "hatali");
  });
  koprule<CamIslemEklendi>(varlikli);
  koprule<CamIslemSilindi>(varlikli);
  koprule<CamYoluHesaplandi>([](lua_State* L, const CamYoluHesaplandi& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
    alanYaz(L, "hamle", static_cast<lua_Integer>(o.hamle));
  });
  koprule<AlanSecimYapildi>([](lua_State* L, const AlanSecimYapildi& o) {
    alanYaz(L, "tip", static_cast<lua_Integer>(o.tip));
    alanYaz(L, "adet", static_cast<lua_Integer>(o.adet));
  });
  koprule<AptYazildi>([](lua_State* L, const AptYazildi& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
    alanYaz(L, "hamle", static_cast<lua_Integer>(o.hamle));
  });
  // K5: SahneRefSecim + Ölçüm seçim olayları makrolara açık (anayasa paritesi).
  koprule<RefSecimYapildi>([](lua_State* L, const RefSecimYapildi& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
    alanYaz(L, "govde", static_cast<lua_Integer>(o.govde));
    alanYaz(L, "alt", static_cast<lua_Integer>(o.alt));
    alanYaz(L, "kaynak", static_cast<lua_Integer>(o.kaynak));
  });
  koprule<OlcumSecimYapildi>([](lua_State* L, const OlcumSecimYapildi& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
    alanYaz(L, "alt", static_cast<lua_Integer>(o.alt));
    lua_pushboolean(L, o.serbest ? 1 : 0);
    lua_setfield(L, -2, "serbest");
  });
  koprule<SketchSecimDegisti>([](lua_State* L, const SketchSecimDegisti& o) {
    alanYaz(L, "varlik", static_cast<lua_Integer>(o.varlik));
    alanYaz(L, "adet", static_cast<lua_Integer>(o.adet));
  });
  // Merkezi komut çalıştırma — makro telemetri/lisans: her komut kullanımını gözle.
  koprule<KomutCalisti>([](lua_State* L, const KomutCalisti& o) {
    lua_pushstring(L, o.ad ? o.ad : ""); lua_setfield(L, -2, "ad");
    lua_pushstring(L, o.kategori ? o.kategori : ""); lua_setfield(L, -2, "kategori");
    lua_pushstring(L, o.kaynak ? o.kaynak : ""); lua_setfield(L, -2, "kaynak");
    lua_pushboolean(L, o.basarili ? 1 : 0); lua_setfield(L, -2, "basarili");
  });
}

bool MakroMotor::dosyaCalistir(const std::string& yol) {
  if (luaL_loadfile(L_, yol.c_str()) != LUA_OK ||
      lua_pcall(L_, 0, LUA_MULTRET, 0) != LUA_OK) {
    hataYaz();
    return false;
  }
  lua_settop(L_, 0);
  return true;
}

bool MakroMotor::satirCalistir(const std::string& kod) {
  if (luaL_loadbuffer(L_, kod.c_str(), kod.size(), "=makro") != LUA_OK ||
      lua_pcall(L_, 0, LUA_MULTRET, 0) != LUA_OK) {
    hataYaz();
    return false;
  }
  lua_settop(L_, 0);
  return true;
}

void MakroMotor::kareGuncelle(float dt) {
  if (guncelleRefs_.empty()) return;
  for (std::size_t i = 0; i < guncelleRefs_.size();) {
    lua_rawgeti(L_, LUA_REGISTRYINDEX, guncelleRefs_[i]);
    lua_pushnumber(L_, static_cast<lua_Number>(dt));
    if (lua_pcall(L_, 1, 0, 0) != LUA_OK) {
      hataYaz();
      luaL_unref(L_, LUA_REGISTRYINDEX, guncelleRefs_[i]);
      guncelleRefs_.erase(guncelleRefs_.begin() + static_cast<std::ptrdiff_t>(i));
    } else {
      ++i;
    }
  }
}

std::vector<std::string> MakroMotor::makroListele(const std::string& dizin) const {
  std::vector<std::string> sonuc;
  std::error_code ec;
  for (const auto& giris : std::filesystem::directory_iterator(dizin, ec)) {
    if (!giris.is_regular_file(ec)) continue;
    if (giris.path().extension() == ".lua") sonuc.push_back(giris.path().string());
  }
  std::sort(sonuc.begin(), sonuc.end());
  return sonuc;
}

int MakroMotor::l_print(lua_State* L) {
  MakroMotor* m = kendisi(L);
  const int n = lua_gettop(L);
  std::string satir;
  for (int i = 1; i <= n; ++i) {
    std::size_t uz = 0;
    const char* s = luaL_tolstring(L, i, &uz);
    if (i > 1) satir += '\t';
    satir.append(s, uz);
    lua_pop(L, 1);
  }
  m->cikti_.push_back(std::move(satir));
  return 0;
}

int MakroMotor::l_guncelle(lua_State* L) {
  MakroMotor* m = kendisi(L);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_pushvalue(L, 1);
  m->guncelleRefs_.push_back(luaL_ref(L, LUA_REGISTRYINDEX));
  return 0;
}

int MakroMotor::l_geriAl(lua_State* L) {
  kendisi(L)->cekirdek_.geriAl();
  return 0;
}

int MakroMotor::l_yinele(lua_State* L) {
  kendisi(L)->cekirdek_.yinele();
  return 0;
}

}  // namespace fiko::betik