#pragma once
#include <array>
#include <string>
#include <utility>
#include <vector>

#include "com/model/imalat_modeli.hpp"
#include "com/model/sahne_modeli.hpp"

// Aci tespit + cikarici modulleri — FikatiaV2024 IAcilar/IFikoAcilar/ICikaricilar portu.
// "I" oneki kaldirildi (IAciTespit → AciTespit, IFikoACAci → FikoACAci).
// ACI HESAPLARI DAVRANIS HAZINESIDIR: esikler, yuvarlamalar, sektor tablolari ve
// eksen/kafa donusum formulleri Python kaynagindan BIREBIR tasindi — "duzeltme" yapma.
// IAcilar ile IFikoAcilar'in ortusen siniflari (ITav20Er32≡IFikoSaltAci,
// IAciWtec≡IFikoACAci, IAciSoraluce≡IFikoBCAci) satir satir ayni davranista oldugundan
// tek sinifta toplanir; iki IKacmaDegerleri.py ise FARKLIDIR ve ikisi de ayri korunur
// (KacmaDegerleri = IAcilar surumu, FikoKacmaDegerleri = IFikoAcilar surumu).
// FikoDll cozucu siniflar CATIA parametre dosyalariyla calisir; dosya klasoru
// (Python'daki scriptYolu\Prg\FikoDosya) kurucuya verilir.

namespace fikatia {

// ---- Salt aci matematigi (COM'suz, test edilebilir) ---------------------------

// PartOperasyonu isleme ekseninin yon vektorleri (Python po.eksen → XYZO portu).
struct EksenVektorleri {
  XYZ x, y, z;
  XYZ merkez;
};

EksenVektorleri eksenVektorleriAl(MakineIslemeEkseni eksen);

namespace aci_hesap {

// Sonuclar derece cinsinden (vector3d.vec_dihedral + rad2deg portu; NaN → 0).
double xAcisi(const EksenVektorleri& eksen, const XYZ& takimYonu);
double saltUstAci(const EksenVektorleri& eksen, const XYZ& takimYonu);
// Python kaynaginda payda yalniz son carpimi boler (parantez onceligi) — BIREBIR.
double altAci(const EksenVektorleri& eksen, const XYZ& takimYonu);
int sektor(double saltUstAciDeg, double xAcisiDeg);
double ustAci(double saltUstAciDeg, double xAcisiDeg, int sektorNo);
double ustAci(const EksenVektorleri& eksen, const XYZ& takimYonu);
// Soraluce kafa adimi yuvarlamasi: round(aci/adim)*adim (Python round = yarim-cift).
double kafaAdiminaYuvarla(double aciDeg, double adim = 2.5);

}  // namespace aci_hesap

// ITav20Er32 ≡ IFikoSaltAci portu: eksen + takim yonunden ust/alt aci ve sektor.
class SaltAci {
 public:
  SaltAci() = default;
  SaltAci(const EksenVektorleri& eksen, const XYZ& takimYonu)
      : eksen_(eksen), takimYonu_(takimYonu) {}

  double xAcisi() const { return aci_hesap::xAcisi(eksen_, takimYonu_); }
  double saltUstAci() const { return aci_hesap::saltUstAci(eksen_, takimYonu_); }
  double altAci() const { return aci_hesap::altAci(eksen_, takimYonu_); }
  int sektor() const { return aci_hesap::sektor(saltUstAci(), xAcisi()); }
  double ustAci() const { return aci_hesap::ustAci(eksen_, takimYonu_); }

  const EksenVektorleri& eksen() const { return eksen_; }
  const XYZ& takimYonu() const { return takimYonu_; }

