#include "com/model/imalat_modeli.hpp"

#include <algorithm>
#include <cwctype>
#include <format>

namespace fikatia {

namespace {

_variant_t vt(const std::wstring& s) { return _variant_t(s.c_str()); }
_variant_t vt(double d) { return _variant_t(d); }
_variant_t vt(long l) { return _variant_t(l); }
_variant_t dv(const FikomNesne& n) { return _variant_t(n.ham(), true); }

// Out-parametreli CATIA cagrilari icin (GetToolAxis vb.) — pointee cagiran tarafta yasar.
_variant_t r8Ref(double* p) {
  _variant_t v;
  v.vt = VT_R8 | VT_BYREF;
  v.pdblVal = p;
  return v;
}

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;
}

double sayiYap(_variant_t& v) {
  v.ChangeType(VT_R8);
  return v.dblVal;
}

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

double sayiOku(const FikomNesne& n, const wchar_t* ad) {
  _variant_t v = n.ozellik(ad);
  return sayiYap(v);
}

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

Parametre oznitelikAl(FikomNesne& n, const std::wstring& ad) {
  return Parametre(nesneYap(n.metod(L"GetAttribute", {vt(ad)})));
}

double prmSayi(Parametre p) {
  _variant_t v = p.degeri();
  return sayiYap(v);
}

bool prmBool(Parametre p) {
  _variant_t v = p.degeri();
  return boolYap(v);
}

double paramSayiOku(Parametreler prm, const wchar_t* ad) { return prmSayi(prm.eleman(ad)); }
bool paramBoolOku(Parametreler prm, const wchar_t* ad) { return prmBool(prm.eleman(ad)); }

void paramSayiYaz(Parametreler prm, const wchar_t* ad, double v) {
  prm.eleman(ad).degeriAyarla(_variant_t(v));
}

void paramBoolYaz(Parametreler prm, const wchar_t* ad, bool v) {
  prm.eleman(ad).degeriAyarla(_variant_t(v));
}

// ---- Mod <-> CATIA dizgi cevirimleri -----------------------------------------

struct ModEs {
  int deger;
  const wchar_t* kod;
};

template <typename E, size_t N>
const wchar_t* modKodu(const ModEs (&tablo)[N], E deger) {
  for (const auto& es : tablo)
    if (es.deger == (int)deger) return es.kod;
  return L"";
}

template <typename E, size_t N>
E modCoz(const ModEs (&tablo)[N], const std::wstring& kod, E varsayilan) {
  for (const auto& es : tablo)
    if (kod == es.kod) return (E)es.deger;
  return varsayilan;
}

constexpr ModEs kIlerlemeGecis[] = {
    {(int)IlerlemeGecisModu::Isleme, L"MfgTransitionMachiningFeedrate"},
    {(int)IlerlemeGecisModu::Yaklasma, L"MfgTransitionApproachFeedrate"},
    {(int)IlerlemeGecisModu::YatayDonus, L"MfgTransitionLeadInFeedrate"},
    {(int)IlerlemeGecisModu::Uzaklasma, L"MfgTransitionRetractFeedrate"},
    {(int)IlerlemeGecisModu::DikeyDonus, L"MfgTransitionLiftOffFeedrate"},
    {(int)IlerlemeGecisModu::Hizli, L"MfgTransitionRapidFeedrate"},
    {(int)IlerlemeGecisModu::Lokal, L"MfgTransitionLocalFeedrate"},
    {(int)IlerlemeGecisModu::Finis, L"MfgTransitionFinishingFeedrate"},
    {(int)IlerlemeGecisModu::HavaKesme, L"MfgTransitionAirCuttingFeedrate"},
};

constexpr ModEs kHatveModu[] = {
    {(int)HatveModu::DalmaMiktari, L"MfgMaxDepthOfCut"},
    {(int)HatveModu::Tekrarli, L"MfgNumberOfLevels"},
    {(int)HatveModu::TekrarliDalmaMiktarli, L"MfgNumberOfLevelsNoTop"},
};

constexpr ModEs kCapIsleme[] = {
    {(int)CapIslemeModu::Helisel, L"MfgCircularMillingHelical"},
    {(int)CapIslemeModu::Standart, L"MfgCircularMillingStandard"},
};

constexpr ModEs kHelis[] = {
    {(int)HelisModu::Acisal, L"MfgHelixAngle"},
    {(int)HelisModu::Adimsal, L"MfgHelixPitch"},
};

constexpr ModEs kCokluHatve[] = {
    {(int)CokluHatveModu::TekrarliHatve, L"M3xMultiPassModeByNumberAndDepth"},
    {(int)CokluHatveModu::TekrarliDerinlik, L"M3xMultiPassModeByNumberAndTotal"},
    {(int)CokluHatveModu::HatveliDerinlik, L"M3xMultiPassModeByDepthAndTotal"},
};

constexpr ModEs kDikeyHatve[] = {
    {(int)DikeyHatveModu::Sabit, L"M3xStepOverModeZLevelConstant"},
    {(int)DikeyHatveModu::Tarak, L"M3xStepOverModeZLevelViaScallopHeight"},
    {(int)DikeyHatveModu::KonturUzaklik, L"M3xStepOverModeZLevelContour"},
    {(int)DikeyHatveModu::MaksimumUzaklik, L"M3xStepOverModeZLevelMaximum"},
};

constexpr ModEs kDerinlikTipi[] = {
    {(int)DerinlikTipi::UcaGore, L"MfgDepthTip"},
    {(int)DerinlikTipi::KesmeYerineGore, L"MfgDepthShoulder"},
};

constexpr ModEs kNoktalama[] = {
    {(int)NoktalamaTipi::Yok, L"MfgPlungeDefault"},
    {(int)NoktalamaTipi::UcaGore, L"MfgPlungeTip"},
    {(int)NoktalamaTipi::CapaGore, L"MfgPlungeDiameter"},
};

constexpr ModEs kBekleme[] = {
    {(int)BeklemeModu::Yok, L"MfgDwellDefault"},
    {(int)BeklemeModu::DevreGore, L"MfgDwellRound"},
    {(int)BeklemeModu::ZamanaGore, L"MfgDwellTime"},
};

constexpr ModEs kKesmeYonu[] = {
    {(int)KesmeYonu::Tirmanma, L"MfgClimb"},
    {(int)KesmeYonu::Konvensiyonel, L"MfgConventional"},
};

constexpr ModEs kCapDonmeTipi[] = {
    {(int)CapDonmeTipi::Helisel, L"MfgCircularMillingHelical"},
    {(int)CapDonmeTipi::Standart, L"MfgCircularMillingStandard"},
};

constexpr ModEs kTalasVerme[] = {
    {(int)TalasVermeModu::TalasMiktarinaGore, L"MfgMaxDepthOfCut"},
    {(int)TalasVermeModu::TekrarSayisinaGore, L"MfgNumberOfLevels"},
    {(int)TalasVermeModu::UstOlmadanTekrarSayisinaGore, L"MfgNumberOfLevelsNoTop"},
};

constexpr ModEs kIslemSirasi[] = {
    {(int)IslemSirasiModu::IlkYatay, L"MfgRadialFirst"},
    {(int)IslemSirasiModu::IlkDikey, L"MfgAxialFirst"},
};

constexpr ModEs kIslemModu3D[] = {
    {(int)IslemModu3D::Duzlemler, L"M3xHardMachiningModeByPlane"},
    {(int)IslemModu3D::SadeceCepler, L"M3xHardMachiningModePocketsOnly"},
    {(int)IslemModu3D::SadeceDisHat, L"M3xHardMachiningModeExternalOnly"},
    {(int)IslemModu3D::CeplerVeDisHat, L"M3xHardMachiningModeExternalPockets"},
    {(int)IslemModu3D::DuzlemeGoreSadeceCepler, L"M3xHardMachiningModeByPlPocketsOnly"},
    {(int)IslemModu3D::DuzlemeGoreSadeceDisHat, L"M3xHardMachiningModeByPlExternalOnly"},
    {(int)IslemModu3D::DuzlemeGoreCeplerVeDisHat, L"M3xHardMachiningModeByPlExternalPockets"},
};

constexpr ModEs kTakimTuru[] = {
    {(int)TakimTuru::Normal, L"MfgEndMillTool"},
    {(int)TakimTuru::Yuzey, L"MfgFaceMillTool"},
    {(int)TakimTuru::Konik, L"MfgConicalMillTool"},
    {(int)TakimTuru::Matkap, L"MfgDrillTool"},
    {(int)TakimTuru::Nokta, L"MfgSpotDrillTool"},
    {(int)TakimTuru::Punta, L"MfgCenterDrillTool"},
    {(int)TakimTuru::CiftCapMatkap, L"MfgMultiDiamDrillTool"},
    {(int)TakimTuru::Havsa, L"MfgCountersinkTool"},
    {(int)TakimTuru::Tap, L"MfgTapTool"},
    {(int)TakimTuru::CiftTarafPah, L"MfgTwoSidesChamferingTool"},
    {(int)TakimTuru::DelikPah, L"MfgBoringAndChamferingTool"},
    {(int)TakimTuru::Bara, L"MfgBoringBarTool"},
    {(int)TakimTuru::Rayba, L"MfgReamerTool"},
    {(int)TakimTuru::TCakisi, L"MfgTSlotterTool"},
    {(int)TakimTuru::Kilavuz, L"MfgThreadMillTool"},
    {(int)TakimTuru::KafaMatkabi, L"MfgCounterboreMillTool"},
    {(int)TakimTuru::VarilTakimi, L"MfgBarrelMillTool"},
    {(int)TakimTuru::TopTakimi, L"MfgBallStylusTool"},
    {(int)TakimTuru::SilindirTakim, L"MfgCylinderStylusTool"},
};

constexpr ModEs kTakimTurIsmi[] = {
    {(int)TakimTuru::Normal, L"Frezeleme Takımı"},
    {(int)TakimTuru::Yuzey, L"Yüzey Traşlama Takımı"},
    {(int)TakimTuru::Konik, L"Konik Takım"},
    {(int)TakimTuru::Matkap, L"Matkap"},
    {(int)TakimTuru::Nokta, L"Nokta Takımı"},
    {(int)TakimTuru::Punta, L"Punta Matkabı"},
    {(int)TakimTuru::CiftCapMatkap, L"Kademeli Matkap"},
    {(int)TakimTuru::Havsa, L"Havşa Matkabı"},
    {(int)TakimTuru::Tap, L"Tap Takımı"},
    {(int)TakimTuru::CiftTarafPah, L"Çift Taraflı Pah Takımı"},
    {(int)TakimTuru::DelikPah, L"Havşalı Matkap"},
    {(int)TakimTuru::Bara, L"Bara Takımı"},
    {(int)TakimTuru::Rayba, L"Rayba"},
    {(int)TakimTuru::TCakisi, L"T Kanal Takımı"},
    {(int)TakimTuru::Kilavuz, L"Kılavuz Takımı"},
    {(int)TakimTuru::KafaMatkabi, L"Kafa Matkabı"},
    {(int)TakimTuru::VarilTakimi, L"Varil Takımı"},
    {(int)TakimTuru::TopTakimi, L"Küresel Top Takımı"},
    {(int)TakimTuru::SilindirTakim, L"Silindir Takım"},
};

constexpr ModEs kHizTipi[] = {
    {(int)HizTipi::Yok, L"None"},
    {(int)HizTipi::Isleme, L"Machining"},
    {(int)HizTipi::Yaklasma, L"Approach"},
    {(int)HizTipi::Uzaklasma, L"Retract"},
    {(int)HizTipi::Hizli, L"RAPID"},
    {(int)HizTipi::Lokal, L"Local"},
};

// ---- Operasyon tipi -> parametre tablosu (IMfgOperasyonlar modullerinin portu) --

enum class HatveKurali {
  Yok,
  Derinlik,           // GetAGeometricAttribute("Depth")
  MaksDalma,          // "Max depth of cut"
  MaksDerinlik,       // "Maximum depth of cut"
  MaksKesmeIlerleme,  // "Maximum cutting progress"
  EksenselStrateji,   // "Axial strategy" moduna gore
  CokluPaso,          // "Mode of input for Multi-Pass" moduna gore
  ZSeviye,            // "Stepover mode" moduna gore
  AdvZSeviye,         // "Maximum distance"
  SeviyeVeDerinlik,   // "Number of levels" + "Maximum depth of cut"
  DerinlikVeSeviye,   // "Maximum depth of cut" + "Number of levels"
  DalmaAktifse,       // "Active max. plunge distance" ise "Max. plunge distance"
  CapIsleme,          // "Machining mode" moduna gore (CircularMilling)
};

enum class YanalKurali { Yok, Radyal, MaksUzaklik, YolVeAralik };

struct OpSatir {
  const wchar_t* tur;
  HatveKurali hatve;
  bool cevreOffset;  // "Offset on Contour"
  bool yuzeyOffset;  // "Offset on part"
  YanalKurali yanal;
};

constexpr OpSatir kOpTablosu[] = {
    {L"Boring", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"BoringAndChamfering", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"BoringSpindleStop", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"Chamfering2Sides", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"CircularMilling", HatveKurali::CapIsleme, false, false, YanalKurali::Yok},
    {L"CounterBoring", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"CounterSinking", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"Drilling", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"DrillingBreakChips", HatveKurali::MaksDalma, false, false, YanalKurali::Yok},
    {L"DrillingDeepHole", HatveKurali::MaksDalma, false, false, YanalKurali::Yok},
    {L"DrillingDwellDelay", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"Facing", HatveKurali::EksenselStrateji, false, false, YanalKurali::Yok},
    {L"GrooveMilling", HatveKurali::EksenselStrateji, false, false, YanalKurali::Yok},
    {L"M3xAdvZLevel", HatveKurali::AdvZSeviye, false, true, YanalKurali::Radyal},
    {L"M3xBetweenContour", HatveKurali::CokluPaso, false, true, YanalKurali::Yok},
    {L"M3xBitangency", HatveKurali::CokluPaso, false, true, YanalKurali::Yok},
    {L"M3xCavitiesMachining", HatveKurali::MaksDerinlik, false, true, YanalKurali::Yok},
    {L"M3xHardMaterial", HatveKurali::MaksDerinlik, false, true, YanalKurali::Yok},
    {L"M3xMultiPockets", HatveKurali::MaksDerinlik, false, true, YanalKurali::Yok},
    {L"M3xPlungeMilling", HatveKurali::MaksKesmeIlerleme, false, true, YanalKurali::Yok},
    {L"M3xSoftMaterial", HatveKurali::MaksDerinlik, false, true, YanalKurali::Yok},
    {L"M3xSpiralMilling", HatveKurali::CokluPaso, false, true, YanalKurali::MaksUzaklik},
    {L"M3xSweeping", HatveKurali::CokluPaso, false, true, YanalKurali::MaksUzaklik},
    {L"M3xZLevel", HatveKurali::ZSeviye, false, true, YanalKurali::Yok},
    {L"Mfg4AxisCurveSweeping", HatveKurali::DalmaAktifse, false, false, YanalKurali::Yok},
    {L"Mfg4XPocketingOperation", HatveKurali::EksenselStrateji, false, false, YanalKurali::Yok},
    {L"Mfg5AxisContourDriven", HatveKurali::Yok, false, false, YanalKurali::Yok},
    {L"Mfg5AxisCurveMachining", HatveKurali::SeviyeVeDerinlik, false, false, YanalKurali::Yok},
    {L"Mfg5AxisFlankContouring", HatveKurali::SeviyeVeDerinlik, false, false, YanalKurali::Yok},
    {L"Mfg5AxisGuidedCutting", HatveKurali::Yok, false, false, YanalKurali::Yok},
    {L"Mfg5AxisHelixMachining", HatveKurali::Yok, false, false, YanalKurali::Yok},
    {L"Mfg5AxisIsoparMachining", HatveKurali::Yok, false, false, YanalKurali::Yok},
    {L"Mfg5AxisMultiPocketsFlank", HatveKurali::MaksDerinlik, false, false, YanalKurali::Yok},
    {L"Mfg5AxisSpiralMilling", HatveKurali::DerinlikVeSeviye, false, false, YanalKurali::Yok},
    {L"MfgFollowCurve", HatveKurali::SeviyeVeDerinlik, false, false, YanalKurali::Yok},
    {L"MfgSequentialAxialOperation", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"MfgSequentialGrooveOperation", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"Pocketing", HatveKurali::EksenselStrateji, true, false, YanalKurali::Yok},
    {L"ProfileContouring", HatveKurali::EksenselStrateji, true, false, YanalKurali::YolVeAralik},
    {L"Reaming", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"ReverseThreading", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"SpotDrilling", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"TSlotting", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"Tapping", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"ThreadMilling", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
    {L"ThreadWithoutTapHead", HatveKurali::Derinlik, false, false, YanalKurali::Yok},
};

const OpSatir* opSatirBul(const std::wstring& tur) {
  for (const auto& satir : kOpTablosu)
    if (tur == satir.tur) return &satir;
  return nullptr;
}

std::vector<Parametre> eksenselHatve(Parametreler prm) {
  const HatveModu mod =
      modCoz(kHatveModu, prm.eleman(L"Axial strategy").degeriStr(), HatveModu::Bilinmiyor);
  switch (mod) {
    case HatveModu::DalmaMiktari: return {prm.eleman(L"Maximum depth of cut")};
    case HatveModu::Tekrarli: return {prm.eleman(L"Number of levels")};
    case HatveModu::TekrarliDalmaMiktarli:
      return {prm.eleman(L"Number of levels"), prm.eleman(L"Maximum depth of cut")};
    default: return {};
  }
}

std::vector<Parametre> cokluPasoHatve(Parametreler prm) {
  const CokluHatveModu mod =
      modCoz(kCokluHatve, prm.eleman(L"Mode of input for Multi-Pass").degeriStr(),
             CokluHatveModu::Bilinmiyor);
  switch (mod) {
    case CokluHatveModu::TekrarliHatve:
      return {prm.eleman(L"Number of levels for Multi-Pass"),
              prm.eleman(L"Depth of cut by level for Multi-Pass")};
    case CokluHatveModu::TekrarliDerinlik:
      return {prm.eleman(L"Number of levels for Multi-Pass"),
              prm.eleman(L"Total height for Multi-Pass")};
    case CokluHatveModu::HatveliDerinlik:
      return {prm.eleman(L"Depth of cut by level for Multi-Pass"),
              prm.eleman(L"Total height for Multi-Pass")};
    default: return {};
  }
}

std::vector<Parametre> zSeviyeHatve(Parametreler prm) {
  const DikeyHatveModu mod =
      modCoz(kDikeyHatve, prm.eleman(L"Stepover mode").degeriStr(), DikeyHatveModu::Bilinmiyor);
  switch (mod) {
    case DikeyHatveModu::Sabit:
      return {prm.eleman(L"Maximum distance"), prm.eleman(L"Scallop height")};
    case DikeyHatveModu::Tarak:
    case DikeyHatveModu::KonturUzaklik:
      return {prm.eleman(L"Maximum distance"), prm.eleman(L"Minimum step distance"),
              prm.eleman(L"Scallop height")};
    case DikeyHatveModu::MaksimumUzaklik: return {prm.eleman(L"Maximum distance")};
    default: return {};
  }
}

std::wstring sayiMetni(double d) { return std::format(L"{}", d); }

}  // namespace

// ---- Serbest cevirim fonksiyonlari -------------------------------------------

const wchar_t* takimTuruKodu(TakimTuru tur) { return modKodu(kTakimTuru, tur); }
const wchar_t* takimTuruIsmi(TakimTuru tur) { return modKodu(kTakimTurIsmi, tur); }
TakimTuru takimTuruCoz(const std::wstring& kod) {
  return modCoz(kTakimTuru, kod, TakimTuru::Bilinmiyor);
}
const wchar_t* ilerlemeGecisModuKodu(IlerlemeGecisModu mod) { return modKodu(kIlerlemeGecis, mod); }
IlerlemeGecisModu ilerlemeGecisModuCoz(const std::wstring& kod) {
  return modCoz(kIlerlemeGecis, kod, IlerlemeGecisModu::Bilinmiyor);
}
const wchar_t* hizTipiKodu(HizTipi tip) { return modKodu(kHizTipi, tip); }

// ---- MfgTakimDogrulayicisi ----------------------------------------------------

double MfgTakimDogrulayicisi::capi() const { return sayiOku(com_, L"Diameter"); }

void MfgTakimDogrulayicisi::degerleriAyarla(const std::wstring& nokta, long numara, long uzunlukNo,
                                            long radiusNo, double cap) {
  com_.metod(L"SetValues", {vt(nokta), vt(numara), vt(uzunlukNo), vt(radiusNo), vt(cap)});
}

// ---- MfgTakim -----------------------------------------------------------------

std::wstring MfgTakim::nlsIsmi(const std::wstring& oznitelik) {
  _variant_t v = com_.metod(L"GetAttributeNLSName", {vt(oznitelik)});
  return metinYap(v);
}

Parametre MfgTakim::parametre(const std::wstring& oznitelik) { return oznitelikAl(com_, oznitelik); }

MfgTakimDogrulayicisi MfgTakim::yeniDogrulayici() {
  return MfgTakimDogrulayicisi(nesneYap(com_.metod(L"AddCorrector")));
}

MfgTakimDogrulayicisi MfgTakim::dogrulayici(long indeks) {
  return MfgTakimDogrulayicisi(nesneYap(com_.metod(L"GetCorrector", {vt(indeks)})));
}

std::wstring MfgTakim::toStr() {
  std::wstring rslt;
  switch (turu()) {
    case TakimTuru::Normal:
    case TakimTuru::Yuzey: {
      rslt = L"Ø" + sayiMetni(prmSayi(anmaCapi()));
      const double r = prmSayi(radius());
      if (r > 0) rslt += L" R" + sayiMetni(r);
      rslt += L" " + turIsmi();
      break;
    }
    case TakimTuru::Matkap:
    case TakimTuru::Rayba:
    case TakimTuru::Punta:
    case TakimTuru::Nokta:
      rslt = L"Ø" + sayiMetni(prmSayi(anmaCapi())) + L" " + turIsmi();
      break;
    case TakimTuru::Konik: rslt = L"Çizgi / Kalem Takımı (Konik Takım)"; break;
    case TakimTuru::TCakisi: rslt = L"T - Çakısı (Slot Çakısı)"; break;
    case TakimTuru::Kilavuz:
      rslt = L"M" + sayiMetni(prmSayi(parametre(L"MFG_OUTSIDE_DIAM"))) + L" Kılavuz";
      break;
    case TakimTuru::KafaMatkabi: {
      rslt = L"DØ" + sayiMetni(prmSayi(anmaCapi()));
      const double giris = prmSayi(parametre(L"MFG_ENTRY_DIAM"));
      if (giris > 0) rslt += L"<->dØ" + sayiMetni(giris);
      rslt += L" Kafa Matkabı";
      break;
    }
    default: break;
  }
  return rslt + L" (" + ismi() + L")";
}

std::wstring MfgTakim::toStr2() {
  std::wstring rslt;
  switch (turu()) {
    case TakimTuru::Normal:
    case TakimTuru::Yuzey: {
      const double cap = prmSayi(anmaCapi());
      rslt = L"Ø" + sayiMetni(cap);
      const double r = prmSayi(radius());
      if (r > 0)
        rslt += (r < cap / 2) ? (L" R" + sayiMetni(r)) : std::wstring(L" Küre");
      else
        rslt += L" Düz";
      break;
    }
    case TakimTuru::Matkap: rslt = L"Ø" + sayiMetni(prmSayi(anmaCapi())) + L" Matkap"; break;
    case TakimTuru::Rayba: rslt = L"Ø" + sayiMetni(prmSayi(anmaCapi())) + L" Rayba"; break;
    case TakimTuru::Punta: rslt = L"Ø" + sayiMetni(prmSayi(anmaCapi())); break;
    case TakimTuru::Konik: rslt = L"Çizgi Takımı"; break;
    case TakimTuru::TCakisi:
      rslt = L"Ø" + sayiMetni(prmSayi(anmaCapi())) + L"x" + sayiMetni(prmSayi(boyu())) + L" T";
      break;
    case TakimTuru::Kilavuz:
      rslt = L"M" + sayiMetni(prmSayi(parametre(L"MFG_OUTSIDE_DIAM"))) + L" Kılavuz";
      break;
    case TakimTuru::KafaMatkabi: {
      rslt = L"DØ" + sayiMetni(prmSayi(anmaCapi()));
      const double giris = prmSayi(parametre(L"MFG_ENTRY_DIAM"));
      if (giris > 0) rslt += L"<->dØ" + sayiMetni(giris);
      break;
    }
    case TakimTuru::Nokta:
      rslt = L"Ø" + sayiMetni(prmSayi(anmaCapi())) + L" " + turIsmi();
      break;
    default: break;
  }
  return rslt;
}

// ---- OprDelikTabani -----------------------------------------------------------

Parametre OprDelikTabani::oznitelik(const std::wstring& ad) { return oznitelikAl(com_, ad); }

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

DerinlikTipi OprDelikTabani::derinlikModu() {
  return modCoz(kDerinlikTipi, oznitelik(L"MFG_DEPTH_MODE").degeriStr(),
                DerinlikTipi::KesmeYerineGore);
}

void OprDelikTabani::derinlikModuAyarla(DerinlikTipi v) {
  oznitelik(L"MFG_DEPTH_MODE").degeriStrAyarla(modKodu(kDerinlikTipi, v));
}

NoktalamaTipi OprDelikTabani::noktalamaModu() {
  return modCoz(kNoktalama, oznitelik(L"MFG_PLUNGE_MODE").degeriStr(), NoktalamaTipi::CapaGore);
}

void OprDelikTabani::noktalamaModuAyarla(NoktalamaTipi v) {
  oznitelik(L"MFG_PLUNGE_MODE").degeriStrAyarla(modKodu(kNoktalama, v));
}

Parametre OprDelikTabani::yaklasmaHizi() { return parametreler().eleman(L"Approach feedrate"); }
Parametre OprDelikTabani::yaklasmaHiziG0() {
  return parametreler().eleman(L"Rapid approach feedrate");
}
Parametre OprDelikTabani::gagalamaHizi() { return parametreler().eleman(L"Plunge feedrate"); }
Parametre OprDelikTabani::gagalamaHiziG0() {
  return parametreler().eleman(L"Rapid plunge feedrate");
}
Parametre OprDelikTabani::islemeHizi() { return parametreler().eleman(L"Machining feedrate"); }
Parametre OprDelikTabani::uzaklasmaHizi() { return parametreler().eleman(L"Retract feedrate"); }
Parametre OprDelikTabani::uzaklasmaHiziG0() {
  return parametreler().eleman(L"Rapid retract feedrate");
}
Parametre OprDelikTabani::gecisHiziModuAktif() {
  return parametreler().eleman(L"MFG_FEED_SELECT_TRANSITION");
}
Parametre OprDelikTabani::gecisHiziModu() {
  return parametreler().eleman(L"MFG_FEED_TYPE_TRANSITION");
}
Parametre OprDelikTabani::gecisHiziLokal() {
  return parametreler().eleman(L"MFG_LOCAL_FEED_TRANSITION_VALUE");
}
Parametre OprDelikTabani::hizBirimi() { return parametreler().eleman(L"Feedrate unit"); }
Parametre OprDelikTabani::hizOtomatikAktif() {
  return parametreler().eleman(L"Automatic compute from tooling Feeds and Speeds");
}
Parametre OprDelikTabani::devirOtomatikAktif() {
  return parametreler().eleman(L"Automatic compute from tooling Feeds and Speeds");
}
Parametre OprDelikTabani::devirAktif() { return parametreler().eleman(L"Spindle output"); }
Parametre OprDelikTabani::devirSayisi() { return parametreler().eleman(L"Machining spindle"); }
Parametre OprDelikTabani::devirBirimi() { return parametreler().eleman(L"Spindle unit"); }
Parametre OprDelikTabani::delikSiralamasiTersCevir() {
  return parametreler().eleman(L"Inverse pattern ordering");
}
Parametre OprDelikTabani::delikMerkeziYenidenLimitle() {
  return parametreler().eleman(L"Relimit hole origin");
}
Parametre OprDelikTabani::farkliDerinlikleriDikkateAl() {
  return parametreler().eleman(L"Machine different depths");
}
Parametre OprDelikTabani::korDerinlikleriDikkateAl() {
  return parametreler().eleman(L"Machine blind/through holes");
}

// ---- OprPunta / OprBeklemeliDelik ----------------------------------------------

BeklemeModu OprPunta::beklemeModu() {
  return modCoz(kBekleme, oznitelik(L"MFG_DWELL_MODE").degeriStr(), BeklemeModu::Yok);
}

void OprPunta::beklemeModuAyarla(BeklemeModu v) {
  oznitelik(L"MFG_DWELL_MODE").degeriStrAyarla(modKodu(kBekleme, v));
}

BeklemeModu OprBeklemeliDelik::beklemeModu() {
  return modCoz(kBekleme, oznitelik(L"MFG_DWELL_MODE").degeriStr(), BeklemeModu::Yok);
}

void OprBeklemeliDelik::beklemeModuAyarla(BeklemeModu v) {
  oznitelik(L"MFG_DWELL_MODE").degeriStrAyarla(modKodu(kBekleme, v));
}

// ---- OprCapDonme ----------------------------------------------------------------

KesmeYonu OprCapDonme::kesmeYonu() {
  return modCoz(kKesmeYonu, oznitelik(L"MfgDirectionOfCut").degeriStr(), KesmeYonu::Konvensiyonel);
}

void OprCapDonme::kesmeYonuAyarla(KesmeYonu v) {
  oznitelik(L"MfgDirectionOfCut").degeriStrAyarla(modKodu(kKesmeYonu, v));
}

CapDonmeTipi OprCapDonme::capDonmeTipi() {
  return modCoz(kCapDonmeTipi, oznitelik(L"MfgCircularMillingMode").degeriStr(),
                CapDonmeTipi::Standart);
}

void OprCapDonme::capDonmeTipiAyarla(CapDonmeTipi v) {
  oznitelik(L"MfgCircularMillingMode").degeriStrAyarla(modKodu(kCapDonmeTipi, v));
}

TalasVermeModu OprCapDonme::talasVermeModu() {
  return modCoz(kTalasVerme, oznitelik(L"MfgAxialStrategy").degeriStr(),
                TalasVermeModu::UstOlmadanTekrarSayisinaGore);
}

void OprCapDonme::talasVermeModuAyarla(TalasVermeModu v) {
  oznitelik(L"MfgAxialStrategy").degeriStrAyarla(modKodu(kTalasVerme, v));
}

IslemSirasiModu OprCapDonme::islemSirasiModu() {
  return modCoz(kIslemSirasi, oznitelik(L"MfgSequencing").degeriStr(), IslemSirasiModu::IlkYatay);
}

void OprCapDonme::islemSirasiModuAyarla(IslemSirasiModu v) {
  oznitelik(L"MfgSequencing").degeriStrAyarla(modKodu(kIslemSirasi, v));
}

// ---- OprM3xHardMaterial / OprPPInstruction --------------------------------------

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

Parametre OprM3xHardMaterial::islemeModuParametre() {
  return parametreler().eleman(L"Machining mode");
}

IslemModu3D OprM3xHardMaterial::islemeModu() {
  return modCoz(kIslemModu3D, islemeModuParametre().degeriStr(), IslemModu3D::Bilinmiyor);
}

void OprM3xHardMaterial::islemeModuAyarla(IslemModu3D v) {
  islemeModuParametre().degeriStrAyarla(modKodu(kIslemModu3D, v));
}

Parametre OprPPInstruction::kodlar() {
  return Parametreler(com_.nesne(L"Parameters")).eleman(L"PP words syntax");
}

// ---- MfgOperasyon ---------------------------------------------------------------

void MfgOperasyon::makroEkseneDikMesafeEkle(const std::wstring& ismi, double degeri) {
  com_.metod(L"AddDistanceAlongAxis", {vt(ismi), vt(degeri)});
}

void MfgOperasyon::makroEkseneDikMesafeHizEkle(const std::wstring& ismi, double degeri,
                                               HizTipi hizTipi) {
  com_.metod(L"AddDistanceAlongAxisFeed",
             {vt(ismi), vt(degeri), _variant_t(hizTipiKodu(hizTipi)), vt(3000L)});
}

void MfgOperasyon::makroEkseneYatayMesafeEkle(const std::wstring& ismi, double mesafe, double aci1,
                                              double aci2) {
  com_.metod(L"AddGotoHorizontal", {vt(ismi), vt(mesafe), vt(aci1), vt(aci2)});
}

// ---- Aktivite -------------------------------------------------------------------

bool Aktivite::gecerliTur() const {
  const std::wstring t = turu();
  return t != L"ToolChange" && t != L"Start" && t != L"Stop" && t != L"PPInstruction";
}

bool Aktivite::aktif() const { return boolOku(com_, L"Active"); }

void Aktivite::takimAyarla(const MfgTakim& t) { com_.ozellikAyarla(L"Tool", dv(t.com())); }

XYZ Aktivite::takimYonu() {
  XYZ yon{-1.0, -1.0, -1.0};
  try {
    com_.metod(L"GetToolAxis", {r8Ref(&yon.x), r8Ref(&yon.y), r8Ref(&yon.z)});
  } catch (const FikomHata&) {
    return XYZ{-1.0, -1.0, -1.0};
  }
  return yon;
}

void Aktivite::takimYonuAyarla(const XYZ& yon) {
  com_.metod(L"SetToolAxis", {vt(yon.x), vt(yon.y), vt(yon.z)});
}

std::array<double, 2> Aktivite::takimBoyu() {
  std::array<double, 2> boy{-1.0, -1.0};
  try {
    com_.metod(L"GetToolGage", {r8Ref(&boy[0]), r8Ref(&boy[1])});
  } catch (const FikomHata&) {
    boy = {-1.0, -1.0};
  }
  return boy;
}

bool Aktivite::hesaplatilmis() const { return sayiOku(com_, L"CalculatedCycleTime") != 0.0; }

IslemeSuresi Aktivite::islemeSuresi() const {
  IslemeSuresi s;
  s.toplamIslemeSuresi = sayiOku(com_, L"CalculatedCycleTime");
  s.toplamGecisSuresi = sayiOku(com_, L"CycleTime");
  s.islemeSuresi = sayiOku(com_, L"MachiningTime") * 60.0;
  s.toplamSure = sayiOku(com_, L"TotalTime") * 60.0;
  return s;
}

bool Aktivite::ucBoyutluMu() const {
  std::wstring t = turu();
  std::transform(t.begin(), t.end(), t.begin(),
                 [](wchar_t c) { return (wchar_t)std::towupper(c); });
  return t.rfind(L"M3X", 0) == 0;
}

bool Aktivite::besEksenMi() const {
  std::wstring t = turu();
  std::transform(t.begin(), t.end(), t.begin(),
                 [](wchar_t c) { return (wchar_t)std::towupper(c); });
  return t.rfind(L"MFG5AXIS", 0) == 0;
}

double Aktivite::devir() { return paramSayiOku(parametreler(), L"Machining spindle"); }
void Aktivite::devirAyarla(double v) { paramSayiYaz(parametreler(), L"Machining spindle", v); }

double Aktivite::ilerlemeIsleme() {
  try {
    return paramSayiOku(parametreler(), L"Machining feedrate");
  } catch (const FikomHata&) {
    return 0.0;
  }
}

void Aktivite::ilerlemeIslemeAyarla(double v) {
  paramSayiYaz(parametreler(), L"Machining feedrate", v);
}

double Aktivite::ilerlemeYaklasma() {
  try {
    return paramSayiOku(parametreler(), L"Approach feedrate");
  } catch (const FikomHata&) {
    return 0.0;
  }
}

void Aktivite::ilerlemeYaklasmaAyarla(double v) {
  paramSayiYaz(parametreler(), L"Approach feedrate", v);
}

double Aktivite::ilerlemeUzaklasma() {
  try {
    return paramSayiOku(parametreler(), L"Retract feedrate");
  } catch (const FikomHata&) {
    return 0.0;
  }
}

void Aktivite::ilerlemeUzaklasmaAyarla(double v) {
  paramSayiYaz(parametreler(), L"Retract feedrate", v);
}

double Aktivite::ilerlemeFinis() {
  const std::wstring t = turu();
  if (t != L"Pocketing" && t != L"ProfileContouring" && t != L"Facing") return 0.0;
  try {
    return paramSayiOku(parametreler(), L"Finishing feedrate");
  } catch (const FikomHata&) {
    return 0.0;
  }
}

void Aktivite::ilerlemeFinisAyarla(double v) {
  paramSayiYaz(parametreler(), L"Finishing feedrate", v);
}

bool Aktivite::ilerlemeGecisAktif() {
  return paramBoolOku(parametreler(), L"MFG_FEED_SELECT_TRANSITION");
}

void Aktivite::ilerlemeGecisAktifAyarla(bool v) {
  paramBoolYaz(parametreler(), L"MFG_FEED_SELECT_TRANSITION", v);
}

IlerlemeGecisModu Aktivite::ilerlemeGecisModu() {
  return ilerlemeGecisModuCoz(parametreler().eleman(L"MFG_FEED_TYPE_TRANSITION").degeriStr());
}

void Aktivite::ilerlemeGecisModuAyarla(IlerlemeGecisModu v) {
  parametreler().eleman(L"MFG_FEED_TYPE_TRANSITION").degeriStrAyarla(ilerlemeGecisModuKodu(v));
}

double Aktivite::ilerlemeGecis() {
  Parametreler prm = parametreler();
  if (!prm.parametreVarmi(L"MFG_LOCAL_FEED_TRANSITION_VALUE")) return 0.0;
  return prmSayi(prm.eleman(L"MFG_LOCAL_FEED_TRANSITION_VALUE"));
}

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

std::vector<Parametre> Aktivite::hatve() {
  const OpSatir* satir = opSatirBul(turu());
  if (!satir || satir->hatve == HatveKurali::Yok) return {};
  if (satir->hatve == HatveKurali::Derinlik) {
    return {Parametre(nesneYap(com_.metod(L"GetAGeometricAttribute", {vt(L"Depth")})))};
  }
  Parametreler prm = parametreler();
  switch (satir->hatve) {
    case HatveKurali::MaksDalma: return {prm.eleman(L"Max depth of cut")};
    case HatveKurali::MaksDerinlik: return {prm.eleman(L"Maximum depth of cut")};
    case HatveKurali::MaksKesmeIlerleme: return {prm.eleman(L"Maximum cutting progress")};
    case HatveKurali::EksenselStrateji: return eksenselHatve(prm);
    case HatveKurali::CokluPaso: return cokluPasoHatve(prm);
    case HatveKurali::ZSeviye: return zSeviyeHatve(prm);
    case HatveKurali::AdvZSeviye:
      return {prm.eleman(L"Maximum distance"), prm.eleman(L"Maximum distance")};
    case HatveKurali::SeviyeVeDerinlik:
      return {prm.eleman(L"Number of levels"), prm.eleman(L"Maximum depth of cut")};
    case HatveKurali::DerinlikVeSeviye:
      return {prm.eleman(L"Maximum depth of cut"), prm.eleman(L"Number of levels")};
    case HatveKurali::DalmaAktifse: {
      if (prmBool(prm.eleman(L"Active max. plunge distance")))
        return {prm.eleman(L"Max. plunge distance")};
      return {};
    }
    case HatveKurali::CapIsleme: {
      const CapIslemeModu mod =
          modCoz(kCapIsleme, prm.eleman(L"Machining mode").degeriStr(), CapIslemeModu::Bilinmiyor);
      if (mod == CapIslemeModu::Standart) return eksenselHatve(prm);
      if (mod == CapIslemeModu::Helisel) {
        // CATIA parametre isimlerindeki sondaki bosluklar kasitli (orijinal veri).
        const HelisModu helis =
            modCoz(kHelis, prm.eleman(L"Helix mode ").degeriStr(), HelisModu::Bilinmiyor);
        if (helis == HelisModu::Acisal) return {prm.eleman(L"Helix angle ")};
        if (helis == HelisModu::Adimsal) return {prm.eleman(L"Helix pitch ")};
      }
      return {};
    }
    default: return {};
  }
}

Parametre Aktivite::cevreOffset() {
  if (!ikiBoyutluMu()) return {};
  const OpSatir* satir = opSatirBul(turu());
  if (!satir || !satir->cevreOffset) return {};
  return parametreler().eleman(L"Offset on Contour");
}

Parametre Aktivite::yuzeyOffset() {
  if (ikiBoyutluMu()) return {};
  const OpSatir* satir = opSatirBul(turu());
  if (!satir || !satir->yuzeyOffset) return {};
  return parametreler().eleman(L"Offset on part");
}

std::vector<Parametre> Aktivite::yanalAdim() {
  const OpSatir* satir = opSatirBul(turu());
  if (!satir) return {};
  Parametreler prm = parametreler();
  switch (satir->yanal) {
    case YanalKurali::Radyal: return {prm.eleman(L"M3xRadialStepDistance")};
    case YanalKurali::MaksUzaklik: return {prm.eleman(L"Maximum distance")};
    case YanalKurali::YolVeAralik:
      return {prm.eleman(L"Number of paths"), prm.eleman(L"Distance between paths")};
    default: return {};
  }
}

// ---- Aktiviteler ------------------------------------------------------------------

long Aktiviteler::adet() const { return com_.nesne(L"Activities").adet(); }

Aktivite Aktiviteler::ekle(const std::wstring& aktiviteIsmi) {
  return Aktivite(nesneYap(com_.metod(L"AppendOperation", {vt(aktiviteIsmi), vt(1L)})));
}

Aktivite Aktiviteler::eleman(long indeks) const {
  FikomNesne akts = com_.nesne(L"Activities");
  return Aktivite(nesneYap(akts.metod(L"GetElement", {vt(indeks + 1)})));
}

std::vector<Aktivite> Aktiviteler::hepsi() const {
  std::vector<Aktivite> liste;
  const long n = adet();
  liste.reserve((size_t)n);
  for (long i = 0; i < n; ++i) liste.push_back(eleman(i));
  return liste;
}

bool Aktiviteler::farkliAciVarmi() {
  bool eskiVar = false;
  XYZ eskiYon;
  const long n = adet();
  for (long i = 0; i < n; ++i) {
    Aktivite akt = eleman(i);
    if (akt.turu() == L"ToolChange") continue;
    const XYZ yon = akt.takimYonu();
    if (!eskiVar) {
      eskiYon = yon;
      eskiVar = true;
    } else if (!(eskiYon == yon)) {
      return true;
    }
  }
  return false;
}

// ---- Program -----------------------------------------------------------------------

ProcessDokuman Program::processDokuman() const { return ProcessDokuman(com_.nesne(L"Parent")); }

bool Program::aktif() const { return boolOku(com_, L"Active"); }

bool Program::bos() const { return aktiviteler().adet() == 0; }

bool Program::isimsiz() const { return ismi().find(L"Manufacturing ") != std::wstring::npos; }

bool Program::aciklamali() const {
  const std::wstring a = aciklama();
  return a != L"No Description" && !a.empty();
}

std::vector<std::wstring> Program::aktiviteTurleri() const {
  std::vector<std::wstring> liste;
  for (const Aktivite& akt : aktiviteler().hepsi()) liste.push_back(akt.turu());
  return liste;
}

bool Program::hesaplatilmamisVarMi() const {
  for (const Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.gecerliTur() && !akt.hesaplatilmis()) return true;
  }
  return false;
}

