#include "com/model/aci_modeli.hpp"

#include <cmath>
#include <cstdlib>
#include <format>

namespace fikatia {

namespace {

// ---- vector3d.py portu (yalniz kullanilan kisim) --------------------------------

constexpr double kKucuk = 1e-6;
constexpr double kPi = 3.14159265358979323846;

struct Vek {
  double x = 0.0, y = 0.0, z = 0.0;
};

Vek vek(const XYZ& v) { return {v.x, v.y, v.z}; }
double nokta(const Vek& a, const Vek& b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
Vek carpim(const Vek& a, const Vek& b) {
  return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
}
double boy(const Vek& a) { return std::sqrt(nokta(a, a)); }
Vek fark(const Vek& a, const Vek& b) { return {a.x - b.x, a.y - b.y, a.z - b.z}; }
Vek olcek(const Vek& a, double s) { return {a.x * s, a.y * s, a.z * s}; }

Vek paralel(const Vek& v, const Vek& eksen) {
  const double L = boy(eksen);
  if (L < kKucuk) return v;
  return olcek(eksen, nokta(v, eksen) / L / L);
}

Vek dikBilesen(const Vek& v, const Vek& eksen) { return fark(v, paralel(v, eksen)); }

double vekAci(const Vek& a, const Vek& b) {
  const double la = boy(a), lb = boy(b);
  if (la * lb < 1e-6) return 0.0;
  const double c = nokta(a, b) / la / lb;
  if (c >= 1.0) return 0.0;
  if (c <= -1.0) return kPi;
  return std::acos(c);
}

double vekDihedral(const Vek& a, const Vek& eksen, const Vek& c) {
  const Vek ap = dikBilesen(a, eksen);
  const Vek cp = dikBilesen(c, eksen);
  double aci = vekAci(ap, cp);
  if (nokta(carpim(ap, cp), eksen) > 0.0) aci = -aci;
  return aci;
}

double dereceye(double rad) { return rad * 180.0 / kPi; }

// crossTool = Z x takim; sonuc = dihedral(crossTool, Z, referans); NaN → 0 (Python).
double dihedralDerece(const Vek& referans, const Vek& eksenZ, const Vek& takim) {
  const Vek crossTool = carpim(eksenZ, takim);
  double r = vekDihedral(crossTool, eksenZ, referans);
  if (std::isnan(r)) r = 0.0;
  return dereceye(r);
}

// Python round esdegeri (yarim-cift): varsayilan FE_TONEAREST modu.
double yuvarlaCift(double v) { return std::nearbyint(v); }
double yuvarla5(double v) { return yuvarlaCift(v * 1e5) / 1e5; }

// ---- COM yardimcilari ------------------------------------------------------------

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

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

double prmSayi(Parametreler& prm, const wchar_t* ad) {
  _variant_t v = prm.eleman(ad).degeri();
  return sayiYap(v);
}

void prmYaz(Parametreler& prm, const wchar_t* ad, double deger) {
  prm.eleman(ad).degeriAyarla(_variant_t(deger));
}

void prmYaz(Parametreler& prm, const wchar_t* ad, bool deger) {
  prm.eleman(ad).degeriAyarla(_variant_t(deger));
}

// FikoDll (CATPart) cozucu oturumu: dosyayi acar, part + parametrelere erisim verir.
struct FikoDllOturum {
  Dokuman dok;
  Part part;
  Parametreler prm;
};

FikoDllOturum fikoDllAc(FikomNesne& uygulama, const std::wstring& klasor,
                        const wchar_t* dosya) {
  std::wstring yol = klasor;
  if (!yol.empty() && yol.back() != L'\\') yol += L'\\';
  yol += dosya;
  FikoDllOturum o;
  o.dok = Dokumanlar(uygulama.nesne(L"Documents")).oku(yol);
  o.part = o.dok.asPartDokuman().part();
  o.prm = o.part.parametreler();
  return o;
}

// Python: islem oncesi DisplayFileAlerts=False, sonrasi True (kosulsuz geri acilir).
struct UyariSusturucu {
  FikomNesne* uygulama;
  explicit UyariSusturucu(FikomNesne& u) : uygulama(&u) {
    u.ozellikAyarla(L"DisplayFileAlerts", _variant_t(false));
  }
  ~UyariSusturucu() {
    try {
      uygulama->ozellikAyarla(L"DisplayFileAlerts", _variant_t(true));
    } catch (...) {
    }
  }
  UyariSusturucu(const UyariSusturucu&) = delete;
  UyariSusturucu& operator=(const UyariSusturucu&) = delete;
};

// "12,5mm" → 12.5 (Python: "mm" sil, virgul → nokta, float()).
double mmSayi(std::wstring s) {
  size_t p;
  while ((p = s.find(L"mm")) != std::wstring::npos) s.erase(p, 2);
  for (auto& ch : s)
    if (ch == L',') ch = L'.';
  return std::wcstod(s.c_str(), nullptr);
}

std::array<double, 3> dizi3(const XYZ& v) { return {v.x, v.y, v.z}; }

// Src/WBK cozumlerinden sonra "YeniEksen__" parametre matrisi: {O, X, Y, Z}.
std::array<XYZ, 4> yeniEksenMatrisi(Parametreler& prm) {
  auto oku = [&](const wchar_t* x, const wchar_t* y, const wchar_t* z) -> XYZ {
    return {prmSayi(prm, x), prmSayi(prm, y), prmSayi(prm, z)};
  };
  return {oku(L"YeniEksenOX", L"YeniEksenOY", L"YeniEksenOZ"),
          oku(L"YeniEksenXX", L"YeniEksenXY", L"YeniEksenXZ"),
          oku(L"YeniEksenYX", L"YeniEksenYY", L"YeniEksenYZ"),
          oku(L"YeniEksenZX", L"YeniEksenZY", L"YeniEksenZZ")};
}

}  // namespace

// ---- Salt aci matematigi -----------------------------------------------------------

EksenVektorleri eksenVektorleriAl(MakineIslemeEkseni eksen) {
  return {eksen.x(), eksen.y(), eksen.z(), eksen.merkez()};
}

namespace aci_hesap {

double xAcisi(const EksenVektorleri& eksen, const XYZ& takimYonu) {
  return dihedralDerece(vek(eksen.x), vek(eksen.z), vek(takimYonu));
}

double saltUstAci(const EksenVektorleri& eksen, const XYZ& takimYonu) {
  return dihedralDerece(vek(eksen.y), vek(eksen.z), vek(takimYonu));
}

double altAci(const EksenVektorleri& eksen, const XYZ& takimYonu) {
  const XYZ& z = eksen.z;
  const XYZ& t = takimYonu;
  const double payda =
      std::sqrt((z.x * z.x + z.y * z.y + z.z * z.z) * (t.x * t.x + t.y * t.y + t.z * t.z));
  // Python kaynaginda bolme yalniz son carpima uygulanir; clamp de yoktur — BIREBIR.
  return dereceye(std::acos(z.x * t.x + z.y * t.y + z.z * t.z / payda));
}

int sektor(double saltUstAciDeg, double xAcisiDeg) {
  const double u = yuvarla5(saltUstAciDeg);
  const double x = yuvarla5(xAcisiDeg);
  int s = 0;

  // Kosullar Python kaynagindan BIREBIR (olu gorunen kollar dahil).
  if (u < 0 && x < 0) {
    if (!(x == 0.0) && !(u == -90.0)) s = 1;
  }
  if (u > 0 && x < 0) {
    if (!(u == 0.0) && !(x == 90.0)) {
      if (!(u == 180.0) && !(x == -90.0)) s = 2;
    }
  }
  if (u > 0 && x > 0) {
    if (!(x == 180.0) && !(u == 90.0)) s = 3;
  }
  if (u < 0 && x > 0) s = 4;

  if (s == 0) {
    if (u == 0.0 && x == 0.0) s = 5;   // dik
    if (u == 0.0 && x == 90.0) s = 6;  // x eksi (Python'daki 0 ve -0 kollari ozdes)
    if (u == 180.0 && x == -90.0) s = 9;
    if (x == 180.0 && u == 90.0) s = 7;  // y eksi
    if (x == 0.0 && u == -90.0) s = 8;
  }
  return s;
}

double ustAci(double saltUstAciDeg, double xAcisiDeg, int sektorNo) {
  double ustA = saltUstAciDeg;
  if (sektorNo == 1) ustA = std::fabs(xAcisiDeg);
  if (sektorNo == 2) ustA = std::fabs(xAcisiDeg);
  if (sektorNo == 3) ustA = (180.0 - std::fabs(saltUstAciDeg)) + 90.0;
  if (sektorNo == 4) ustA = 360.0 - std::fabs(xAcisiDeg);
  if (sektorNo == 5) ustA = 0.0;
  if (sektorNo == 6) ustA = 270.0;
  if (sektorNo == 7) ustA = 180.0;
  if (sektorNo == 8) ustA = 0.0;
  if (sektorNo == 9) ustA = 90.0;
  return ustA;
}

double ustAci(const EksenVektorleri& eksen, const XYZ& takimYonu) {
  const double salt = saltUstAci(eksen, takimYonu);
  const double x = xAcisi(eksen, takimYonu);
  return ustAci(salt, x, sektor(salt, x));
}

double kafaAdiminaYuvarla(double aciDeg, double adim) {
  return yuvarlaCift(aciDeg / adim) * adim;
}

}  // namespace aci_hesap

// ---- FikoACAci (Wtec) ---------------------------------------------------------------

bool FikoACAci::dikAciBul(double ustAciDeg, double altAciDeg, ACAciSonuc& sonuc) {
  bool bulundu = false;
  auto ata = [&](double a, double c) {
    sonuc.a = a;
    sonuc.c = c;
    sonuc.islenebilir = true;
    sonuc.dik = true;
    bulundu = true;
  };
  if (ustAciDeg == 0.0 && altAciDeg == 90.0) ata(90.0, 180.0);
  if (ustAciDeg == 90.0 && altAciDeg == 90.0) ata(0.0, 180.0);
  if (ustAciDeg == 180.0 && altAciDeg == 90.0) ata(270.0, 180.0);
  if (ustAciDeg == 270.0 && altAciDeg == 90.0) ata(180.0, 180.0);
  if (ustAciDeg == 0.0 && altAciDeg == 0.0) ata(0.0, 0.0);
  return bulundu;
}

std::pair<double, double> FikoACAci::saltAciAl(double ustAciDeg, double altAciDeg) {
  UyariSusturucu sustur(uygulama_);
  FikoDllOturum o = fikoDllAc(uygulama_, klasor_, L"WBK.FikoDll");
  prmYaz(o.prm, L"Ust", ustAciDeg);
  prmYaz(o.prm, L"Alt", altAciDeg);
  o.part.guncelle();
  const double b = prmSayi(o.prm, L"B-ACISI");
  const double c = prmSayi(o.prm, L"C-ACISI");
  o.dok.kapat();
  return {b, c};
}

ACAciSonuc FikoACAci::acilar(double ustAciDeg, double altAciDeg) {
  ACAciSonuc sonuc;
  dikAciBul(ustAciDeg, altAciDeg, sonuc);
  if (!islenebilir(altAciDeg)) {
    sonuc = {};
    sonuc.islenebilir = false;
    sonuc.dik = false;
    sonuc.hata = true;
    sonuc.hataMesaji = L"Bu Açılarda Wtecte İşlem Yapılamaz";
  }
  if (!sonuc.dik && !sonuc.hata && sonuc.islenebilir) {
    const auto [a, c] = saltAciAl(ustAciDeg, altAciDeg);
    sonuc.a = a;
    sonuc.c = c;
  }
  return sonuc;
}

// ---- FikoBCAci (Soraluce) -------------------------------------------------------------

bool FikoBCAci::dikAciBul(double ustAciDeg, double altAciDeg, BCAciSonuc& sonuc) {
  bool bulundu = false;
  auto ata = [&](double b, double c) {
    sonuc.b = b;
    sonuc.c = c;
    sonuc.islenebilir = true;
    sonuc.dik = true;
    bulundu = true;
  };
  if (altAciDeg == 180.0) ata(180.0, 0.0);
  if (ustAciDeg == 270.0 && altAciDeg == 90.0) ata(90.0, 0.0);
  if (ustAciDeg == 180.0 && altAciDeg == 90.0) ata(0.0, 180.0);
  if (ustAciDeg == 90.0 && altAciDeg == 90.0) ata(270.0, 0.0);
  if (ustAciDeg == 0.0 && altAciDeg == 0.0) ata(0.0, 0.0);
  return bulundu;
}

BCAciSonuc FikoBCAci::saltAciAl(double ustAciDeg, double altAciDeg, bool dokKapat) {
  UyariSusturucu sustur(uygulama_);
  FikoDllOturum o = fikoDllAc(uygulama_, klasor_, L"Src.FikoDll");
  dok_ = o.dok;
  prmYaz(o.prm, L"Ust", ustAciDeg);
  prmYaz(o.prm, L"Alt", altAciDeg);
  o.part.guncelle();

  const double srBK = prmSayi(o.prm, L"BAci");
  const double srCK = prmSayi(o.prm, L"CAci");
  const double srB = aci_hesap::kafaAdiminaYuvarla(srBK, kKafaAdimi);
  const double srC = aci_hesap::kafaAdiminaYuvarla(srCK, kKafaAdimi);

  prmYaz(o.prm, L"eksBAcisi", srB);
  prmYaz(o.prm, L"eksCAcisi", srC);
  o.part.guncelle();

  BCAciSonuc sonuc;
  sonuc.b = srB;
  sonuc.c = srC;
  sonuc.bFark = srB - srBK;
  sonuc.cFark = srC - srCK;
  sonuc.aciFarki = prmSayi(o.prm, L"AciFark");
  if (dokKapat) dok_.kapat();
  return sonuc;
}

BCAciSonuc FikoBCAci::acilar(double ustAciDeg, double altAciDeg) {
  BCAciSonuc sonuc;
  dikAciBul(ustAciDeg, altAciDeg, sonuc);
  // Python kaynaginda kosul boyle (tersine gorunuyor) — BIREBIR korundu:
  // islenebilir() TRUE ise hata bayragi kalkar, genel cozum atlanir.
  if (islenebilir(ustAciDeg, altAciDeg)) {
    sonuc = {};
    sonuc.islenebilir = false;
    sonuc.dik = false;
    sonuc.hata = true;
    sonuc.hataMesaji = L"Bu Açılarda Soralucede İşlem Yapılamaz";
  }
  if (!sonuc.dik && !sonuc.hata && sonuc.islenebilir) {
    const BCAciSonuc salt = saltAciAl(ustAciDeg, altAciDeg, true);
    sonuc.b = salt.b;
    sonuc.c = salt.c;
    sonuc.aciFarki = salt.aciFarki;
    sonuc.bFark = salt.bFark;
    sonuc.cFark = salt.cFark;
  }
  return sonuc;
}

std::pair<double, double> FikoBCAci::acilarYuvarlamasiz(double ustAciDeg, double altAciDeg) {
  UyariSusturucu sustur(uygulama_);
  FikoDllOturum o = fikoDllAc(uygulama_, klasor_, L"Src.FikoDll");
  dok_ = o.dok;
  prmYaz(o.prm, L"Ust", ustAciDeg);
  prmYaz(o.prm, L"Alt", altAciDeg);
  o.part.guncelle();
  const double b = prmSayi(o.prm, L"BAci");
  const double c = prmSayi(o.prm, L"CAci");
  dok_.kapat();
  return {b, c};
}

BCAciSonuc FikoBCAci::aciDuzelt(double ustAciDeg, double altAciDeg, double b, double c,
                                bool dokKapat) {
  saltAciAl(ustAciDeg, altAciDeg, false);
  Part part = dok_.asPartDokuman().part();
  Parametreler prm = part.parametreler();

  const double srBK = prmSayi(prm, L"BAci");
  const double srCK = prmSayi(prm, L"CAci");
  prmYaz(prm, L"eksBAcisi", b);
  prmYaz(prm, L"eksCAcisi", c);
  part.guncelle();
  const double srB = prmSayi(prm, L"eksBAcisi");
  const double srC = prmSayi(prm, L"eksCAcisi");

  BCAciSonuc sonuc;
  sonuc.b = b;
  sonuc.c = c;
  sonuc.aciFarki = prmSayi(prm, L"AciFark");
  sonuc.bFark = srB - srBK;
  sonuc.cFark = srC - srCK;
  if (dokKapat) dok_.kapat();
  return sonuc;
}

std::array<XYZ, 4> FikoBCAci::eksenAktar(double ustAciDeg, double altAciDeg, double b,
                                         double c, PartOperasyonu po, Dokuman aktifDokuman,
                                         const std::wstring& aktiviteIsmi, bool poAyarla) {
  MakineIslemeEkseni poEkseni = po.islemeEkseni();
  const EksenVektorleri poVektor = eksenVektorleriAl(poEkseni);

  const BCAciSonuc aci = aciDuzelt(ustAciDeg, altAciDeg, b, c, false);

  Part part = dok_.asPartDokuman().part();
  Eksen merkezEksen = Eksenler(part.eksenler()).eleman(1);
  merkezEksen.merkezAyarla(dizi3(poVektor.merkez));
  merkezEksen.xAyarla(dizi3(poVektor.x));
  merkezEksen.yAyarla(dizi3(poVektor.y));
  merkezEksen.zAyarla(dizi3(poVektor.z));
  part.guncelle();

  Parametreler prm = part.parametreler();
  const std::array<XYZ, 4> yeni = yeniEksenMatrisi(prm);

  PPRDokuman ppr(aktifDokuman.com().nesne(L"PPRDocument"));
  PPRProductlar productlar(ppr.productlar());
  PartDokuman partDok = productlar.eleman(0).referansProduct().dokuman().asPartDokuman();
  Part hedefPart = partDok.part();

  Eksen eksen = Eksenler(hedefPart.eksenler()).ekle();
  eksen.merkezAyarla(dizi3(yeni[0]));
  eksen.xAyarla(dizi3(yeni[1]));
  eksen.yAyarla(dizi3(yeni[2]));
  eksen.zAyarla(dizi3(yeni[3]));
  eksen.ismiAyarla(std::format(L"FikoYT Eksen -> B ={}° C ={}° Fark ={}° ({})", aci.b, aci.c,
                               aci.aciFarki, aktiviteIsmi));
  hedefPart.guncelle();

  Secililer secililer = partDok.secililer();
  secililer.temizle();
  secililer.ekle(eksen);
  FikomNesne gorunum = secililer.gorunum();
  gorunum.metod(L"SetRealColor", {vt(255L), vt(255L), vt(0L), vt(1L)});
  gorunum.metod(L"SetRealLineType", {vt(1L), vt(1L)});
  gorunum.metod(L"SetRealWidth", {vt(3L), vt(1L)});

  if (poAyarla) {
    MakineIslemeEkseni islemeEkseni = po.islemeEkseni();
    islemeEkseni.eksenSec(eksen.com(), po.urunDokumani().com());
    islemeEkseni.ismiAyarla(
        std::format(L"FikoYT B ={}° C ={}° Fark ={}°", aci.b, aci.c, aci.aciFarki));
  }

  dok_.kapat();
  return yeni;
}

std::array<XYZ, 4> FikoBCAci::eksenAktarMfg(double ustAciDeg, double altAciDeg, double b,
                                            double c, PartOperasyonu po) {
  MakineIslemeEkseni poEkseni = po.islemeEkseni();
  const EksenVektorleri poVektor = eksenVektorleriAl(poEkseni);

  const BCAciSonuc aci = aciDuzelt(ustAciDeg, altAciDeg, b, c, false);

  Part part = dok_.asPartDokuman().part();
  Eksen merkezEksen = Eksenler(part.eksenler()).eleman(1);
  merkezEksen.merkezAyarla(dizi3(poVektor.merkez));
  merkezEksen.xAyarla(dizi3(poVektor.x));
  merkezEksen.yAyarla(dizi3(poVektor.y));
  merkezEksen.zAyarla(dizi3(poVektor.z));
  part.guncelle();

  Parametreler prm = part.parametreler();
  const std::array<XYZ, 4> yeni = yeniEksenMatrisi(prm);

  MfgOzellikler ozellikler = po.mfgGorunum().mfgOzellikler();
  FikomNesne yeniEksen = ozellikler.ekle(L"MfgMachiningAxisSystem");
  yeniEksen.metod(L"SetOriginPointByCoordinates", {vt(yeni[0].x), vt(yeni[0].y), vt(yeni[0].z)});
  yeniEksen.metod(L"SetOriginXDirection", {vt(yeni[1].x), vt(yeni[1].y), vt(yeni[1].z)});
  yeniEksen.metod(L"SetOriginZDirection", {vt(yeni[3].x), vt(yeni[3].y), vt(yeni[3].z)});
  yeniEksen.ozellikAyarla(L"Name", vt(std::format(L"FikoYT B={}° C={}°", b, c)));

  po.com().ozellikAyarla(
      L"Name", vt(std::format(L"FikoYT B ={}° C ={}° Fark ={}°", aci.b, aci.c, aci.aciFarki)));
  po.com().ozellikAyarla(L"MachiningAxisSystem", dv(yeniEksen));

  dok_.kapat();
  return yeni;
}

// ---- KacmaDegerleri (IAcilar surumu) ---------------------------------------------------

TakimBilgisi KacmaDegerleri::takimBilgisi(Aktivite aktivite) {
  TakimBilgisi bilgi;
  std::wstring takimTipi;
  try {
    takimTipi = aktivite.com().nesne(L"Tool").metin(L"ToolType");
  } catch (const FikomHata&) {
    bilgi.takimTipi = L"Takim Tanitilmamis";
    bilgi.hata = true;
    return bilgi;
  }
  if (takimTipi == L"MfgEndMillTool") {
    MfgTakim takim = aktivite.takim();
    bilgi.takimCapi = mmSayi(takim.anmaCapi().degeriStr());
    bilgi.takimRadiusu = mmSayi(takim.radius().degeriStr());
    bilgi.takimTipi = takimTipi;
    bilgi.hata = false;
  } else {
    bilgi.takimTipi = L"Takim Desteklenmiyor";
    bilgi.hata = true;
  }
  return bilgi;
}

XYZ KacmaDegerleri::kacmaDegerleri(const TakimBilgisi& takim, double ustAciDeg,
                                   double altAciDeg) {
  if (takim.hata) return {0.0, 0.0, 0.0};

  FikoDllOturum o = fikoDllAc(uygulama_, klasor_, L"KCMEndMill.FikoDll");
  prmYaz(o.prm, L"Ust", ustAciDeg);
  prmYaz(o.prm, L"Alt", altAciDeg);
  prmYaz(o.prm, L"TakimCapi", takim.takimCapi);
  prmYaz(o.prm, L"TakimRadius", takim.takimRadiusu);
  prmYaz(o.prm, L"TakimRadiuslu", takim.takimRadiusu != 0.0);
  o.part.guncelle();

  XYZ kacma{prmSayi(o.prm, L"KacmaX"), prmSayi(o.prm, L"KacmaY"),
            prmSayi(o.prm, L"KacmaZ") * -1.0};
  o.dok.kapat();
  return kacma;
}

// ---- FikoKacmaDegerleri (IFikoAcilar surumu) -------------------------------------------

KacmaSonucu FikoKacmaDegerleri::takimKontrol(MfgTakim takim) {
  KacmaSonucu sonuc;
  TakimTuru tur = TakimTuru::Bilinmiyor;
  try {
    if (!takim.gecerli()) throw FikomHata("Takim yok", 0);
    tur = takim.turu();
  } catch (const FikomHata&) {
    sonuc.hata = true;
    sonuc.hataMesaji = L"Takım Tanıtılmamış";
    return sonuc;
  }
  if (tur != TakimTuru::Normal && tur != TakimTuru::Yuzey) {
    sonuc.hata = true;
    sonuc.hataMesaji = L"Takım Desteklenmiyor";
  }
  return sonuc;
}

KacmaSonucu FikoKacmaDegerleri::kacmaDegerleri(MfgTakim takim, double ustAciDeg,
                                               double altAciDeg) {
  KacmaSonucu sonuc = takimKontrol(takim);
  if (sonuc.hata) return sonuc;

  UyariSusturucu sustur(uygulama_);
  const std::wstring dosya = std::wstring(takimTuruKodu(takim.turu())) + L".FikoDll";
  FikoDllOturum o = fikoDllAc(uygulama_, klasor_, dosya.c_str());

  _variant_t cap = takim.disCapi().degeri();
  _variant_t radius = takim.radius().degeri();
  const double radiusDeger = sayiYap(radius);

  prmYaz(o.prm, L"Ust", ustAciDeg);
  prmYaz(o.prm, L"Alt", altAciDeg);
  prmYaz(o.prm, L"TakimCapi", sayiYap(cap));
  prmYaz(o.prm, L"TakimRadius", radiusDeger);
  prmYaz(o.prm, L"TakimRadiuslu", radiusDeger != 0.0);
  o.part.guncelle();

  sonuc.degerler = {prmSayi(o.prm, L"KacmaX"), prmSayi(o.prm, L"KacmaY"),
                    prmSayi(o.prm, L"KacmaZ") * -1.0};
  o.dok.kapat();
  return sonuc;
}

// ---- FikoAcisalOffset ------------------------------------------------------------------

XYZ FikoAcisalOffset::degerleriAl(double ustAciDeg, double altAciDeg) {
  UyariSusturucu sustur(uygulama_);
  FikoDllOturum o = fikoDllAc(uygulama_, klasor_, L"FikoOffset.FikoDll");
  prmYaz(o.prm, L"Ust", ustAciDeg);
  prmYaz(o.prm, L"Alt", altAciDeg);
  prmYaz(o.prm, L"offsetMiktari", offsetMiktari_);
  o.part.guncelle();

  XYZ sonuc{prmSayi(o.prm, L"OffsetX"), prmSayi(o.prm, L"OffsetY"),
            prmSayi(o.prm, L"OffsetZ") * -1.0};
  o.dok.kapat();
  return sonuc;
}

// ---- FikoAcilar facade -----------------------------------------------------------------

XYZ FikoAcilar::takimYonu() {
  if (!takimYonuYuklu_) {
    takimYonu_ = aktivite_.takimYonu();
    takimYonuYuklu_ = true;
  }
  return takimYonu_;
}

MfgTakim FikoAcilar::takim() {
  if (!takimYuklu_) {
    takim_ = aktivite_.takim();
    takimYuklu_ = true;
  }
  return takim_;
}

EksenVektorleri FikoAcilar::eksenVektor() {
  if (!eksenYuklu_) {
    eksen_ = eksenVektorleriAl(po_.islemeEkseni());
    eksenYuklu_ = true;
  }
  return eksen_;
}

ACAciSonuc FikoAcilar::acAcilari() {
  SaltAci salt = saltAcilar();
  return acAcisi().acilar(salt.ustAci(), salt.altAci());
}

BCAciSonuc FikoAcilar::bcAcilari() {
  SaltAci salt = saltAcilar();
  return bcAcisi().acilar(salt.ustAci(), salt.altAci());
}

std::array<XYZ, 4> FikoAcilar::eksenAktar(double b, double c, bool poAyarla, bool takimDik) {
  SaltAci salt = saltAcilar();
  FikoBCAci bc = bcAcisi();
  const std::array<XYZ, 4> yeni =
      bc.eksenAktar(salt.ustAci(), salt.altAci(), b, c, po_,
                    Dokuman(uygulama_.nesne(L"ActiveDocument")), aktivite_.ismi(), poAyarla);
  if (takimDik) takimYonuAyarla(yeni[3]);  // Python: facade onbellegi guncellenir
  return yeni;
}

// ---- Cikaricilar -----------------------------------------------------------------------

namespace {

// Python readline taklidi: satir '\n' dahil doner, EOF'ta bos; \r\n → \n.
class SatirOkuyucu {
 public:
  explicit SatirOkuyucu(const std::string& icerik) : s_(icerik) {}

