#pragma once

// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
// Für die Migration erstellen wir minimale Forward-Declarations

#include <functional>
#include <memory>
#include <ostream>
#include <string>

#include <QObject>

#include "LtsUtils/LtsUtilsCore/data_modification_enum.h"

namespace AreaEffectSimulation
{

// AesItem-Struct (wird normalerweise von DDS generiert)
struct AesItem
{
  int32_t id() const { return m_id; }
  const std::string& name() const { return m_name; }
  
  int32_t m_id = 0;
  std::string m_name;
};

inline std::ostream& operator<<(std::ostream& os, const AesItem& item)
{
    os << "AesItem{id=" << item.id() << ", name=" << item.name() << "}";
    return os;
}

// BCContamination-Struct (wird normalerweise von DDS generiert)
struct BCContamination : public AesItem
{
};

// BoobyTrap-Struct (wird normalerweise von DDS generiert)
struct BoobyTrap : public AesItem
{
};

// OffRouteMine-Struct (wird normalerweise von DDS generiert)
struct OffRouteMine : public AesItem
{
};

namespace Interface
{

// Dtc - Data Transfer Component für Area Effect Simulation
// DDS-generierte Klasse mit Signals für AES-Item-Änderungen
class Dtc : public QObject {
  Q_OBJECT
  
public:
  Dtc() = default;
  ~Dtc() override = default;
  
  // Callback registration for AES item changes
  void bcContaminations(std::function<void(const BCContamination&)> callback) {
    m_bcCallback = callback;
  }
  
  void boobyTraps(std::function<void(const BoobyTrap&)> callback) {
    m_boobyTrapCallback = callback;
  }
  
  void offRouteMines(std::function<void(const OffRouteMine&)> callback) {
    m_offRouteMineCallback = callback;
  }
  
  void aesItems(std::function<void(const AesItem&)> callback) {
    m_aesCallback = callback;
  }
  
  // Trigger methods for STUB testing
  void triggerBCContaminationChanged(const BCContamination& item, DataModification modType) {
    emit bcContaminationChanged(item, modType);
    if (m_bcCallback) {
      m_bcCallback(item);
    }
  }
  
  void triggerBoobyTrapChanged(const BoobyTrap& item, DataModification modType) {
    emit boobyTrapChanged(item, modType);
    if (m_boobyTrapCallback) {
      m_boobyTrapCallback(item);
    }
  }
  
  void triggerOffRouteMineChanged(const OffRouteMine& item, DataModification modType) {
    emit offRouteMineChanged(item, modType);
    if (m_offRouteMineCallback) {
      m_offRouteMineCallback(item);
    }
  }
  
  void triggerAesItemChanged(const AesItem& item, DataModification modType) {
    emit aesItemChanged(item, modType);
    if (m_aesCallback) {
      m_aesCallback(item);
    }
  }
  
signals:
  void bcContaminationChanged(const BCContamination& item, DataModification modType);
  void boobyTrapChanged(const BoobyTrap& item, DataModification modType);
  void offRouteMineChanged(const OffRouteMine& item, DataModification modType);
  void aesItemChanged(const AesItem& item, DataModification modType);
  
private:
  std::function<void(const BCContamination&)> m_bcCallback;
  std::function<void(const BoobyTrap&)> m_boobyTrapCallback;
  std::function<void(const OffRouteMine&)> m_offRouteMineCallback;
  std::function<void(const AesItem&)> m_aesCallback;
};

class Ftc;
} // namespace Interface
} // namespace AreaEffectSimulation