double Program::toplamIslemeSuresi() const {
  double toplam = 0.0;
  for (const Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.gecerliTur() && akt.hesaplatilmis()) {
      const IslemeSuresi s = akt.islemeSuresi();
      toplam += s.toplamGecisSuresi + s.toplamSure;
    }
  }
  return toplam;
}

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

FikomNesne Program::ekleKod(const std::wstring& kod) {
  return nesneYap(com_.metod(L"AddPPInstruction", {vt(kod)}));
}

void Program::nesneTasi(const FikomNesne& referans, const FikomNesne& tasinacak) {
  com_.metod(L"MoveOperation", {dv(referans), dv(tasinacak)});
}

Aktivite Program::operasyonEkle(const std::wstring& opIsmi, long oto) {
  return Aktivite(nesneYap(com_.metod(L"AppendOperation", {vt(opIsmi), vt(oto)})));
}

long Program::indexPo() const {
  const long poSayisi = processDokuman().partOperasyonlari().adet();
  FikomNesne oncekiler = com_.nesne(L"PossiblePrecedenceActivities");
  long poSayac = 0;
  const long n = oncekiler.adet();
  for (long i = 0; i < n; ++i) {
    const std::wstring tur = oncekiler.eleman(i + 1).metin(L"Type");
    if (tur == L"ManufacturingSetup") {
      ++poSayac;
      if (poSayac > poSayisi) break;
    } else if (tur != L"MachiningProcessList") {
      break;
    }
  }
  return poSayac;
}

