/**
  * @RDE_HEADER@
  * The ClientMessage class is an abstract base class for concrete ClientMessage objects
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Philipp Dassow, SLST, 2017-12-05
  */
#include "client_message.h"

#include <AssetManagement/asm_db.h>
#include <ExerciseManagement/exm_db.h>
#include <FileManagement/flm_db.h>
#include <InfrastructureManagement/ism_db.h>
#include <ParticipantManagement/ppm_db.h>
#include <OperatorManagement/opm_db.h>

#include "WebSocketInterface/Messages/reply_message.h"
#include "WebSocketInterface/json_keys.h"
#include "WebSocketInterface/data_manager.h"

#include <QtCore/QJsonDocument>
#include <QtCore/QUuid>

namespace OcBaseDownload
{
namespace WebSocketInterface
{
namespace Messages
{
using namespace JsonKeys;

// ####### ClientMessageFactory begin #######
ClientMessageFactory::ClientMessageFactory(DataManager *dataManager)
  : LtsWebSocket::AbstractClientMessageFactory(getLogger("ClientMessageFactory"))
  , m_dataManager(dataManager)
{}

LtsWebSocket::AbstractClientMessage *ClientMessageFactory::createMessage(LtsWebSocket::ReplyHandler *client,
                                                                         const QString &message)
{
  LtsWebSocket::AbstractClientMessage *result = checkAttributes(client, message);
  if (result)
    return result;

  if (m_type == LtsWebSocket::JsonKeys::ERROR_())
    result = new ErrorMessage(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // SCM telegram
  else if (m_type == ServiceManagement::WebSocketInterface::JsonKeys::SERVICE_PORTS_INFORMATION())
    result = new ServicePortsInformation(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // ASM telegrams
  else if (m_type == AssetManagement::WebSocketInterface::JsonKeys::TRAINING_AREA_BASE_DATA())
    result = new BaseData<AssetManagement::DatabaseInterface, AssetManagement::Database::AsmTrainingArea>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == AssetManagement::WebSocketInterface::JsonKeys::TECHNICAL_AREA_BASE_DATA())
    result = new BaseData<AssetManagement::DatabaseInterface, AssetManagement::Database::AsmTechnicalArea>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == AssetManagement::WebSocketInterface::JsonKeys::LOCATION_BASE_DATA())
    result = new BaseData<AssetManagement::DatabaseInterface, AssetManagement::Database::AsmLocation>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == AssetManagement::WebSocketInterface::JsonKeys::ASM_ASSET_BASE_DATA())
    result = new BaseData<AssetManagement::DatabaseInterface, AssetManagement::Database::AsmAsset>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // EXM telegrams
  else if (m_type == ExerciseManagement::WebSocketInterface::JsonKeys::EXERCISE_BASE_DATA())
    result = new BaseData<ExerciseManagement::DatabaseInterface, ExerciseManagement::Database::ExmExercise>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == ExerciseManagement::WebSocketInterface::JsonKeys::EXERCISE_PHASE_BASE_DATA())
    result = new BaseData<ExerciseManagement::DatabaseInterface, ExerciseManagement::Database::ExmExercisePhase>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == ExerciseManagement::WebSocketInterface::JsonKeys::EXERCISE_STATE_CHANGE_BASE_DATA())
    result = new BaseData<ExerciseManagement::DatabaseInterface, ExerciseManagement::Database::ExmExerciseStateChange>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // ISM telegrams
  else if (m_type == InfrastructureManagement::WebSocketInterface::JsonKeys::ISM_ASSET_BASE_DATA())
    result = new BaseData<InfrastructureManagement::DatabaseInterface, InfrastructureManagement::Database::IsmAsset>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == InfrastructureManagement::WebSocketInterface::JsonKeys::MAIN_STRUCTURE_ELEMENT_BASE_DATA())
    result = new BaseData<InfrastructureManagement::DatabaseInterface, InfrastructureManagement::Database::IsmMainStructureElement>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == InfrastructureManagement::WebSocketInterface::JsonKeys::STRUCTURE_ELEMENT_BASE_DATA())
    result = new BaseData<InfrastructureManagement::DatabaseInterface, InfrastructureManagement::Database::IsmStructureElement>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == InfrastructureManagement::WebSocketInterface::JsonKeys::STRUCTURE_ELEMENT_FOOTPRINT_BASE_DATA())
    result = new BaseData<InfrastructureManagement::DatabaseInterface, InfrastructureManagement::Database::IsmStructureElementFootprint>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == InfrastructureManagement::WebSocketInterface::JsonKeys::MOUNTING_POINT_ASSET_BASE_DATA())
    result = new BaseData<InfrastructureManagement::DatabaseInterface, InfrastructureManagement::Database::IsmMountingPointAsset>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == InfrastructureManagement::WebSocketInterface::JsonKeys::MOUNTING_POINT_SCHEDULE_BASE_DATA())
    result = new BaseData<InfrastructureManagement::DatabaseInterface, InfrastructureManagement::Database::IsmMountingPointSchedule>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == InfrastructureManagement::WebSocketInterface::JsonKeys::MOUNTING_POINT_PLAN_BASE_DATA())
    result = new BaseData<InfrastructureManagement::DatabaseInterface, InfrastructureManagement::Database::IsmMountingPointPlan>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // PPM Ex0 telegrams
  else if (m_type == ParticipantManagement::WebSocketInterface::JsonKeys::EQUIPMENT_TYPE_BASE_DATA())
    result = new BaseData<ParticipantManagement::DatabaseInterface, ParticipantManagement::Database::PpmEquipmentType>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == ParticipantManagement::WebSocketInterface::JsonKeys::TYPE_BASE_DATA())
    result = new BaseData<ParticipantManagement::DatabaseInterface, ParticipantManagement::Database::PpmType>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // PPM ExN telegrams
  else if (m_type == ParticipantManagement::WebSocketInterface::JsonKeys::PARTY_BASE_DATA())
    result = new BaseData<ParticipantManagement::DatabaseInterface, ParticipantManagement::Database::PpmParty>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == ParticipantManagement::WebSocketInterface::JsonKeys::PARTICIPANT_BASE_DATA())
    result = new BaseData<ParticipantManagement::DatabaseInterface, ParticipantManagement::Database::PpmParticipant>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // OPM telegrams
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::GROUP_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmGroup>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::GROUP_GROUP_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmGroupGroup>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::OPERATOR_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmOperator>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::OPERATOR_EXERCISE_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmOperatorExercise>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::SETTINGS_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmSettings>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::ACCESS_CONTROL_LEVEL_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmAccessControlLevel>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::ACL_ALLOW_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmAclAllow>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == OperatorManagement::WebSocketInterface::JsonKeys::ACL_DENY_BASE_DATA())
    result = new BaseData<OperatorManagement::DatabaseInterface, OperatorManagement::Database::OpmAclDeny>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  // FLM telegrams
  else if (m_type == FileManagement::WebSocketInterface::JsonKeys::FOLDER_BASE_DATA())
    result = new BaseData<FileManagement::DatabaseInterface, FileManagement::Database::FlmFolder>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == FileManagement::WebSocketInterface::JsonKeys::FILE_CONTENT_BASE_DATA())
    result = new BaseData<FileManagement::DatabaseInterface, FileManagement::Database::FlmFileContent>(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
  else if (m_type == FileManagement::WebSocketInterface::JsonKeys::PDF_LIST_DATA())
    result = new PdfListMessage(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);

  return checkResult(client, message, result);
}
// ####### ClientMessageFactory end #######

