#pragma once

// STUB - RTI DDS not available
// This stub provides minimal functionality for building without RTI Connext DDS

#include <LtsSession/ltssession_export.h>
#include <QObject>
#include <QString>
#include <memory>

// Forward declaration - actual type from LtsWidgets
namespace LtsWidgets {
struct TopicInfo {
    // Minimal stub for TopicInfo
    QString topicName;
    int entityId{0};
};
}

namespace LtsSession
{

// STUB: TopicLockHandler - minimal implementation without RTI DDS
class LTSSESSION_EXPORT TopicLockHandler : public QObject
{
    Q_OBJECT
  public:
    TopicLockHandler() = default;
    ~TopicLockHandler() = default;

    bool init(void* coreFtc, int exerciseId)
    {
        Q_UNUSED(coreFtc);
        Q_UNUSED(exerciseId);
        return false; // RTI not available
    }

    bool isLocked() const
    {
        return m_locked;
    }

    LtsWidgets::TopicInfo getTopicInfo() const
    {
        return m_topicInfo;
    }

  public slots:
    void slotTryLock(const LtsWidgets::TopicInfo& topicInfo)
    {
        Q_UNUSED(topicInfo);
        // STUB: no-op
    }
    
    bool slotUnlock()
    {
        return false; // STUB: cannot unlock without RTI
    }
    
    void slotFinalize()
    {
        // STUB: no-op
    }

  signals:
    void signalLockDialog(const QString& lockedBy);
    void signalUnlockDialog();

  private:
    bool lock()
    {
        return false; // STUB
    }
    
    bool unlock()
    {
        return false; // STUB
    }
    
    std::string objStateAsString() const
    {
        return "STUB";
    }

    void* m_coreFtc{nullptr}; // STUB: was std::shared_ptr<Core::Interface::Ftc>
    LtsWidgets::TopicInfo m_topicInfo;
    int m_lockEntityId{0};
    int m_exerciseId{0};
    bool m_locked{false};
    bool m_askedForLock{false};
    bool m_deleteAfterAnswer{false};
};

// STUB: TopicLockHanderData - minimal implementation without RTI DDS
class LTSSESSION_EXPORT TopicLockHanderData : public QObject
{
    Q_OBJECT

  public:
    TopicLockHanderData() = default;
    ~TopicLockHanderData() = default;
    
    void init(void* coreFtc, int exerciseId)
    {
        Q_UNUSED(coreFtc);
        Q_UNUSED(exerciseId);
    }

    void unlock()
    {
        // STUB: no-op
    }
    
    void slotTryLock(const LtsWidgets::TopicInfo& topicInfo)
    {
        Q_UNUSED(topicInfo);
        // STUB: no-op
    }
    
    bool isLocked() const
    {
        return false; // STUB
    }
    
    LtsWidgets::TopicInfo getTopicInfo() const
    {
        return LtsWidgets::TopicInfo{}; // STUB
    }

    const QString& getLockedBy() const
    {
        return m_lockedBy;
    }

  Q_SIGNALS:
    void lockDataChanged();

  public:
    QString m_debugName;

  private Q_SLOTS:
    void slotLock(const QString& lockedBy)
    {
        Q_UNUSED(lockedBy);
        // STUB: no-op
    }
    
    void slotUnlock()
    {
        // STUB: no-op
    }

  private:
    // STUB: No actual TopicLockHandler without RTI
    QObject* m_topicLockHandler{nullptr}; // Was QPointer<TopicLockHandler>
    QString m_lockedBy;
};

} // namespace LtsSession