PartOperasyonu Program::poTespit() const {
  return processDokuman().partOperasyonlari().eleman(indexPo());
}

std::vector<std::wstring> Program::takimlar() {
  std::vector<std::wstring> liste;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.turu() == L"ToolChange") liste.push_back(akt.takim().toStr());
  }
  return liste;
}

std::vector<std::wstring> Program::takimlar2() {
  std::vector<std::wstring> liste;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.turu() != L"ToolChange") liste.push_back(akt.takim().toStr2());
  }
  return liste;
}

bool Program::magazinli() const {
  long sayac = 0;
  for (const Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.turu() == L"ToolChange" && ++sayac > 1) return true;
  }
  return false;
}

std::vector<std::wstring> Program::operasyonBoyutlari() {
  std::vector<std::wstring> liste;
  auto ekleTekil = [&liste](const wchar_t* b) {
    for (const auto& v : liste)
      if (v == b) return;
    liste.push_back(b);
  };
  for (const Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.turu() == L"ToolChange") continue;
    if (akt.besEksenMi())
      ekleTekil(L"5D");
    else if (akt.ucBoyutluMu())
      ekleTekil(L"3D");
    else
      ekleTekil(L"2D");
  }
  return liste;
}

bool Program::gonderilmismi() { return parametreler().parametreVarmi(L"Gonderilmismi"); }

