#include <cmath>
#include <string>
#include <vector>

#include "fiko/cam/apt.hpp"          // cam::AptSonuc (aptIceAktar girisi)
#include "fiko/cam/cam_sistemi.hpp"
#include "fiko/cam/takim.hpp"
#include "fiko/cam/takim_yolu.hpp"
#include "fiko/io/web_io.hpp"
#include "fiko/sahne/sahne.hpp"

// ============================================================================
// Okuma sonucunu sahneye baglama (main-thread). STEP import ithalEkleHazir
// kalibi: grup + mesh dugumleri (hazirMeshEkle) + takim yolu cizim dugumleri
// (kenarNesneEkle). main.cpp Dosya>Ac menusu bu fonksiyonlari cagirir.
// ============================================================================

namespace fiko::io {

namespace {

// Bir HazirCizim'i sahneye baglar (yuzey mesh + kenar tek dugumde). Yalniz
// kenar varsa (mesh bos) kenar-dugumu (kenarNesneEkle) tercih edilir.
void cizimBagla(Sahne& sahne, Varlik ust, const HazirCizim& c, u32& sayac) {
  const std::string ad = c.ad.empty() ? ("Cizim." + std::to_string(++sayac)) : c.ad;
  const bool meshVar = !c.yuzey.vertexler.empty();
  if (meshVar) {
    sahne.hazirMeshEkle(ad, ust, c.renk, c.yuzey, c.kenar);
  } else if (!c.kenar.vertexler.empty()) {
    Aabbf sinir;
    for (const auto& v : c.kenar.vertexler) sinir.genislet({v.konum[0], v.konum[1], v.konum[2]});
    sahne.kenarNesneEkle(ad, ust, c.renk, c.kenar.vertexler, sinir);
  }
}

// FikoOpNokta.tip → HamleTip. Web: 'rapid'=G0 (Hizli), digerleri G1 (Kesme).
// Z-dalma ayrimini native sim renk/ilerlemeden yapar; burada tip-tabanli sade.
cam::HamleTip hamleTipCoz(const std::string& tip) {
  return (tip == "rapid") ? cam::HamleTip::Hizli : cam::HamleTip::Kesme;
}

// Bir FikoOp programini native CAM operasyonu olarak ekler (aptIceAktar) →
// urun agacinda operasyon + sim'de oynanabilir yol dugumu. Web'in FikoAPTCAT/
// FikoTakimYolu simulasyonu ile ayni davranis. Donen: eklenen op kimligi (0=bos).
u32 camOperasyonEkle(cam::CamSistemi& cam, const FikoOpSonuc& sonuc, const FikoOpProgram& p) {
  cam::AptSonuc as;
  // Op adi = web program ismi (FikoAPTCAT.isim). operasyonIsmi ( or. "ON") yorum.
  as.programAdi = p.ad;
  as.operasyonAdi = p.ad;
  as.eksenOrigin = p.cerceveOrigin;
  as.eksenX = p.cerceveX;
  as.eksenY = p.cerceveY;
  as.eksenZ = p.cerceveZ;

  // Takim: ilk noktanin takimi (delta encoding → nokta[0]'da tam).
  const FikoOpNokta& n0 = p.noktalar.front();
  if (n0.takimIndeks >= 0 && n0.takimIndeks < (int)sonuc.takimlar.size()) {
    const FikoOpTakim& t = sonuc.takimlar[n0.takimIndeks];
    as.takim.cap = t.cap;
    as.takim.koseYaricap = t.radius;
    if (t.boy > 0) as.takim.boy = t.boy;
    as.takim.ad = t.ismi.empty() ? as.operasyonAdi + " Takım" : t.ismi;
  }
  as.devir = n0.devir;

  // Takim ekseni (5-eksen yonu) — normalize; bozuk/asiri deger → +Z.
  Vec3d ty = n0.takimYonu;
  const f64 tl = std::sqrt(ty.x * ty.x + ty.y * ty.y + ty.z * ty.z);
  as.takimEkseni = (std::isfinite(tl) && tl > 1e-9) ? ty / tl : Vec3d{0, 0, 1};

  // Yol: nokta → Hamle{tip, konum(mm), ilerleme(mm/dk)}.
  as.yol.hamleler.reserve(p.noktalar.size());
  for (const FikoOpNokta& n : p.noktalar) {
    cam::Hamle h;
    h.tip = hamleTipCoz(n.tip);
    h.nokta = n.konum;
    h.ilerleme = n.hiz;
    as.yol.hamleler.push_back(h);
  }
  as.yol.istatistikGuncelle();
  as.gotoSayisi = as.yol.hamleler.size();
  as.basarili = true;

  return cam.aptIceAktar(as);
}

}  // namespace

u32 ithalSonucuKur(Sahne& sahne, const WrlSonuc& sonuc) {
  if (sonuc.parcalar.empty()) return 0;
  const Varlik grup = sahne.grupEkle(sonuc.ad.empty() ? "VRML" : sonuc.ad);
  u32 sayac = 0;
  for (const HazirCizim& c : sonuc.parcalar) cizimBagla(sahne, grup, c, sayac);
  return grup;
}

// Bir programi GORSEL kenar dugumu olarak ekler (CAM yoksa fallback). Web'in
// takim yolu cizgisi gorunumu — LINE_LIST, ilk nokta rengi.
void gorselYolEkle(Sahne& sahne, Varlik grup, const FikoOpProgram& p) {
  std::vector<KenarVertex> kenar;
  kenar.reserve((p.noktalar.size() - 1) * 2);
  Aabbf sinir;
  for (std::size_t i = 1; i < p.noktalar.size(); ++i) {
    const auto& a = p.noktalar[i - 1].konum;
    const auto& b = p.noktalar[i].konum;
    KenarVertex va{}, vb{};
    va.konum[0] = (f32)a.x; va.konum[1] = (f32)a.y; va.konum[2] = (f32)a.z; va.altKimlik = 0;
    vb.konum[0] = (f32)b.x; vb.konum[1] = (f32)b.y; vb.konum[2] = (f32)b.z; vb.altKimlik = 0;
    kenar.push_back(va); kenar.push_back(vb);
    sinir.genislet({va.konum[0], va.konum[1], va.konum[2]});
    sinir.genislet({vb.konum[0], vb.konum[1], vb.konum[2]});
  }
  const Vec3f renk = p.noktalar.front().renk;
  sahne.kenarNesneEkle(p.ad.empty() ? "Takim Yolu" : p.ad, grup, renk, kenar, sinir);
}

u32 ithalSonucuKur(Sahne& sahne, const FikoOpSonuc& sonuc, cam::CamSistemi* cam) {
  // Mesh cizimler → sahne agaci grubu (yalniz cizim varsa grup olustur).
  const bool gorselYol = (cam == nullptr);  // CAM yoksa yollar gorsel kenar dugumu
  Varlik grup = 0;
  if (!sonuc.cizimler.empty() || (gorselYol && !sonuc.programlar.empty()))
    grup = sahne.grupEkle(sonuc.ad.empty() ? "Fikoperasyon" : sonuc.ad);

  u32 sayac = 0;
  Aabbf meshSinir;
  for (const HazirCizim& c : sonuc.cizimler) {
    cizimBagla(sahne, grup, c, sayac);
    if (!c.yuzey.vertexler.empty()) meshSinir.genislet(c.yuzey.sinir);
  }

  // Takim yollari: CAM yoksa → gorsel kenar dugumu (fallback).
  if (!cam) {
    for (const FikoOpProgram& p : sonuc.programlar)
      if (p.noktalar.size() >= 2) gorselYolEkle(sahne, grup, p);
    return grup;
  }

  // CAM: web hiyerarsisini kur → PartOperasyon ("Fiko WebPart Op") konteyneri,
  // altinda Manufacturing Program → her program simule edilebilir CamOperasyon
  // (APT yolu). aptIceAktar op olusturur; kimlikleri pop.operasyonlar'a bagla.
  const u32 popKimlik = cam->parcaOpEkle();
  if (cam::PartOperasyon* pop = cam->parcaOpBul(popKimlik)) {
    if (!sonuc.ad.empty()) pop->ad = sonuc.ad;      // web: "Fikoperasyon.1"
    pop->eksenOrigin = sonuc.eksenMerkez;           // isleme ekseni (FikoEksen)
    pop->eksenX = sonuc.eksenX;
    pop->eksenY = sonuc.eksenY;
    pop->eksenZ = sonuc.eksenZ;
    if (meshSinir.gecerliMi()) {                      // stok = cizim sinir kutusu
      const Vec3f b = meshSinir.boyut(), o = meshSinir.asgari;
      pop->stok.tip = cam::StokTip::Kutu;
      pop->stok.boyut = {(f64)b.x, (f64)b.y, (f64)b.z};
      pop->stok.origin = {(f64)o.x, (f64)o.y, (f64)o.z};
    }
  }

  std::vector<u32> opKimlikler;
  for (const FikoOpProgram& p : sonuc.programlar) {
    if (p.noktalar.size() < 2) continue;
    if (const u32 opId = camOperasyonEkle(*cam, sonuc, p)) opKimlikler.push_back(opId);
  }
  // Op'lari PartOperasyon altina bagla (agacta "⚙ ... → Manufacturing Program → op").
  if (cam::PartOperasyon* pop = cam->parcaOpBul(popKimlik)) pop->operasyonlar = opKimlikler;
  cam->aktifParcaOp = (int)popKimlik;

  // Grup (mesh) yoksa da PartOp/op eklendiyse basarili say.
  return grup ? grup : (opKimlikler.empty() ? 0u : 1u);
}

}  // namespace fiko::io