// ####### ClientMessage begin #######
ClientMessage::ClientMessage(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data)
  : LtsWebSocket::AbstractClientMessage(client, type, typeId, uuid, data)
  , m_dataManager(dataManager)
  , m_logger(getLogger("ClientMessage"))
{}
// ####### ClientMessage end #######

// ####### ServicesInformation begin #######
ErrorMessage::ErrorMessage(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data)
  : ClientMessage(dataManager, client, type, typeId, uuid, data)
{}

void ErrorMessage::process()
{
  ErrorData err;
  err.errorClass = m_data.toObject().value(LtsWebSocket::JsonKeys::ERROR_CLASS()).toInt();
  err.uuid = m_data.toObject().value(LtsWebSocket::JsonKeys::UUID_()).toString();
  err.errorMessage = m_data.toObject().value(LtsWebSocket::JsonKeys::ERROR_MESSAGE()).toString();
  m_dataManager->handleErrorMessage(err);
}

bool ErrorMessage::hasValidData() const
{
  return true;
}
// ####### ErrorMessage end #######

// ####### ServicesInformation begin #######
ServicePortsInformation::ServicePortsInformation(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data)
  : ClientMessage(dataManager, client, type, typeId, uuid, data)
{}

void ServicePortsInformation::process()
{
  const QJsonArray exerciseInformationArray = m_data.toArray();
  QVector<ExerciseInformation> exercises;
  QVector<ServiceInformation> services;
  QVector<PortInformation> ports;
  exercises.reserve(exerciseInformationArray.size());

  for (const auto &exerciseJsonValue : exerciseInformationArray)
  {
    QJsonObject exerciseJsonObject = exerciseJsonValue.toObject();
    ExerciseInformation exercise;

    exercise.exerciseId = exerciseJsonObject.value(ServiceManagement::WebSocketInterface::JsonKeys::EXERCISE_ID()).toInt();
    if (exerciseJsonObject.contains(ServiceManagement::WebSocketInterface::JsonKeys::REPLAY_PARTITION_ID()))
      exercise.replayPartitionId = dds::core::optional<int32_t>(exerciseJsonObject.value(ServiceManagement::WebSocketInterface::JsonKeys::REPLAY_PARTITION_ID()).toInt());

    const QJsonArray servicesJsonArray = exerciseJsonObject.value(ServiceManagement::WebSocketInterface::JsonKeys::SERVICES()).toArray();

    // prepare vector
    services.clear();
    services.reserve(servicesJsonArray.size());

    for (const auto &serviceValue : servicesJsonArray)
    {
      ServiceInformation service;
      QJsonObject serviceObject = serviceValue.toObject();

      service.name = serviceObject.value(ServiceManagement::WebSocketInterface::JsonKeys::NAME()).toString();
      service.abbreviation = serviceObject.value(ServiceManagement::WebSocketInterface::JsonKeys::NAME_ABBR()).toString();

      const QJsonArray portsJsonArray = serviceObject.value(ServiceManagement::WebSocketInterface::JsonKeys::PORTS()).toArray();

      // prepare vector
      ports.clear();
      ports.reserve(portsJsonArray.size());

      for (const auto &portValue : portsJsonArray)
      {
        QJsonObject portObject = portValue.toObject();
        PortInformation port;

        port.number = portObject.value(ServiceManagement::WebSocketInterface::JsonKeys::NUMBER()).toInt();
        port.type = portObject.value(ServiceManagement::WebSocketInterface::JsonKeys::TYPE_ID()).toInt();

        ports.append(port);
      }
      service.ports = ports;
      services.append(service);
    }
    exercise.services = services;
    exercises.append(exercise);
  }

  m_dataManager->servicePortsInformation(exercises);
}