double Program::enBuyukTakimBoyu() {
  double enBuyuk = 0.0;
  bool var = false;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (!akt.gecerliTur()) continue;
    const double boy = akt.takimBoyu()[0];
    if (!var || boy > enBuyuk) enBuyuk = boy;
    var = true;
  }
  return var ? enBuyuk : 0.0;
}

double Program::enYuksekIlerleme() {
  double enYuksek = 0.0;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.gecerliTur()) enYuksek = std::max(enYuksek, akt.ilerlemeIsleme());
  }
  return enYuksek;
}

double Program::enYuksekDevir() {
  double enYuksek = 0.0;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (akt.gecerliTur()) enYuksek = std::max(enYuksek, akt.devir());
  }
  return enYuksek;
}

double Program::enYuksekHatve() {
  double enYuksek = 0.0;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (!akt.gecerliTur()) continue;
    double deger = 0.0;
    try {
      std::vector<Parametre> h = akt.hatve();
      if (!h.empty()) deger = prmSayi(h.back());
    } catch (const FikomHata&) {
      deger = 0.0;
    }
    enYuksek = std::max(enYuksek, deger);
  }
  return enYuksek;
}

double Program::enDusukCevreOffset() {
  double enDusuk = 0.0;
  bool var = false;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (!akt.gecerliTur()) continue;
    double deger = 0.0;
    try {
      Parametre p = akt.cevreOffset();
      if (p.gecerli()) deger = prmSayi(p);
    } catch (const FikomHata&) {
      deger = 0.0;
    }
    if (!var || deger < enDusuk) enDusuk = deger;
    var = true;
  }
  return var ? enDusuk : 0.0;
}