 private:
  EksenVektorleri eksen_{};
  XYZ takimYonu_{};
};

using Tav20Er32 = SaltAci;

// ---- Makine-ozel aci sonuclari -------------------------------------------------

struct ACAciSonuc {  // IACAciSonuc portu (Wtec)
  double a = 0.0, c = 0.0;
  bool dik = false;
  bool islenebilir = true;
  bool hata = false;
  std::wstring hataMesaji;
};

struct BCAciSonuc {  // IBCAciSonuc portu (Soraluce)
  double b = 0.0, c = 0.0;
  double aciFarki = 0.0, bFark = 0.0, cFark = 0.0;
  bool dik = false;
  bool islenebilir = true;
  bool hata = false;
  std::wstring hataMesaji;
};

// IAciWtec ≡ IFikoACAci portu (Wtec tezgahi). Genel durum WBK.FikoDll ile cozulur.
class FikoACAci {
 public:
  FikoACAci() = default;
  FikoACAci(FikomNesne uygulama, std::wstring fikoDosyaKlasoru)
      : uygulama_(std::move(uygulama)), klasor_(std::move(fikoDosyaKlasoru)) {}

  static bool islenebilir(double altAciDeg) { return altAciDeg <= 90.0; }
  // Dik aci tablosu; eslesme varsa sonuc doldurulur ve true doner.
  static bool dikAciBul(double ustAciDeg, double altAciDeg, ACAciSonuc& sonuc);
  ACAciSonuc acilar(double ustAciDeg, double altAciDeg);
  // WBK.FikoDll cozumu: (B-ACISI, C-ACISI) parametreleri.
  std::pair<double, double> saltAciAl(double ustAciDeg, double altAciDeg);

 private:
  FikomNesne uygulama_;
  std::wstring klasor_;
};

// IAciSoraluce ≡ IFikoBCAci portu (Soraluce tezgahi). Genel durum Src.FikoDll ile
// cozulur; B/C kafa adimina (2.5°) yuvarlanir.
class FikoBCAci {
 public:
  static constexpr double kKafaAdimi = 2.5;

  FikoBCAci() = default;
  FikoBCAci(FikomNesne uygulama, std::wstring fikoDosyaKlasoru)
      : uygulama_(std::move(uygulama)), klasor_(std::move(fikoDosyaKlasoru)) {}

  static bool islenebilir(double ustAciDeg, double altAciDeg) {
    return (ustAciDeg < 90.0 || ustAciDeg > 270.0) && altAciDeg < 180.0;
  }
  static bool dikAciBul(double ustAciDeg, double altAciDeg, BCAciSonuc& sonuc);
  BCAciSonuc acilar(double ustAciDeg, double altAciDeg);
  // Src.FikoDll ham (B, C) — kafa adimina yuvarlanmadan.
  std::pair<double, double> acilarYuvarlamasiz(double ustAciDeg, double altAciDeg);
  // Kullanicinin verdigi B/C degerlerini dosyaya yazip fark degerlerini okur.
  BCAciSonuc aciDuzelt(double ustAciDeg, double altAciDeg, double b, double c,
                       bool dokKapat = true);
  // IFikoBCAci.eksenAktar portu: yeni ekseni part dokumanina ekler, secip renklendirir;
  // poAyarla ile PO isleme ekseni bu eksene baglanir. Donus: {O, X, Y, Z}.
  // Python'daki takimDik bayragi facade onbellegini guncelliyordu — FikoAcilar::eksenAktar'da.
  std::array<XYZ, 4> eksenAktar(double ustAciDeg, double altAciDeg, double b, double c,
                                PartOperasyonu po, Dokuman aktifDokuman,
                                const std::wstring& aktiviteIsmi, bool poAyarla = false);
  // IAciSoraluce.eksenAktar portu: MfgMachiningAxisSystem yaratip PO'ya atar.
  std::array<XYZ, 4> eksenAktarMfg(double ustAciDeg, double altAciDeg, double b, double c,
                                   PartOperasyonu po);

 private:
  BCAciSonuc saltAciAl(double ustAciDeg, double altAciDeg, bool dokKapat);