bool ServicePortsInformation::hasValidData() const
{
  return true;
}
// ####### ServicesInformation end #######

// ####### BaseData begin #######
template <typename DB, typename T>
BaseData<DB, T>::BaseData(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, QJsonValue &data)
  : ClientMessage(dataManager, client, type, typeId, uuid, data)
{}

template <typename DB, typename T>
void BaseData<DB, T>::process()
{
  m_dataManager->baseData<T>(DB::template fromJson<T>(m_data.toArray()));
}

template <typename DB, typename T>
bool BaseData<DB, T>::hasValidData() const
{
  return true;
}
// ####### BaseData end #######

// ####### PdfListData begin #######
PdfListMessage::PdfListMessage(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, QJsonValue &data)
  : ClientMessage(dataManager, client, type, typeId, uuid, data)
{}

void PdfListMessage::process()
{
  PdfListData data;

  using namespace FileManagement::WebSocketInterface::JsonKeys;

  if (m_data.isArray())
  {
    data.pdfData.reserve(m_data.toArray().size());

    QJsonArray arr = m_data.toArray();

    for (const QJsonValue &current : qAsConst(arr))
    {
      if (!current.isObject())
        continue;

      QJsonObject obj = current.toObject();

      data.pdfData.append({obj.value(FILE_ID()).toInt(),
                           obj.value(NAME()).toString(),
                           obj.value(FILE_SIZE()).toInt(),
                           FileManagement::FileCategory::inner_enum(obj.value(FILE_CATEGORY()).toInt()),
                           obj.value(IS_TEMPLATE()).toBool(),
                           obj.value(PROPERTIES()),
                           FileManagement::FileStatus::inner_enum(obj.value(FILE_STATUS()).toInt()),
                           obj.value(FOLDER_ID()).toInt(),
                           obj.value(PHASE_ID()).toInt(),
                           obj.value(OPERATOR_ID()).toInt(),
                           obj.value(EXERCISE_ID()).toInt()
                          });
    }
  }

  m_dataManager->handlePdfListMessage(data);
}

bool PdfListMessage::hasValidData() const
{
  return true;
}
// ####### PdfListData end #######

} // namespace Messages
} // namespace WebSocketInterface
} // namespace OcBaseDownload