double Program::enDusukYuzeyOffset() {
  double enDusuk = 0.0;
  bool var = false;
  for (Aktivite& akt : aktiviteler().hepsi()) {
    if (!akt.gecerliTur()) continue;
    double deger = 0.0;
    try {
      Parametre p = akt.yuzeyOffset();
      if (p.gecerli()) deger = prmSayi(p);
    } catch (const FikomHata&) {
      deger = 0.0;
    }
    if (!var || deger < enDusuk) enDusuk = deger;
    var = true;
  }
  return var ? enDusuk : 0.0;
}

bool Program::farkliAciVarMi() { return aktiviteler().farkliAciVarmi(); }

std::wstring Program::hataKodlari() {
  std::wstring rslt;
  if (takimlar().size() > 1) rslt = L"[M]";
  if (farkliAciVarMi()) rslt += L"[A]";
  if (hesaplatilmamisVarMi()) rslt += L"[H]";
  return rslt.empty() ? L"Yok" : rslt;
}

void Program::magazinKodlariEkle() {
  Aktiviteler akts = aktiviteler();
  const long n = akts.adet();
  std::wstring liste = L"INSERT (*** FIKOYT TAKIMLAR ***)";
  for (long i = 0; i < n; ++i) {
    Aktivite akt = akts.eleman(i);
    if (akt.turu() != L"ToolChange") continue;
    MfgTakim tkm = akt.takim();
    std::wstring ad = tkm.ismi();
    std::transform(ad.begin(), ad.end(), ad.begin(),
                   [](wchar_t c) { return (wchar_t)std::towupper(c); });
    liste += L"\n" + std::format(L"INSERT (T{:<2} {})", tkm.takimNo(), ad);
  }
  liste += L"\nINSERT (*** ********** ***)";

  if (n > 0) {
    Aktivite ilk = akts.eleman(0);
    if (ilk.ismi().find(L"FikoYT Takımlar") != std::wstring::npos) {
      ilk.asOperasyon().asPPInstruction().kodlar().degeriAyarla(_variant_t(liste.c_str()));
      return;
    }
    FikomNesne ppins = ekleKod(liste);
    ppins.ozellikAyarla(L"Name", _variant_t(L"*** FikoYT Takımlar ***"));
    nesneTasi(ilk.com(), ppins);
    return;
  }
  FikomNesne ppins = ekleKod(liste);
  ppins.ozellikAyarla(L"Name", _variant_t(L"*** FikoYT Takımlar ***"));
}

