#pragma once

#include "json_keys.h"

#include <LtsWebSocket/json_keys.h>
#include <LtsWebSocket/client_message.h>

#include <LtsProjectionWorkstation/lts_projection_workstation_export.h>
#include <LtsProjectionWorkstation/vnc_server_manager.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 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};

}; 

} 

}