  FikomNesne uygulama_;
  std::wstring klasor_;
  Dokuman dok_;  // aciDuzelt/eksenAktar zinciri icin acik tutulan Src dokumani
};

// ---- Kacma degerleri ------------------------------------------------------------

// IAcilar/IKacmaDegerleri.takim portu — ham oznitelik ("12,5mm") ayiklamali.
struct TakimBilgisi {
  double takimCapi = 0.0;
  double takimRadiusu = 0.0;
  std::wstring takimTipi;
  bool hata = false;
};

// IAcilar/IKacmaDegerleri portu (eski surum): yalniz MfgEndMillTool, cap kaynagi
// MFG_NOMINAL_DIAM, dosya her zaman KCMEndMill.FikoDll.
class KacmaDegerleri {
 public:
  KacmaDegerleri() = default;
  KacmaDegerleri(FikomNesne uygulama, std::wstring fikoDosyaKlasoru)
      : uygulama_(std::move(uygulama)), klasor_(std::move(fikoDosyaKlasoru)) {}

  static TakimBilgisi takimBilgisi(Aktivite aktivite);
  // Hatali takimda (0,0,0); KacmaZ isareti ters cevrilir (Python * -1).
  XYZ kacmaDegerleri(const TakimBilgisi& takim, double ustAciDeg, double altAciDeg);

 private:
  FikomNesne uygulama_;
  std::wstring klasor_;
};

struct KacmaSonucu {  // IKacmaSonuc portu
  XYZ degerler;
  bool hata = false;
  std::wstring hataMesaji;
};

// IFikoAcilar/IKacmaDegerleri portu (yeni surum): desteklenen takimlar Normal/Yuzey,
// cap kaynagi MFG_BODY_DIAM, dosya "<TakimTuruKodu>.FikoDll".
class FikoKacmaDegerleri {
 public:
  FikoKacmaDegerleri() = default;
  FikoKacmaDegerleri(FikomNesne uygulama, std::wstring fikoDosyaKlasoru)
      : uygulama_(std::move(uygulama)), klasor_(std::move(fikoDosyaKlasoru)) {}

  static KacmaSonucu takimKontrol(MfgTakim takim);
  KacmaSonucu kacmaDegerleri(MfgTakim takim, double ustAciDeg, double altAciDeg);

 private:
  FikomNesne uygulama_;
  std::wstring klasor_;
};

// IFikoAcisalOffset portu: FikoOffset.FikoDll ile acisal offset bileske vektoru.
class FikoAcisalOffset {
 public:
  FikoAcisalOffset() = default;
  FikoAcisalOffset(FikomNesne uygulama, std::wstring fikoDosyaKlasoru)
      : uygulama_(std::move(uygulama)), klasor_(std::move(fikoDosyaKlasoru)) {}

  double offsetMiktari() const { return offsetMiktari_; }
  void offsetMiktariAyarla(double v) { offsetMiktari_ = v; }
  // OffsetZ isareti ters cevrilir (Python * -1).
  XYZ degerleriAl(double ustAciDeg, double altAciDeg);
  XYZ degerleriAl(double ustAciDeg, double altAciDeg, double offset) {
    offsetMiktari_ = offset;
    return degerleriAl(ustAciDeg, altAciDeg);
  }

 private:
  FikomNesne uygulama_;
  std::wstring klasor_;
  double offsetMiktari_ = 0.0;
};

// ---- Facade (IFikoAcilar + IAciTespit portu) -------------------------------------

// Aktivite baglamini tutar; takim yonu / takim / eksen vektoru Python'daki gibi
// tembel yuklenir ve elle gecersiz kilinabilir (setter'lar onbellegi ezer).
class FikoAcilar {
 public:
  FikoAcilar() = default;
  FikoAcilar(FikomNesne uygulama, std::wstring fikoDosyaKlasoru, Aktivite aktivite,
             PartOperasyonu po)
      : uygulama_(std::move(uygulama)),
        klasor_(std::move(fikoDosyaKlasoru)),
        aktivite_(std::move(aktivite)),
        po_(std::move(po)) {}

  Aktivite& aktivite() { return aktivite_; }
  PartOperasyonu& po() { return po_; }