// ---- Programlar -----------------------------------------------------------------------

long Programlar::adet() const { return com_.nesne(L"Programs").adet(); }

Program Programlar::eleman(long indeks) const {
  FikomNesne prgler = com_.nesne(L"Programs");
  return Program(nesneYap(prgler.metod(L"GetElement", {vt(indeks + 1)})));
}

std::vector<Program> Programlar::hepsi() const {
  std::vector<Program> liste;
  const long n = adet();
  liste.reserve((size_t)n);
  for (long i = 0; i < n; ++i) liste.push_back(eleman(i));
  return liste;
}

void Programlar::tumunuAktifYap() {
  for (Program& prg : hepsi()) prg.aktifAyarla(true);
}

void Programlar::tumunuDeaktifYap() {
  for (Program& prg : hepsi()) prg.aktifAyarla(false);
}

void Programlar::tumunuKilitle() {
  for (Program& prg : hepsi()) {
    if (prg.aktiviteler().adet() > 0) prg.kilitle();
  }
}

void Programlar::tumKilidiAc() {
  for (Program& prg : hepsi()) {
    if (prg.aktiviteler().adet() > 0) prg.kilidiAc();
  }
}

std::vector<std::wstring> Programlar::aktifProgramlar() const {
  std::vector<std::wstring> liste;
  for (const Program& prg : hepsi())
    if (prg.aktif()) liste.push_back(prg.ismi());
  return liste;
}

std::vector<std::wstring> Programlar::deAktifProgramlar() const {
  std::vector<std::wstring> liste;
  for (const Program& prg : hepsi())
    if (!prg.aktif()) liste.push_back(prg.ismi());
  return liste;
}