  std::string oku() {
    if (poz_ >= s_.size()) return {};
    const size_t n = s_.find('\n', poz_);
    std::string satir;
    if (n == std::string::npos) {
      satir = s_.substr(poz_);
      poz_ = s_.size();
    } else {
      satir = s_.substr(poz_, n - poz_ + 1);
      poz_ = n + 1;
    }
    if (satir.size() >= 2 && satir[satir.size() - 2] == '\r') satir.erase(satir.size() - 2, 1);
    return satir;
  }

 private:
  const std::string& s_;
  size_t poz_ = 0;
};

bool bosMu(const std::string& s) {  // Python strip() == ''
  for (const char ch : s)
    if (ch != ' ' && ch != '\t' && ch != '\r' && ch != '\n' && ch != '\v' && ch != '\f')
      return false;
  return true;
}

std::string hepsiniDegistir(std::string s, const std::string& eski, const std::string& yeni) {
  size_t p = 0;
  while ((p = s.find(eski, p)) != std::string::npos) {
    s.replace(p, eski.size(), yeni);
    p += yeni.size();
  }
  return s;
}

std::string kirp(std::string s) {  // Python strip()
  const char* bosluk = " \t\r\n\v\f";
  const size_t bas = s.find_first_not_of(bosluk);
  if (bas == std::string::npos) return {};
  const size_t son = s.find_last_not_of(bosluk);
  return s.substr(bas, son - bas + 1);
}

// replace(onEk,"") + replace(" ","") + strip()
std::string temizle(const std::string& satir, const std::string& onEk) {
  return kirp(hepsiniDegistir(hepsiniDegistir(satir, onEk, ""), " ", ""));
}

std::vector<std::string> bol(const std::string& s, char ayrac) {
  std::vector<std::string> parcalar;
  size_t bas = 0;
  for (;;) {
    const size_t p = s.find(ayrac, bas);
    if (p == std::string::npos) {
      parcalar.push_back(s.substr(bas));
      break;
    }
    parcalar.push_back(s.substr(bas, p - bas));
    bas = p + 1;
  }
  return parcalar;
}

std::string eleman(const std::vector<std::string>& v, size_t i) {
  return i < v.size() ? v[i] : std::string();
}

bool aptSonSatiriMi(const std::string& s) {
  return s.starts_with("PPRINT  End of generation of : ") ||
         s.starts_with("$$  End of generation of : ");
}

bool hizTuruGecerli(const AptAktiviteBilgi* aktivite) {
  if (!aktivite) return false;
  const std::string& t = aktivite->turu;
  return t != "ToolChange" && t != "Start" && t != "Stop" && t != "PPInstruction";
}

std::string ilerlemeSorgula(double ilerleme, const AptAktiviteBilgi* aktivite) {
  if (!hizTuruGecerli(aktivite)) return "BILINMIYOR";
  if (ilerleme == aktivite->ilerlemeIsleme) return "ISLEME";
  if (ilerleme == aktivite->ilerlemeYaklasma) return "YAKLASMA";
  if (ilerleme == aktivite->ilerlemeUzaklasma) return "UZAKLASMA";
  if (ilerleme == aktivite->ilerlemeFinis) return "FINIS";
  return "BOSTA";
}

// apt_FEDRAT siniflandirmasi — sorgudan farkli: 0.0 → HIZLI ara kolu vardir.
std::string fedratSinifla(double hizDurum, const AptAktiviteBilgi* aktivite) {
  if (!hizTuruGecerli(aktivite)) return "BILINMIYOR";
  if (hizDurum == aktivite->ilerlemeIsleme) return "ISLEME";
  if (hizDurum == aktivite->ilerlemeYaklasma) return "YAKLASMA";
  if (hizDurum == aktivite->ilerlemeUzaklasma) return "UZAKLASMA";
  if (hizDurum == 0.0) return "HIZLI";
  if (hizDurum == aktivite->ilerlemeFinis) return "FINIS";
  return "BOSTA";
}

}  // namespace

std::string fikoAptV1Uret(const FikoAptV1Girdi& girdi) {
  std::string cikti;
  cikti += "#$ FikoYT PROGRAM BASLANGICI " + girdi.programIsmi + "\n";
  cikti += girdi.toFikoGLJson + "\n";

  SatirOkuyucu okuyucu(girdi.aptIcerik);
  std::string aktifSatir = "BAS";
  size_t aktiviteSay = 0;
  const AptAktiviteBilgi* aktivite = nullptr;
  std::string aktiviteIsmi;

  for (;;) {
    while (!(aktifSatir.starts_with("PPRINT OPERATION NAME : ") ||
             aktifSatir.starts_with("$$ OPERATION NAME : "))) {
      aktifSatir = okuyucu.oku();
      if (bosMu(aktifSatir)) break;
    }
    if (bosMu(aktifSatir)) break;
    if (aktiviteSay >= girdi.aktiviteler.size()) break;  // Python'da IndexError sonlanirdi
    aktivite = &girdi.aktiviteler[aktiviteSay];

    // Isim satiri '\n' dahil saklanir; BASLANGIC/BITIS satirlari bu yuzden satir sonlanir.
    aktiviteIsmi = hepsiniDegistir(
        hepsiniDegistir(aktifSatir, "PPRINT OPERATION NAME : ", ""), "$$ OPERATION NAME : ", "");
    cikti += "#FIKOYT AKTIVITE BASLANGIC: " + std::to_string(aktiviteSay) + ", ISMI " +
             aktiviteIsmi;
    aktifSatir = okuyucu.oku();  // Python: bu satir denetlenir ama islenmeden atlanir

    while (!aptSonSatiriMi(aktifSatir)) {
      aktifSatir = okuyucu.oku();
      if (bosMu(aktifSatir)) break;

      if (aktifSatir.starts_with("PPRINT ")) {
        if (!aptSonSatiriMi(aktifSatir))
          cikti += hepsiniDegistir(aktifSatir, "PPRINT ", "#NCYAZ ");
      } else if (aktifSatir.starts_with("PPRINT/")) {
        if (!aptSonSatiriMi(aktifSatir))
          cikti += hepsiniDegistir(aktifSatir, "PPRINT/", "#NCYAZ ");
      } else if (aktifSatir.starts_with("INSERT")) {
        cikti += hepsiniDegistir(aktifSatir, "INSERT", "#NCEKLE");
      } else if (aktifSatir.starts_with("TLAXIS/")) {
        cikti += "TKMYON " + temizle(aktifSatir, "TLAXIS/") + "\n";
      } else if (aktifSatir.starts_with("GOTO  /")) {
        cikti += "GIT " + temizle(aktifSatir, "GOTO  /") + "\n";
      } else if (aktifSatir.starts_with("SPINDL/")) {
        const std::vector<std::string> devir = bol(temizle(aktifSatir, "SPINDL/"), ',');
        cikti += "DEVIR " + eleman(devir, 0) + "|" + eleman(devir, 1) + "|" +
                 eleman(devir, 2) + "\n";
      } else if (aktifSatir.starts_with("FEDRAT/")) {
        std::vector<std::string> hiz = bol(temizle(aktifSatir, "FEDRAT/"), ',');
        const double hizDurum = std::strtod(eleman(hiz, 0).c_str(), nullptr);
        hiz.push_back(fedratSinifla(hizDurum, aktivite));
        cikti += "ILERLEME " + eleman(hiz, 0) + "|" + eleman(hiz, 1) + "|" +
                 ilerlemeSorgula(hizDurum, aktivite) + "\n";
      } else if (aktifSatir.starts_with("CUTTER/")) {
        const std::string takim =
            kirp(hepsiniDegistir(hepsiniDegistir(hepsiniDegistir(aktifSatir, "CUTTER/", ""),
                                                 " ", ""), "$", ""));
        const std::string takim1 =
            kirp(hepsiniDegistir(hepsiniDegistir(okuyucu.oku(), " ", ""), "$", ""));
        cikti += "TAKIM " + takim + takim1 + "\n";
      } else if (!(aktifSatir.starts_with("PPRINT  End of generation of : ") ||
                   aktifSatir.starts_with("$$  End of generation of "))) {
        cikti += aktifSatir;
      }
    }

    cikti += "#FIKOYT AKTIVITE BITIS: " + std::to_string(aktiviteSay) + ", ISMI " +
             aktiviteIsmi;
    ++aktiviteSay;
    aktifSatir = okuyucu.oku();
    if (bosMu(aktifSatir)) break;
    if (aktiviteSay >= girdi.aktiviteler.size()) break;
  }

  cikti += "#$ FikoYT PROGRAM BITIS " + girdi.programIsmi;
  return cikti;
}

std::string fikoOpGLV1Uret(const FikoOpGLV1Girdi& girdi) {
  std::string cikti;
  cikti += "#$ FikoYT PART OPERASYONU BASLANGICI " + girdi.opIsmi + "\n";
  cikti += girdi.opToFikoGLJson + "\n";
  cikti += "#$ FikoYT CIZIMLER BASLANGICI\n";
  cikti += "{}\n";
  cikti += "#$ FikoYT VRML CIZIM BASLANGICI " + girdi.cizimDokumanIsmi + "\n";
  cikti += girdi.vrmlIcerik;
  cikti += "#$ FikoYT VRML CIZIM BITIS " + girdi.cizimDokumanIsmi + "\n";
  cikti += "#$ FikoYT CIZIMLER BITIS\n";
  cikti += "#$ FikoYT PROGRAMLAR BASLANGICI\n";
  for (const auto& program : girdi.programlar) {
    if (program.bos) {
      cikti += "#$ FikoYT PROGRAM BASLANGICI " + program.ismi + "\n";
      cikti += program.toFikoGLJson + "\n";
      cikti += "#$ FikoYT PROGRAM BITIS " + program.ismi;
    } else {
      cikti += program.aptV1Icerik;
    }
    cikti += "\n";
  }
  cikti += "#$ FikoYT PROGRAMLAR BITIS\n";
  cikti += "#$ FikoYT PART OPERASYONU BITIS " + girdi.opIsmi;
  return cikti;
}

}  // namespace fikatia