  XYZ takimYonu();
  void takimYonuAyarla(const XYZ& v) { takimYonu_ = v; takimYonuYuklu_ = true; }
  MfgTakim takim();
  void takimAyarla(const MfgTakim& v) { takim_ = v; takimYuklu_ = true; }
  EksenVektorleri eksenVektor();
  void eksenVektorAyarla(const EksenVektorleri& v) { eksen_ = v; eksenYuklu_ = true; }

  SaltAci saltAcilar() { return SaltAci(eksenVektor(), takimYonu()); }
  FikoACAci acAcisi() const { return FikoACAci(uygulama_, klasor_); }
  FikoBCAci bcAcisi() const { return FikoBCAci(uygulama_, klasor_); }
  FikoAcisalOffset acisalOffset() const { return FikoAcisalOffset(uygulama_, klasor_); }
  KacmaDegerleri eskiKacmaDegerleri() const { return KacmaDegerleri(uygulama_, klasor_); }
  FikoKacmaDegerleri kacmaDegerleri() const { return FikoKacmaDegerleri(uygulama_, klasor_); }

  // IAciWtec.acilar / IFikoACAci.acilar es degeri.
  ACAciSonuc acAcilari();
  // IAciSoraluce.acilar / IFikoBCAci.acilar es degeri.
  BCAciSonuc bcAcilari();
  // takimDik: yeni Z yonu facade takim-yonu onbellegine yazilir (Python davranisi).
  std::array<XYZ, 4> eksenAktar(double b, double c, bool poAyarla = false,
                                bool takimDik = false);

 private:
  FikomNesne uygulama_;
  std::wstring klasor_;
  Aktivite aktivite_;
  PartOperasyonu po_;
  XYZ takimYonu_{};
  bool takimYonuYuklu_ = false;
  MfgTakim takim_;
  bool takimYuklu_ = false;
  EksenVektorleri eksen_{};
  bool eksenYuklu_ = false;
};

using AciTespit = FikoAcilar;

// ---- Cikaricilar (ICikaricilar portu) ---------------------------------------------
// Python siniflari dogrudan dosyaya yaziyordu; portta cikti string doner, yazma
// cagirana kalir. Icerikler UTF-8 std::string'dir (APT dosyalari metin tabanli).

// FEDRAT hiz siniflandirmasi icin aktivite basina gereken bilgiler.
struct AptAktiviteBilgi {
  std::string turu;  // "ToolChange"/"Start"/"Stop"/"PPInstruction" hiz sorgusunu kapatir
  double ilerlemeIsleme = 0.0;
  double ilerlemeYaklasma = 0.0;
  double ilerlemeUzaklasma = 0.0;
  double ilerlemeFinis = 0.0;
};

struct FikoAptV1Girdi {
  std::string programIsmi;
  std::string toFikoGLJson;                   // programin FikoGL JSON'u (tek satir)
  std::vector<AptAktiviteBilgi> aktiviteler;  // APT'deki operasyon sirasiyla
  std::string aptIcerik;                      // .FikoApt dosya icerigi
};

// IFikoAptv1 portu: CATIA APT ciktisini FikoAptv1 bicimine cevirir.
std::string fikoAptV1Uret(const FikoAptV1Girdi& girdi);

struct FikoOpGLV1Girdi {
  std::string opIsmi;
  std::string opToFikoGLJson;
  std::string cizimDokumanIsmi;  // urun dokumaninin ismi (VRML baslik satirlari)
  std::string vrmlIcerik;
  struct ProgramBlok {
    bool bos = false;
    std::string ismi;           // yalniz bos programda kullanilir
    std::string toFikoGLJson;   // yalniz bos programda kullanilir
    std::string aptV1Icerik;    // dolu programda fikoAptV1Uret ciktisi
  };
  std::vector<ProgramBlok> programlar;
};

// IFikoOpGLv1 portu: part operasyonu paket dosyasini (OpGL) birlestirir.
std::string fikoOpGLV1Uret(const FikoOpGLV1Girdi& girdi);

}  // namespace fikatia