std::vector<std::wstring> Programlar::isimliProgramlar() const {
  std::vector<std::wstring> liste;
  for (const Program& prg : hepsi())
    if (!prg.isimsiz()) liste.push_back(prg.ismi());
  return liste;
}

std::vector<std::wstring> Programlar::isimsizProgramlar() const {
  std::vector<std::wstring> liste;
  for (const Program& prg : hepsi())
    if (prg.isimsiz()) liste.push_back(prg.ismi());
  return liste;
}

// ---- Makine -----------------------------------------------------------------------------

std::wstring Makine::makineIsmi() { return oznitelikAl(com_, L"MFG_NAME").degeriStr(); }
void Makine::makineIsmiAyarla(const std::wstring& v) {
  oznitelikAl(com_, L"MFG_NAME").degeriStrAyarla(v);
}
std::wstring Makine::postTuru() { return oznitelikAl(com_, L"MFG_OUTPUT_TYPE").degeriStr(); }
void Makine::postTuruAyarla(const std::wstring& v) {
  oznitelikAl(com_, L"MFG_OUTPUT_TYPE").degeriStrAyarla(v);
}
std::wstring Makine::interpolasyonDairesel2d() {
  return oznitelikAl(com_, L"MFG_INT_CIRC_2D").degeriStr();
}
void Makine::interpolasyonDairesel2dAyarla(const std::wstring& v) {
  oznitelikAl(com_, L"MFG_INT_CIRC_2D").degeriStrAyarla(v);
}
std::wstring Makine::interpolasyonDuzlemsel3d() {
  return oznitelikAl(com_, L"MFG_INT_LIN_3D").degeriStr();
}
void Makine::interpolasyonDuzlemsel3dAyarla(const std::wstring& v) {
  oznitelikAl(com_, L"MFG_INT_LIN_3D").degeriStrAyarla(v);
}
std::wstring Makine::maksIslemeHizi() { return oznitelikAl(com_, L"MFG_MAX_FEEDRATE").degeriStr(); }
void Makine::maksIslemeHiziAyarla(double v) {
  oznitelikAl(com_, L"MFG_MAX_FEEDRATE").degeriAyarla(_variant_t(v));
}
std::wstring Makine::maksBostakiHizi() { return oznitelikAl(com_, L"MFG_RAPID_FEED").degeriStr(); }
void Makine::maksBostakiHiziAyarla(double v) {
  oznitelikAl(com_, L"MFG_RAPID_FEED").degeriAyarla(_variant_t(v));
}
void Makine::aciklamaAyarla(const std::wstring& v) {
  oznitelikAl(com_, L"MFG_COMMENT").degeriStrAyarla(v);
}

// ---- MakineIslemeEkseni ------------------------------------------------------------------

XYZ MakineIslemeEkseni::merkez() {
  XYZ v;
  com_.metod(L"GetOriginPoint", {r8Ref(&v.x), r8Ref(&v.y), r8Ref(&v.z)});
  return v;
}

void MakineIslemeEkseni::merkezAyarla(const XYZ& v) {
  com_.metod(L"SetOriginPointByCoordinates", {vt(v.x), vt(v.y), vt(v.z)});
}

XYZ MakineIslemeEkseni::x() {
  XYZ v;
  com_.metod(L"GetOriginXDirection", {r8Ref(&v.x), r8Ref(&v.y), r8Ref(&v.z)});
  return v;
}

void MakineIslemeEkseni::xAyarla(const XYZ& v) {
  com_.metod(L"SetOriginXDirection", {vt(v.x), vt(v.y), vt(v.z)});
}

XYZ MakineIslemeEkseni::y() {
  XYZ v;
  com_.metod(L"GetOriginYDirection", {r8Ref(&v.x), r8Ref(&v.y), r8Ref(&v.z)});
  return v;
}

void MakineIslemeEkseni::yAyarla(const XYZ& v) {
  com_.metod(L"SetOriginYDirection", {vt(v.x), vt(v.y), vt(v.z)});
}

XYZ MakineIslemeEkseni::z() {
  XYZ v;
  com_.metod(L"GetOriginZDirection", {r8Ref(&v.x), r8Ref(&v.y), r8Ref(&v.z)});
  return v;
}

void MakineIslemeEkseni::zAyarla(const XYZ& v) {
  com_.metod(L"SetOriginZDirection", {vt(v.x), vt(v.y), vt(v.z)});
}

void MakineIslemeEkseni::eksenSec(const FikomNesne& eksen, const FikomNesne& product) {
  com_.metod(L"SetPartAxisSystem", {dv(eksen), dv(product)});
}

// ---- PartOperasyonu ----------------------------------------------------------------------

bool PartOperasyonu::aktif() const { return boolOku(com_, L"Active"); }

ProcessDokuman PartOperasyonu::processDokuman() const {
  return ProcessDokuman(com_.nesne(L"Parent").nesne(L"Parent"));
}

long PartOperasyonu::dizaynGeometriSayisi() {
  _variant_t v = com_.metod(L"DesignGeometriesCount");
  v.ChangeType(VT_I4);
  return v.lVal;
}

long PartOperasyonu::fiksturGeometriSayisi() {
  _variant_t v = com_.metod(L"FixtureGeometriesCount");
  v.ChangeType(VT_I4);
  return v.lVal;
}

long PartOperasyonu::islemModelSayisi() {
  _variant_t v = com_.metod(L"InProcessModelBodiesCount");
  v.ChangeType(VT_I4);
  return v.lVal;
}

long PartOperasyonu::kutukSayisi() {
  _variant_t v = com_.metod(L"StockGeometriesCount");
  v.ChangeType(VT_I4);
  return v.lVal;
}

std::wstring PartOperasyonu::partIsmi() {
  try {
    _variant_t v = com_.metod(L"GetPartName");
    return metinYap(v);
  } catch (const FikomHata&) {
    return {};
  }
}

Makine PartOperasyonu::makineYarat(const std::wstring& ismi, const std::wstring& postTuru,
                                   const std::wstring& tezgah) {
  FikomNesne mkn = nesneYap(com_.metod(L"CreateMachine", {vt(ismi)}));
  oznitelikAl(mkn, L"MFG_OUTPUT_TYPE").degeriStrAyarla(postTuru);
  mkn.ozellikAyarla(L"PPTableName", vt(tezgah));
  return Makine(mkn);
}

std::wstring PartOperasyonu::eksenIsmi() const {
  return com_.nesne(L"MachiningAxisSystem").metin(L"Name");
}

void PartOperasyonu::eksenIsmiAyarla(const std::wstring& v) {
  com_.nesne(L"MachiningAxisSystem").ozellikAyarla(L"Name", vt(v));
}

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

Product PartOperasyonu::urunDokumani() {
  return Product(nesneYap(com_.metod(L"GetProductInstance")));
}

void PartOperasyonu::urunDokumaniAyarla(const FikomNesne& product) {
  com_.metod(L"SetProductAndReconciliate", {dv(product)});
}

bool PartOperasyonu::carpmaKontrolu() {
  return paramBoolOku(parametreler(), L"Activate collisions checking");
}
void PartOperasyonu::carpmaKontroluAyarla(bool v) {
  paramBoolYaz(parametreler(), L"Activate collisions checking", v);
}
bool PartOperasyonu::carpmaDizaynKontrolu() {
  return paramBoolOku(parametreler(), L"Collisions checking on design part");
}
void PartOperasyonu::carpmaDizaynKontroluAyarla(bool v) {
  paramBoolYaz(parametreler(), L"Collisions checking on design part", v);
}
bool PartOperasyonu::carpmaFiksturKontrolu() {
  return paramBoolOku(parametreler(), L"Collisions checking on fixtures");
}
void PartOperasyonu::carpmaFiksturKontroluAyarla(bool v) {
  paramBoolYaz(parametreler(), L"Collisions checking on fixtures", v);
}
bool PartOperasyonu::carpmaKutukKontrolu() {
  return paramBoolOku(parametreler(), L"Collisions checking on input stock");
}
void PartOperasyonu::carpmaKutukKontroluAyarla(bool v) {
  paramBoolYaz(parametreler(), L"Collisions checking on input stock", v);
}
double PartOperasyonu::carpmaTakimOffset() {
  return paramSayiOku(parametreler(), L"Offset on tool shank");
}
void PartOperasyonu::carpmaTakimOffsetAyarla(double v) {
  paramSayiYaz(parametreler(), L"Offset on tool shank", v);
}
double PartOperasyonu::carpmaTutucuOffset() {
  return paramSayiOku(parametreler(), L"Offset on tool assembly");
}
void PartOperasyonu::carpmaTutucuOffsetAyarla(double v) {
  paramSayiYaz(parametreler(), L"Offset on tool assembly", v);
}
bool PartOperasyonu::kutukTakibi() {
  return paramBoolOku(parametreler(), L"MfgIntermediateStockIsActive");
}
void PartOperasyonu::kutukTakibiAyarla(bool v) {
  paramBoolYaz(parametreler(), L"MfgIntermediateStockIsActive", v);
}
double PartOperasyonu::kutukTakibiGecis() {
  return paramSayiOku(parametreler(), L"MfgSafetyDistanceOnStock");
}
void PartOperasyonu::kutukTakibiGecisAyarla(double v) {
  paramSayiYaz(parametreler(), L"MfgSafetyDistanceOnStock", v);
}

