#include "com/fikatia_uygulama.hpp"

#include <oleauto.h>

namespace fikatia {

namespace {

bool boolOku(FikomNesne& n, const wchar_t* ad) {
  _variant_t v = n.ozellik(ad);
  v.ChangeType(VT_BOOL);
  return v.boolVal != VARIANT_FALSE;
}

// Başlık metnine göre üst düzey pencere ara (aktifEt için).
struct PencereArama {
  const wchar_t* aranan;
  HWND bulunan;
};

BOOL CALLBACK pencereTara(HWND hwnd, LPARAM veri) {
  auto* arama = reinterpret_cast<PencereArama*>(veri);
  wchar_t baslik[512]{};
  GetWindowTextW(hwnd, baslik, 512);
  if (wcsstr(baslik, arama->aranan)) {
    arama->bulunan = hwnd;
    return FALSE;
  }
  return TRUE;
}

}  // namespace

[[nodiscard]] std::wstring FikatiaUygulama::isAlaniId() {
  _variant_t v = uygulama_.metod(L"GetWorkbenchId");
  if (v.vt == VT_EMPTY || v.vt == VT_NULL) return {};
  v.ChangeType(VT_BSTR);
  return v.bstrVal ? std::wstring(v.bstrVal) : std::wstring();
}

[[nodiscard]] bool FikatiaUygulama::gorunur() { return boolOku(uygulama_, L"Visible"); }
[[nodiscard]] bool FikatiaUygulama::ekraniTazele() { return boolOku(uygulama_, L"RefreshDisplay"); }
[[nodiscard]] bool FikatiaUygulama::interaktif() { return boolOku(uygulama_, L"Interactive"); }
[[nodiscard]] bool FikatiaUygulama::dosyaUyarilari() { return boolOku(uygulama_, L"DisplayFileAlerts"); }
[[nodiscard]] bool FikatiaUygulama::hsoSenkronize() { return boolOku(uygulama_, L"HSOSynchronized"); }

[[nodiscard]] _variant_t FikatiaUygulama::evalVb(const std::wstring& govde, const std::wstring& parametreAdlari,
                                   std::vector<_variant_t> parametreler) {
  const std::wstring kod =
      L"Function donus(" + parametreAdlari + L")\n" + govde + L"\nEnd Function";
  FikomNesne servis = uygulama_.nesne(L"SystemService");
  std::vector<_variant_t> args{_variant_t(kod.c_str()), _variant_t(0L), _variant_t(L"donus")};
  for (auto& p : parametreler) args.push_back(std::move(p));
  return servis.metod(L"Evaluate", std::move(args));
}

[[nodiscard]] _variant_t FikatiaUygulama::scriptCalistir(const std::wstring& kutuphaneYolu,
                                           const std::wstring& modul, const std::wstring& makro,
                                           std::vector<_variant_t> parametreler) {
  FikomNesne servis = uygulama_.nesne(L"SystemService");
  // 2 = catScriptLibraryTypeVBAFile (Python IFikatia.scriptCalistir birebir)
  std::vector<_variant_t> args{_variant_t(kutuphaneYolu.c_str()), _variant_t(2L),
                               _variant_t(modul.c_str()), _variant_t(makro.c_str())};
  for (auto& p : parametreler) args.push_back(std::move(p));
  return servis.metod(L"ExecuteScript", std::move(args));
}

[[nodiscard]] std::vector<FikomNesne> FikatiaUygulama::acikCatialar() {
  std::vector<FikomNesne> liste;
  IRunningObjectTable* rot = nullptr;
  if (FAILED(GetRunningObjectTable(0, &rot)) || !rot) return liste;
  IEnumMoniker* numarator = nullptr;
  if (SUCCEEDED(rot->EnumRunning(&numarator)) && numarator) {
    IMoniker* anahtar = nullptr;
    while (numarator->Next(1, &anahtar, nullptr) == S_OK) {
      IUnknown* bilinmeyen = nullptr;
      if (SUCCEEDED(rot->GetObject(anahtar, &bilinmeyen)) && bilinmeyen) {
        IDispatch* d = nullptr;
        bilinmeyen->QueryInterface(IID_IDispatch, reinterpret_cast<void**>(&d));
        bilinmeyen->Release();
        if (d) {
          FikomNesne aday(d);
          // CATIA ayırt etme: Documents + Caption sunan Application nesnesi
          try {
            (void)aday.nesne(L"Documents");
            (void)aday.metin(L"Caption");
            liste.push_back(std::move(aday));
          } catch (const FikomHata&) {
          }
        }
      }
      anahtar->Release();
    }
    numarator->Release();
  }
  rot->Release();
  return liste;
}

[[nodiscard]] bool FikatiaUygulama::aktifEt() {
  if (!bagli()) return false;
  try {
    const std::wstring eski = baslik();
    const std::wstring gecici = L"fikatia-" + std::to_wstring(GetTickCount64());
    baslikAyarla(gecici);
    PencereArama arama{gecici.c_str(), nullptr};
    EnumWindows(pencereTara, static_cast<LPARAM>(&arama));
    baslikAyarla(eski);
    if (!arama.bulunan) return false;
    if (IsIconic(arama.bulunan)) ShowWindow(arama.bulunan, SW_RESTORE);
    return SetForegroundWindow(arama.bulunan) != 0;
  } catch (const FikomHata&) {
    return false;
  }
}

[[nodiscard]] std::wstring FikatiaUygulama::baglan(bool gerekirseBaslat) {
  if (bagli() && canli()) return {};
  uygulama_ = {};

  CLSID clsid{};
  HRESULT hr = CLSIDFromProgID(L"CATIA.Application", &clsid);
  if (FAILED(hr))
    return L"CATIA bu bilgisayarda kayıtlı değil (CATIA.Application ProgID bulunamadı).";

  IUnknown* bilinmeyen = nullptr;
  hr = GetActiveObject(clsid, nullptr, &bilinmeyen);
  if (SUCCEEDED(hr) && bilinmeyen) {
    IDispatch* d = nullptr;
    bilinmeyen->QueryInterface(IID_IDispatch, reinterpret_cast<void**>(&d));
    bilinmeyen->Release();
    if (d) { uygulama_ = FikomNesne(d); return {}; }
    return L"Çalışan CATIA bulundu ama IDispatch arayüzü alınamadı.";
  }

  if (!gerekirseBaslat)
    return L"Çalışan CATIA bulunamadı. CATIA'yı açın veya 'Başlat' seçeneğini kullanın.";

  IDispatch* d = nullptr;
  hr = CoCreateInstance(clsid, nullptr, CLSCTX_LOCAL_SERVER, IID_IDispatch, reinterpret_cast<void**>(&d));
  if (FAILED(hr) || !d) {
    _com_error ce(hr);
    return std::wstring(L"CATIA başlatılamadı: ") +
           (ce.ErrorMessage() ? ce.ErrorMessage() : L"bilinmeyen hata");
  }
  uygulama_ = FikomNesne(d);
  try {
    uygulama_.ozellikAyarla(L"Visible", _variant_t(true));
  } catch (const FikomHata&) {
    // Görünürlük ayarlanamasa da bağlantı geçerli — sessiz geç.
  }
  return {};
}

[[nodiscard]] bool FikatiaUygulama::canli() {
  if (!uygulama_) return false;
  try {
    (void)uygulama_.metin(L"Caption");
    return true;
  } catch (const FikomHata&) {
    uygulama_ = {};
    return false;
  }
}

[[nodiscard]] std::wstring FikatiaUygulama::surumBilgisi() {
  if (!bagli()) return {};
  try {
    // SystemService.Environ yerine doğrudan surum ozellikleri (V5: nesne doner).
    _variant_t s = uygulama_.ozellik(L"SystemConfiguration");
    FikomNesne sk = varyantNesne(s);
    if (sk) {
      const long ana = sk.sayi(L"Version");
      const long yayin = sk.sayi(L"Release");
      return L"CATIA V" + std::to_wstring(ana) + L"R" + std::to_wstring(yayin);
    }
  } catch (const FikomHata&) {
  }
  try {
    return uygulama_.metin(L"Caption");
  } catch (const FikomHata&) {
    return L"?";
  }
}

[[nodiscard]] std::vector<FikatiaUygulama::DokumanBilgi> FikatiaUygulama::dokumanlar() {
  std::vector<DokumanBilgi> liste;
  if (!bagli()) return liste;
  FikomNesne dokumanlarNesnesi = uygulama_.nesne(L"Documents");
  if (!dokumanlarNesnesi) return liste;
  const long n = dokumanlarNesnesi.adet();
  liste.reserve(static_cast<size_t>(n));
  for (long i = 1; i <= n; ++i) {
    FikomNesne d = dokumanlarNesnesi.eleman(i);
    if (!d) continue;
    DokumanBilgi bilgi;
    try { bilgi.ad = d.metin(L"Name"); } catch (const FikomHata&) {}
    try { bilgi.tamYol = d.metin(L"FullName"); } catch (const FikomHata&) {}
    // Tür: uzantıdan (CATPart/CATProduct/CATProcess/CATDrawing)
    const size_t nokta = bilgi.ad.rfind(L'.');
    bilgi.tip = (nokta != std::wstring::npos) ? bilgi.ad.substr(nokta + 1) : L"?";
    liste.push_back(std::move(bilgi));
  }
  return liste;
}

}  // namespace fikatia