#pragma once

#include "json_keys.h"
#include "LtsProjectionWorkstation/ltsprojectionworkstation_export.h"

#include <LtsProjectionWorkstation/vnc_server_manager.h>
#include <LtsWebSocket/client_message.h>
#include <LtsWebSocket/json_keys.h>
#include <QVector>

namespace LtsWebSocket
{
class ReplyHandler;
}

namespace LtsProjectionWorkstation
{

class AbstractMessageHandler
{
  public:
    virtual ~AbstractMessageHandler() = default;
    virtual void handleMessage(LtsWebSocket::AbstractClientMessage* message) = 0;
};

class Reply : public LtsWebSocket::ReplyMessage
{
  public:
    Reply(const QString& type, const int typeId, const QString& uuid, const QJsonObject& data)
        : LtsWebSocket::ReplyMessage(type, typeId, uuid)
    {
        m_jsonRepresentation.insert(LtsWebSocket::JsonKeys::DATA(), data);
    }
};

class Message : public LtsWebSocket::AbstractClientMessage
{
  public:
    Message(AbstractMessageHandler* handler, LtsWebSocket::ReplyHandler* client, const QString& type,
            const QString& uuid, const QJsonValue& data = QJsonValue())
        : LtsWebSocket::AbstractClientMessage(client, type, 1, uuid, data), m_handler(handler)
    {
    }

    LtsWebSocket::ReplyMessage* toReplyMessage() const
    {
        if (!m_handler || !m_client)
            return new Reply(m_type, m_typeId, m_uuid, m_replyData.toObject());
        return nullptr;
    }

    void addReply(LtsWebSocket::ReplyMessage* reply)
    {
        if (m_client)
            m_client->addReply(reply);
    }

  protected:
    AbstractMessageHandler* m_handler;
    QJsonValue m_replyData;
};

class LTSPROJECTIONWORKSTATION_EXPORT ErrorMessage : public Message
{
  public:
    using Message::Message;
    ErrorMessage(const QString& uuid, const QString& reason);

    void process() override final;
    bool hasValidData() const override final;

  private:
    QString m_reason;
};

namespace STC
{

class LTSPROJECTIONWORKSTATION_EXPORT LoginRequestReply : public Message
{
  public:
    enum Reason {
        LoginSuccessful,
        OtherUser,
    };

    using Message::Message;
    LoginRequestReply(const QString& uuid, Reason reason, int reasonUserId, const QVector<VncScreen>& screens);

    void process() override final;
    bool hasValidData() const override final;

    int reasonUserId() const
    {
        return m_reasonUserId;
    }

    Reason reason() const
    {
        return m_reason;
    }

    const QVector<VncScreen>& screens() const
    {
        return m_screens;
    }

  private:
    QVector<VncScreen> m_screens;
    int m_reasonUserId = -1;
    Reason m_reason = LoginSuccessful;
};

class LTSPROJECTIONWORKSTATION_EXPORT DedicatedDisconnect : public Message
{
  public:
    using Message::Message;
    DedicatedDisconnect(const QString& uuid, int userId);

    void process() override final;
    bool hasValidData() const override final;

    int userid() const
    {
        return m_userId;
    }

  private:
    int m_userId = -1;
};

} // namespace STC

namespace CTS
{

class LTSPROJECTIONWORKSTATION_EXPORT LoginRequest : public Message
{
  public:
    using Message::Message;
    LoginRequest(const QString& uuid, int userId, int priority, int exerciseId, const QByteArray& settingsData);

    void process() override final;
    bool hasValidData() const override final;

    int userId() const
    {
        return m_userId;
    }

    int priority() const
    {
        return m_priority;
    }

    int exerciseId() const
    {
        return m_exerciseId;
    }

    const QByteArray& settingsData() const
    {
        return m_settingsData;
    }

  private:
    QByteArray m_settingsData;
    int m_userId = 0;
    int m_priority = 0;
    int m_exerciseId = 0;
};

class LTSPROJECTIONWORKSTATION_EXPORT LogoutRequest : public Message
{
  public:
    using Message::Message;

    explicit LogoutRequest(const QString& uuid)
        : Message(nullptr, nullptr, JsonKeys::LOGOUT_REQUEST(), uuid, QJsonValue())
    {
    }

    void process() override final;
    bool hasValidData() const override final;
};

class LTSPROJECTIONWORKSTATION_EXPORT DisconnectRequest : public Message
{
  public:
    using Message::Message;
    explicit DisconnectRequest(const QString& uuid, int userId);

    void process() override final;
    bool hasValidData() const override final;

    int userId() const
    {
        return m_userId;
    }

  private:
    int m_userId{0};
};

} // namespace CTS

} // namespace LtsProjectionWorkstation