XYZ PartOperasyonu::takimDegisimKoordinatlari() {
  Parametreler prm = parametreler();
  return XYZ{prmSayi(prm.eleman(L"Tool change point X")),
             prmSayi(prm.eleman(L"Tool change point Y")),
             prmSayi(prm.eleman(L"Tool change point Z"))};
}

void PartOperasyonu::takimDegisimKoordinatlariAyarla(const XYZ& v) {
  Parametreler prm = parametreler();
  prm.eleman(L"Tool change point X").degeriAyarla(_variant_t(v.x));
  prm.eleman(L"Tool change point Y").degeriAyarla(_variant_t(v.y));
  prm.eleman(L"Tool change point Z").degeriAyarla(_variant_t(v.z));
}

bool PartOperasyonu::takimDegisimKoordinatlariAktif() {
  return paramBoolOku(parametreler(), L"Tool change point");
}

void PartOperasyonu::takimDegisimKoordinatlariAktifAyarla(bool v) {
  paramBoolYaz(parametreler(), L"Tool change point", v);
}

XYZ PartOperasyonu::referansKoordinatlari() {
  Parametreler prm = parametreler();
  return XYZ{prmSayi(prm.eleman(L"MfgSetUpHomePointX")),
             prmSayi(prm.eleman(L"MfgSetUpHomePointY")),
             prmSayi(prm.eleman(L"MfgSetUpHomePointZ"))};
}

void PartOperasyonu::referansKoordinatlariAyarla(const XYZ& v) {
  Parametreler prm = parametreler();
  prm.eleman(L"MfgSetUpHomePointX").degeriAyarla(_variant_t(v.x));
  prm.eleman(L"MfgSetUpHomePointY").degeriAyarla(_variant_t(v.y));
  prm.eleman(L"MfgSetUpHomePointZ").degeriAyarla(_variant_t(v.z));
}

XYZ PartOperasyonu::referansYonu() {
  Parametreler prm = parametreler();
  return XYZ{prmSayi(prm.eleman(L"MfgSetUpHomePointI")),
             prmSayi(prm.eleman(L"MfgSetUpHomePointJ")),
             prmSayi(prm.eleman(L"MfgSetUpHomePointK"))};
}

void PartOperasyonu::referansYonuAyarla(const XYZ& v) {
  Parametreler prm = parametreler();
  prm.eleman(L"MfgSetUpHomePointI").degeriAyarla(_variant_t(v.x));
  prm.eleman(L"MfgSetUpHomePointJ").degeriAyarla(_variant_t(v.y));
  prm.eleman(L"MfgSetUpHomePointK").degeriAyarla(_variant_t(v.z));
}

bool PartOperasyonu::referansKoordinatlariAktif() {
  return paramBoolOku(parametreler(), L"MfgUseMachineHomePoint");
}

void PartOperasyonu::referansKoordinatlariAktifAyarla(bool v) {
  paramBoolYaz(parametreler(), L"MfgUseMachineHomePoint", v);
}

XYZ PartOperasyonu::tablaMerkezKoordinatlari() {
  Parametreler prm = parametreler();
  return XYZ{prmSayi(prm.eleman(L"SetUp delta X")), prmSayi(prm.eleman(L"SetUp delta Y")),
             prmSayi(prm.eleman(L"SetUp delta Z"))};
}

void PartOperasyonu::tablaMerkezKoordinatlariAyarla(const XYZ& v) {
  Parametreler prm = parametreler();
  prm.eleman(L"SetUp delta X").degeriAyarla(_variant_t(v.x));
  prm.eleman(L"SetUp delta Y").degeriAyarla(_variant_t(v.y));
  prm.eleman(L"SetUp delta Z").degeriAyarla(_variant_t(v.z));
}

double PartOperasyonu::simulasyonKutukHassasiyeti() {
  return paramSayiOku(parametreler(), L"Stocks Accuracy");
}

void PartOperasyonu::simulasyonKutukHassasiyetiAyarla(double v) {
  paramSayiYaz(parametreler(), L"Stocks Accuracy", v);
}

double PartOperasyonu::dizaynHassasiyeti() {
  return paramSayiOku(parametreler(), L"Designs Accuracy");
}

void PartOperasyonu::dizaynHassasiyetiAyarla(double v) {
  paramSayiYaz(parametreler(), L"Designs Accuracy", v);
}

MfgGorunum PartOperasyonu::mfgGorunum() {
  return MfgGorunum(nesneYap(com_.metod(L"GetManufacturingView")));
}

// ---- PartOperasyonlari -------------------------------------------------------------------

long PartOperasyonlari::adet() const {
  FikomNesne cocuklar = com_.nesne(L"ChildrenActivities");
  const long n = cocuklar.adet();
  long sayac = 0;
  for (long i = 0; i < n; ++i) {
    FikomNesne cocuk = cocuklar.eleman(i + 1);
    _variant_t v = cocuk.metod(L"IsSubTypeOf", {vt(L"ManufacturingSetup")});
    if (boolYap(v)) ++sayac;
  }
  return sayac;
}

PartOperasyonu PartOperasyonlari::eleman(long indeks) const {
  FikomNesne cocuklar = com_.nesne(L"ChildrenActivities");
  const long n = cocuklar.adet();
  long sayac = 0;
  for (long i = 0; i < n; ++i) {
    FikomNesne cocuk = cocuklar.eleman(i + 1);
    _variant_t v = cocuk.metod(L"IsSubTypeOf", {vt(L"ManufacturingSetup")});
    if (boolYap(v) && ++sayac == indeks + 1) return PartOperasyonu(cocuk);
  }
  return {};
}

std::vector<PartOperasyonu> PartOperasyonlari::hepsi() const {
  std::vector<PartOperasyonu> liste;
  const long n = adet();
  liste.reserve((size_t)n);
  for (long i = 0; i < n; ++i) liste.push_back(eleman(i));
  return liste;
}

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

// ---- MfgProcess / ProcessDokuman ---------------------------------------------------------

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

PartOperasyonlari ProcessDokuman::partOperasyonlari(long process) const {
  return PartOperasyonlari(asPPR().processler().eleman(process).com());
}

bool ProcessDokuman::seciliProgramVarMi() const {
  Secililer secim = secililer();
  const long n = secim.adet2();
  for (long i = 0; i < n; ++i) {
    if (secim.eleman2(i).turu() == L"ManufacturingProgram") return true;
  }
  return false;
}

std::vector<Program> ProcessDokuman::seciliProgramlar() const {
  std::vector<Program> liste;
  Secililer secim = secililer();
  const long n = secim.adet2();
  for (long i = 0; i < n; ++i) {
    SeciliEleman el = secim.eleman2(i);
    if (el.turu() == L"ManufacturingProgram") liste.push_back(Program(el.nesne()));
  }
  return liste;
}

std::vector<Program> ProcessDokuman::tumProgramlar() const {
  std::vector<Program> liste;
  for (const PartOperasyonu& po : partOperasyonlari().hepsi()) {
    for (Program& prg : po.programlar().hepsi()) liste.push_back(std::move(prg));
  }
  return liste;
}

std::vector<std::wstring> ProcessDokuman::tumProgramlarListe() const {
  std::vector<std::wstring> liste;
  for (const Program& prg : tumProgramlar()) liste.push_back(prg.ismi());
  return liste;
}

long ProcessDokuman::tumProgramSayisi() const {
  long toplam = 0;
  for (const PartOperasyonu& po : partOperasyonlari().hepsi()) toplam += po.programlar().adet();
  return toplam;
}

// ---- MfgGorunum / MfgOzellikler / MfgOzellik ---------------------------------------------

Parametre MfgOzellik::alCizimselDegerler(const std::wstring& ismi) {
  return Parametre(nesneYap(com_.metod(L"GetAGeometricAttribute", {vt(ismi)})));
}

FikomNesne MfgOzellikler::ekle(const std::wstring& tip) {
  return nesneYap(com_.metod(L"Add", {vt(tip)}));
}

void MfgGorunum::udfSonucundanIslenebilirAlanYarat(const FikomNesne& referansProduct) {
  com_.metod(L"CreateAllMachinableAreaFeaturesFromTechResultsOfUDF", {dv(referansProduct)});
}

}  // namespace fikatia