#include "com/model/belge_modeli.hpp"

#include <set>

namespace fikatia {

namespace {

_variant_t vt(const std::wstring& s) { return _variant_t(s.c_str()); }

std::wstring metinYap(_variant_t& v) {
  if (v.vt == VT_EMPTY || v.vt == VT_NULL) return {};
  v.ChangeType(VT_BSTR);
  return v.bstrVal ? std::wstring(v.bstrVal) : std::wstring();
}

bool boolYap(_variant_t& v) {
  v.ChangeType(VT_BOOL);
  return v.boolVal != VARIANT_FALSE;
}

bool boolOku(const FikomNesne& n, const wchar_t* ad) {
  _variant_t v = n.ozellik(ad);
  return boolYap(v);
}

FikomNesne nesneYap(_variant_t v) { return varyantNesne(v); }

// std::wstring listesi → VT_ARRAY|VT_VARIANT (CATIA'nin dizi bekleyen cagrilarina).
_variant_t dizgiDizisi(const std::vector<std::wstring>& liste) {
  SAFEARRAYBOUND sinir{(ULONG)liste.size(), 0};
  SAFEARRAY* sa = SafeArrayCreate(VT_VARIANT, 1, &sinir);
  if (!sa) throw FikomHata("SAFEARRAY olusturulamadi", 0);
  for (LONG i = 0; i < (LONG)liste.size(); ++i) {
    _variant_t e(liste[(size_t)i].c_str());
    SafeArrayPutElement(sa, &i, &e);
  }
  _variant_t sonuc;
  sonuc.vt = VT_ARRAY | VT_VARIANT;
  sonuc.parray = sa;
  return sonuc;
}

void gezginCalistir(std::wstring komut) {
  STARTUPINFOW si{};
  si.cb = sizeof(si);
  PROCESS_INFORMATION pi{};
  if (CreateProcessW(nullptr, komut.data(), nullptr, nullptr, FALSE, 0, nullptr, nullptr, &si, &pi)) {
    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
  }
}

}  // namespace

// ---- HibridBody / Bodyler / HibridBodyler -----------------------------------

HibridBody HibridBody::hibridBodyEkle(const std::wstring& ismi) {
  FikomNesne kap = com_.nesne(L"HybridBodies");
  HibridBody yeni(nesneYap(kap.metod(L"Add")));
  if (!ismi.empty()) yeni.ismiAyarla(ismi);
  return yeni;
}

Body Bodyler::ekle(const std::wstring& ismi) {
  Body yeni(nesneYap(com_.metod(L"Add")));
  if (!ismi.empty()) yeni.ismiAyarla(ismi);
  return yeni;
}

Body Bodyler::eleman(long indeks) const { return Body(com_.eleman(indeks + 1)); }

Body Bodyler::eleman(const std::wstring& ad) {
  return Body(nesneYap(com_.metod(L"Item", {vt(ad)})));
}

HibridBody HibridBodyler::ekle(const std::wstring& ismi) {
  HibridBody yeni(nesneYap(com_.metod(L"Add")));
  if (!ismi.empty()) yeni.ismiAyarla(ismi);
  return yeni;
}

HibridBody HibridBodyler::eleman(long indeks) const { return HibridBody(com_.eleman(indeks + 1)); }

HibridBody HibridBodyler::eleman(const std::wstring& ad) {
  return HibridBody(nesneYap(com_.metod(L"Item", {vt(ad)})));
}

// ---- Parametre --------------------------------------------------------------

void Parametre::ismiAyarla(const std::wstring& ad) { com_.metod(L"Rename", {vt(ad)}); }

bool Parametre::isimDegismisMi() const { return boolOku(com_, L"Renamed"); }
bool Parametre::gizli() const { return boolOku(com_, L"Hidden"); }
bool Parametre::parametreGercekMi() const { return boolOku(com_, L"IsTrueParameter"); }
bool Parametre::saltOkunur() const { return boolOku(com_, L"ReadOnly"); }

std::wstring Parametre::degeriStr() {
  _variant_t v = com_.metod(L"ValueAsString");
  return metinYap(v);
}

void Parametre::degeriStrAyarla(const std::wstring& v) {
  com_.metod(L"ValuateFromString", {vt(v)});
}

// ---- Parametreler / ParametreSeti -------------------------------------------

ParametreSeti Parametreler::kaynakParametreSeti() const {
  return ParametreSeti(com_.nesne(L"RootParameterSet"));
}

Parametreler Parametreler::altParametreler(const FikomNesne& obje, bool yinelemeli) {
  return Parametreler(nesneYap(com_.metod(L"SubList", {_variant_t(obje.ham(), true), _variant_t(yinelemeli)})));
}

Parametreler Parametreler::altParametreler(const FikomSarmal& obje, bool yinelemeli) {
  return altParametreler(obje.com(), yinelemeli);
}

bool Parametreler::parametreVarmi(const std::wstring& ad) {
  try {
    Parametre p = eleman(ad);
    if (!p.gecerli()) return false;
    (void)p.degeri();
    return true;
  } catch (const FikomHata&) {
    return false;
  }
}

Parametre Parametreler::eleman(long indeks) const { return Parametre(com_.eleman(indeks + 1)); }

Parametre Parametreler::eleman(const std::wstring& ad) {
  const size_t ayrac = ad.find(L">>>");
  if (ayrac == std::wstring::npos) return Parametre(nesneYap(com_.metod(L"Item", {vt(ad)})));

  const std::wstring aranan = ad.substr(0, ayrac);
  for (long i = adet() - 1; i >= 0; --i) {
    Parametre p = eleman(i);
    const std::wstring tam = p.ismi();
    const size_t son = tam.rfind(L'\\');
    const std::wstring kisa = (son == std::wstring::npos) ? tam : tam.substr(son + 1);
    if (kisa == aranan) return p;
  }
  return {};
}

void Parametreler::sil(long indeks) { com_.metod(L"Remove", {_variant_t(indeks + 1)}); }
void Parametreler::sil(const std::wstring& ad) { com_.metod(L"Remove", {vt(ad)}); }

Parametre Parametreler::yaratBoolean(const std::wstring& ismi, bool degeri) {
  return Parametre(nesneYap(com_.metod(L"CreateBoolean", {vt(ismi), _variant_t(degeri)})));
}

Parametre Parametreler::yaratOlcu(const std::wstring& ismi, const std::wstring& birimi, double degeri) {
  return Parametre(nesneYap(com_.metod(L"CreateDimension", {vt(ismi), vt(birimi), _variant_t(degeri)})));
}

Parametre Parametreler::yaratTamSayi(const std::wstring& ismi, long degeri) {
  return Parametre(nesneYap(com_.metod(L"CreateInteger", {vt(ismi), _variant_t(degeri)})));
}

Parametre Parametreler::yaratSayi(const std::wstring& ismi, double degeri) {
  return Parametre(nesneYap(com_.metod(L"CreateReal", {vt(ismi), _variant_t(degeri)})));
}

Parametre Parametreler::yaratYazi(const std::wstring& ismi, const std::wstring& degeri) {
  return Parametre(nesneYap(com_.metod(L"CreateString", {vt(ismi), vt(degeri)})));
}

void Parametreler::parametreSetiYarat(const FikomNesne& obje) {
  com_.metod(L"CreateSetOfParameters", {_variant_t(obje.ham(), true)});
}

std::wstring Parametreler::iliskidekiIsmi(const FikomNesne& obje) {
  _variant_t v = com_.metod(L"GetNameToUseInRelation", {_variant_t(obje.ham(), true)});
  return metinYap(v);
}

Parametreler ParametreSeti::tumParametreler() const {
  return Parametreler(com_.nesne(L"AllParameters"));
}

Parametreler ParametreSeti::direktParametreler() const {
  return Parametreler(com_.nesne(L"DirectParameters"));
}

ParametreSeti ParametreSeti::parametreSetleri() const {
  return ParametreSeti(com_.nesne(L"ParameterSets"));
}

// ---- Secim ------------------------------------------------------------------

Dokuman SeciliEleman::dokuman() const { return Dokuman(com_.nesne(L"Document")); }

Product SeciliEleman::product() const {
  return Product(com_.nesne(L"LeafProduct").nesne(L"ReferenceProduct"));
}

void Secililer::ekle(const FikomNesne& obje) {
  com_.metod(L"Add", {_variant_t(obje.ham(), true)});
}

FikomNesne Secililer::bul(const std::wstring& objeIsmi) {
  return nesneYap(com_.metod(L"FindObject", {vt(objeIsmi)}));
}

SeciliEleman Secililer::eleman(long indeks) const { return SeciliEleman(com_.eleman(indeks + 1)); }

SeciliEleman Secililer::eleman2(long indeks) {
  return SeciliEleman(nesneYap(com_.metod(L"Item2", {_variant_t(indeks + 1)})));
}

void Secililer::yapistirOzel(const std::wstring& format) { com_.metod(L"PasteSpecial", {vt(format)}); }
void Secililer::kaldir(long indeks) { com_.metod(L"Remove", {_variant_t(indeks + 1)}); }
void Secililer::kaldir2(long indeks) { com_.metod(L"Remove2", {_variant_t(indeks + 1)}); }
void Secililer::ara(const std::wstring& sorgu) { com_.metod(L"Search", {vt(sorgu)}); }

// ---- Dokuman / Dokumanlar ---------------------------------------------------

bool Dokuman::kaydedilmisMi() const { return boolOku(com_, L"Saved"); }
bool Dokuman::gizliOlanlariGoster() const { return boolOku(com_, L"SeeHiddenElements"); }
bool Dokuman::saltOkunur() const { return boolOku(com_, L"ReadOnly"); }

std::wstring Dokuman::turu() const {
  const std::wstring tam = tamIsmi();
  const size_t bolme = tam.find_last_of(L"\\/");
  const std::wstring taban = (bolme == std::wstring::npos) ? tam : tam.substr(bolme + 1);
  const size_t nokta = taban.rfind(L'.');
  return (nokta == std::wstring::npos || nokta == 0) ? std::wstring() : taban.substr(nokta);
}

Secililer Dokuman::secililer() const { return Secililer(com_.nesne(L"Selection")); }

void Dokuman::ac() {
  FikomNesne dokumanlar = com_.nesne(L"Application").nesne(L"Documents");
  dokumanlar.metod(L"Open", {vt(tamIsmi())});
}

void Dokuman::veriAktar(const std::wstring& dosya, const std::wstring& format) {
  com_.metod(L"ExportData", {vt(dosya), vt(format)});
}

void Dokuman::farkliKaydet(const std::wstring& dosya) { com_.metod(L"SaveAs", {vt(dosya)}); }

void Dokuman::klasoruAc() { gezginCalistir(L"explorer.exe \"" + klasoru() + L"\""); }

void Dokuman::klasoruAcSecimli() {
  gezginCalistir(L"explorer.exe /select,\"" + tamIsmi() + L"\"");
}

PartDokuman Dokuman::asPartDokuman() const { return PartDokuman(com_); }
ProductDokuman Dokuman::asProductDokuman() const { return ProductDokuman(com_); }

Dokuman Dokumanlar::ekle(const std::wstring& dokumanTipi) {
  return Dokuman(nesneYap(com_.metod(L"Add", {vt(dokumanTipi)})));
}

Dokuman Dokumanlar::eleman(long indeks) const { return Dokuman(com_.eleman(indeks + 1)); }

Dokuman Dokumanlar::eleman(const std::wstring& ad) {
  return Dokuman(nesneYap(com_.metod(L"Item", {vt(ad)})));
}

Dokuman Dokumanlar::yeniDosyadan(const std::wstring& dosyaYolu) {
  return Dokuman(nesneYap(com_.metod(L"NewFrom", {vt(dosyaYolu)})));
}

Dokuman Dokumanlar::ac(const std::wstring& dosya) {
  return Dokuman(nesneYap(com_.metod(L"Open", {vt(dosya)})));
}

Dokuman Dokumanlar::oku(const std::wstring& dosya) {
  return Dokuman(nesneYap(com_.metod(L"Read", {vt(dosya)})));
}

// ---- Part -------------------------------------------------------------------

double Part::yogunluk() const {
  _variant_t v = com_.ozellik(L"Density");
  v.ChangeType(VT_R8);
  return v.dblVal;
}

Bodyler Part::bodyler() const { return Bodyler(com_.nesne(L"Bodies")); }
HibridBodyler Part::hibridBodyler() const { return HibridBodyler(com_.nesne(L"HybridBodies")); }
Parametreler Part::parametreler() const { return Parametreler(com_.nesne(L"Parameters")); }

HibridBody Part::geometricSetEkle(const std::wstring& ismi) {
  FikomNesne kap = com_.nesne(L"HybridBodies");
  HibridBody yeni(nesneYap(kap.metod(L"Add")));
  if (!ismi.empty()) yeni.ismiAyarla(ismi);
  return yeni;
}

// ---- Product ----------------------------------------------------------------

Parametreler Product::parametreler() const { return Parametreler(com_.nesne(L"Parameters")); }

Parametreler Product::kullaniciParametreleri() const {
  return Parametreler(com_.nesne(L"UserRefProperties"));
}

Productlar Product::productlar() const { return Productlar(com_.nesne(L"Products")); }

Product Product::referansProduct() const { return Product(com_.nesne(L"ReferenceProduct")); }

FikomNesne Product::isimdenReferansYarat(const std::wstring& ad) {
  return nesneYap(com_.metod(L"CreateReferenceFromName", {vt(ad)}));
}

void Product::modeliAktifEt(const std::wstring& modelIsmi) {
  com_.metod(L"ActivateShape", {vt(modelIsmi)});
}

void Product::modeliDeaktifEt(const std::wstring& modelIsmi) {
  com_.metod(L"DesactivateShape", {vt(modelIsmi)});
}

void Product::anaModelEkle(const std::wstring& dosyaYolu) {
  com_.metod(L"AddMasterShapeRepresentation", {vt(dosyaYolu)});
}

void Product::modelEkle(const std::wstring& dosyaYolu, const std::wstring& modelIsmi,
                        const std::wstring& davranis, bool baglam) {
  com_.metod(L"AddShapeRepresentation", {vt(dosyaYolu), vt(modelIsmi), vt(davranis), _variant_t(baglam)});
}

void Product::isModuUygula(IsModu mod) { com_.metod(L"ApplyWorkMode", {_variant_t((long)mod)}); }

void Product::malzemeListesiniCikar(CiktiTuru tur, const std::wstring& dosya) {
  com_.metod(L"ExtractBOM", {_variant_t((long)tur), vt(dosya)});
}

std::wstring Product::aktifModelIsmi() {
  _variant_t v = com_.metod(L"GetActiveShapeName");
  return metinYap(v);
}

std::wstring Product::gecerliModelIsmi() {
  _variant_t v = com_.metod(L"GetDefaultShapeName");
  return metinYap(v);
}

std::wstring Product::anaModelYolu() {
  _variant_t v = com_.metod(L"GetMasterShapeRepresentationPathName");
  return metinYap(v);
}

long Product::modelSayisi() {
  _variant_t v = com_.metod(L"GetNumberOfShapes");
  v.ChangeType(VT_I4);
  return v.lVal;
}

std::wstring Product::modelYolu(const std::wstring& modelIsmi) {
  _variant_t v = com_.metod(L"GetShapePathName", {vt(modelIsmi)});
  return metinYap(v);
}

FikomNesne Product::anaModel(bool gerekirseYukle) {
  return nesneYap(com_.metod(L"GetMasterShapeRepresentation", {_variant_t(gerekirseYukle)}));
}

FikomNesne Product::model(bool gerekirseYukle, const std::wstring& modelIsmi,
                          const std::wstring& davranis, bool baglam) {
  return nesneYap(com_.metod(L"GetShapeRepresentation",
                             {_variant_t(gerekirseYukle), vt(modelIsmi), vt(davranis), _variant_t(baglam)}));
}

FikomNesne Product::teknolojikObje(const std::wstring& uygulamaTipi) {
  return nesneYap(com_.metod(L"GetTechnologicalObject", {vt(uygulamaTipi)}));
}

bool Product::anaModelVarmi() {
  _variant_t v = com_.metod(L"HasAMasterShapeRepresentation");
  return boolYap(v);
}

bool Product::modelVarmi(const std::wstring& modelIsmi, const std::wstring& davranis, bool baglam) {
  _variant_t v = com_.metod(L"HasRepresentation", {vt(modelIsmi), vt(davranis), _variant_t(baglam)});
  return boolYap(v);
}

void Product::modelSil(const std::wstring& modelIsmi, const std::wstring& davranis, bool baglam) {
  com_.metod(L"RemoveShapeRepresentation", {vt(modelIsmi), vt(davranis), _variant_t(baglam)});
}

bool Product::productMi() const { return productlar().adet() > 0; }

Dokuman Product::dokuman() const {
  return Dokuman(com_.nesne(L"ReferenceProduct").nesne(L"Parent"));
}

long Product::toplamParcaSayisi() const {
  long toplam = 0;
  Productlar alt = productlar();
  const long n = alt.adet();
  for (long i = 0; i < n; ++i) {
    Product cocuk = alt.eleman(i);
    toplam += cocuk.productMi() ? cocuk.toplamParcaSayisi() : 1;
  }
  return toplam;
}

namespace {

void tekilParcaTopla(const Product& p, std::set<std::wstring>& tekil) {
  Productlar alt = p.productlar();
  const long n = alt.adet();
  for (long i = 0; i < n; ++i) {
    Product cocuk = alt.eleman(i);
    if (cocuk.productMi()) {
      tekilParcaTopla(cocuk, tekil);
    } else {
      try {
        tekil.insert(cocuk.referansProduct().parcaNumarasi());
      } catch (const FikomHata&) {
      }
    }
  }
}

}  // namespace

long Product::farkliParcaSayisi() const {
  std::set<std::wstring> tekil;
  tekilParcaTopla(*this, tekil);
  return (long)tekil.size();
}

PartDokuman Product::partaCevir(const std::wstring& partIsmi) {
  FikomNesne komut = nesneYap(com_.metod(L"GetItem", {vt(L"DECProductToPart")}));
  komut.metod(L"Run");
  PartDokuman yeni(nesneYap(komut.metod(L"GetResult")));
  if (!partIsmi.empty()) {
    Product ref = yeni.product().referansProduct();
    ref.parcaNumarasiAyarla(L"FikoYT_" + partIsmi + L"_Hepsi(" +
                            std::to_wstring(GetTickCount64()) + L")");
  }
  return yeni;
}

// ---- Productlar -------------------------------------------------------------

Product Productlar::bilesenEkle(const FikomNesne& product) {
  return Product(nesneYap(com_.metod(L"AddComponent", {_variant_t(product.ham(), true)})));
}

Product Productlar::bilesenEkleDosyalardan(const std::vector<std::wstring>& dosyalar,
                                           const std::wstring& metod) {
  return Product(nesneYap(com_.metod(L"AddComponentsFromFiles", {dizgiDizisi(dosyalar), vt(metod)})));
}

Product Productlar::bilesenEkleAcikDosyadan(const FikomNesne& product) {
  return Product(nesneYap(com_.metod(L"AddExternalComponent", {_variant_t(product.ham(), true)})));
}

Product Productlar::yeniProduct(const std::wstring& parcaNo) {
  return Product(nesneYap(com_.metod(L"AddNewProduct", {vt(parcaNo)})));
}

Product Productlar::yeniBilesen(const std::wstring& bilesenTuru, const std::wstring& parcaNo) {
  return Product(nesneYap(com_.metod(L"AddNewComponent", {vt(bilesenTuru), vt(parcaNo)})));
}

Product Productlar::bilesenDegistir(const FikomNesne& product, const std::wstring& yeniDosya, bool ikili) {
  return Product(nesneYap(com_.metod(L"ReplaceComponent",
                                     {_variant_t(product.ham(), true), vt(yeniDosya), _variant_t(ikili)})));
}

Product Productlar::productDegistir(const FikomNesne& eski, const FikomNesne& yeni, bool ikili) {
  return Product(nesneYap(com_.metod(L"ReplaceProduct",
                                     {_variant_t(eski.ham(), true), _variant_t(yeni.ham(), true), _variant_t(ikili)})));
}

Product Productlar::eleman(long indeks) const { return Product(com_.eleman(indeks + 1)); }

Product Productlar::eleman(const std::wstring& ad) {
  return Product(nesneYap(com_.metod(L"Item", {vt(ad)})));
}

void Productlar::sil(long indeks) { com_.metod(L"Remove", {_variant_t(indeks + 1)}); }

// ---- Tipli dokumanlar -------------------------------------------------------

Part PartDokuman::part() const { return Part(com_.nesne(L"Part")); }
Product PartDokuman::product() const { return Product(com_.nesne(L"Product")); }
Product ProductDokuman::product() const { return Product(com_.nesne(L"Product")); }

}  // namespace fikatia