/**
  * Publish static data (pdm, asm, ism) for THP
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Hanna E. Rathje, SLSE, 2016-01-13
  */

#include "static_publisher.h"
#include <QCryptographicHash>
#include <QJsonDocument>
#include <QTimer>

#include <DDS/DTS/generic_dts_impl.h>

#include <AssetManagement/asm_db.h>
#include <AssetManagement/convert_db_to_dds.h>
#include <ExerciseManagement/exm_db.h>
#include <ExerciseManagement/convert_db_to_dds.h>
#include <FileManagement/flm_db.h>
#include <FileManagement/convert_db_to_dds.h>
#include <InfrastructureManagement/ism_db.h>
#include <InfrastructureManagement/convert_db_to_dds.h>
#include <ParticipantManagement/ppm_db.h>
#include <ParticipantManagement/convert_db_to_dds.h>
#include <ProjectDataManagement/pdm_db.h>
#include <ProjectDataManagement/convert_db_to_dds.h>


namespace SituationReplay
{
StaticPublisher::StaticPublisher(const std::shared_ptr<DdsHandler> &ddsInterface,
                                 const QSqlDatabase &db)
  : m_ddsInterface(ddsInterface)
  , m_db(db)
{
  auto ddsConnector = ddsInterface->ddsReplay();
  m_asmTrainingArea.reset(ddsConnector->createDTS<DTS::TrainingAreaImpl>());
  m_exmExercise.reset(ddsConnector->createDTS<DTS::ExerciseImpl>());
  m_exmExercisePhase.reset(ddsConnector->createDTS<DTS::ExercisePhaseImpl>());
  m_flmFileContent.reset(ddsConnector->createDTS<DTS::FileContentImpl>());
  m_flmFileTypeInfo.reset(ddsConnector->createDTS<DTS::FileTypeInfoImpl>());
  m_flmFolder.reset(ddsConnector->createDTS<DTS::FolderImpl>());

  m_ismMainFootprint.reset(ddsConnector->createDTS<DTS::MainFootprintImpl>());
  m_ismMainStructureElement.reset(ddsConnector->createDTS<DTS::MainStructureElementImpl>());

  m_ppmType.reset(ddsConnector->createDTS<DTS::TypeImpl>());

  m_pdmCanComponentString.reset(ddsConnector->createDTS<DTS::CanComponentStringImpl>());
  m_pdmChargeType.reset(ddsConnector->createDTS<DTS::ChargeTypeImpl>());
  m_pdmFirePurpose.reset(ddsConnector->createDTS<DTS::FirePurposeImpl>());
  m_pdmGearType.reset(ddsConnector->createDTS<DTS::GearTypeImpl>());
  m_ppmGearTypeChargeType.reset(ddsConnector->createDTS<DTS::GearTypeChargeTypeImpl>());
  m_pdmIgniterType.reset(ddsConnector->createDTS<DTS::IgniterTypeImpl>());
  m_pdmIgniterFunction.reset(ddsConnector->createDTS<DTS::IgniterFunctionImpl>());
  m_pdmChargeTypeIgniterTypeIgniterFunction.reset(ddsConnector->createDTS<DTS::ChargeTypeIgniterTypeIgniterFunctionImpl>());
  m_pdmLoadType.reset(ddsConnector->createDTS<DTS::LoadTypeImpl>());
  m_pdmChargeTypeLoadType.reset(ddsConnector->createDTS<DTS::ChargeTypeLoadTypeImpl>());

  m_pdmLanguageHmi.reset(ddsConnector->createDTS<DTS::LanguageHmiImpl>());
  m_pdmTranslationBlob.reset(ddsConnector->createDTS<DTS::TranslationBlobImpl>());
  m_pdmVulnerabilityKind.reset(ddsConnector->createDTS<DTS::VulnerabilityKindImpl>());

  QTimer::singleShot(0, this, &StaticPublisher::publishData);
}

StaticPublisher::~StaticPublisher()
{
  m_asmTrainingArea = nullptr;
  m_exmExercise = nullptr;
  m_exmExercisePhase = nullptr;
  m_flmFileContent = nullptr;
  m_flmFileTypeInfo = nullptr;
  m_flmFolder = nullptr;

  m_ismMainFootprint = nullptr;
  m_ismMainStructureElement = nullptr;

  m_ppmType = nullptr;

  m_pdmCanComponentString = nullptr;
  m_pdmChargeType = nullptr;
  m_pdmFirePurpose = nullptr;
  m_pdmGearType = nullptr;
  m_ppmGearTypeChargeType = nullptr;
  m_pdmIgniterType = nullptr;
  m_pdmIgniterFunction = nullptr;
  m_pdmLoadType = nullptr;
  m_pdmChargeTypeIgniterTypeIgniterFunction = nullptr;
  m_pdmChargeTypeLoadType = nullptr;
  m_pdmLanguageHmi = nullptr;
  m_pdmTranslationBlob = nullptr;
  m_pdmVulnerabilityKind = nullptr;

  m_ddsInterface = nullptr;
}

void StaticPublisher::publishData()
{
  {
    auto db = AssetManagement::DatabaseInterface::create(0);
    db->init(m_db);
    db->select([this](const AssetManagement::Database::AsmTrainingArea &data) { m_asmTrainingArea->write(AssetManagement::Database::convert(data)); });
  }
  {
    auto db = ExerciseManagement::DatabaseInterface::create(0);
    db->init(m_db);
    db->select([this](const ExerciseManagement::Database::ExmExercise &data) { m_exmExercise->write(ExerciseManagement::Database::convert(data)); });
    db->select([this](const ExerciseManagement::Database::ExmExercisePhase &data) { m_exmExercisePhase->write(ExerciseManagement::Database::convert(data)); });
  }
  {
    auto db = FileManagement::DatabaseInterface::create(0);
    db->init(m_db);
    db->select([this](const FileManagement::Database::FlmFileContent &data) { m_flmFileContent->write(FileManagement::Database::convert(data)); emit fileContentAvailable(data); });
    db->select([this](const FileManagement::Database::FlmFileTypeInfo &data) { m_flmFileTypeInfo->write(FileManagement::Database::convert(data)); });
    db->select([this](const FileManagement::Database::FlmFolder &data) { m_flmFolder->write(FileManagement::Database::convert(data)); });
  }
  {
    auto db = InfrastructureManagement::DatabaseInterface::create(0);
    db->init(m_db);
    publishMainStructureElement(db);
  }
  {
    auto db = ParticipantManagement::DatabaseInterface::create(0);
    db->init(m_db);
    db->select([this](const ParticipantManagement::Database::PpmType &data) { m_ppmType->write(ParticipantManagement::Database::convert(data)); });
  }
  {
    auto db = ProjectDataManagement::DatabaseInterface::create(0);
    db->init(m_db);
    db->select([this](const ProjectDataManagement::Database::PdmCanComponentString &data) { m_pdmCanComponentString->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmChargeType &data) { m_pdmChargeType->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmFirePurpose &data) { m_pdmFirePurpose->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmGearType &data) { m_pdmGearType->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmGearTypeChargeType &data) { m_ppmGearTypeChargeType->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmIgniterType &data) { m_pdmIgniterType->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmIgniterFunction &data) { m_pdmIgniterFunction->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmChargeTypeIgniterTypeIgniterFunction &data) { m_pdmChargeTypeIgniterTypeIgniterFunction->write(ProjectDataManagement::Database::convert(data)); });
    db->select([this](const ProjectDataManagement::Database::PdmLanguage &data) { m_pdmLanguageHmi->write(ProjectDataManagement::Database::convert(data)); });
    publishTranslationBlob(db);
    db->select([this](const ProjectDataManagement::Database::PdmVulnerabilityKind &data) { m_pdmVulnerabilityKind->write(ProjectDataManagement::Database::convert(data)); });
  }
  m_db = QSqlDatabase();
}

void StaticPublisher::publishMainStructureElement(const std::shared_ptr<InfrastructureManagement::DatabaseInterface> &db)
{
  // read all MSE from database
  QHash<qint64, InfrastructureManagement::Database::IsmMainStructureElement> mainStructureElements;
  if (!db->select([&mainStructureElements] (const InfrastructureManagement::Database::IsmMainStructureElement &data) { mainStructureElements[data.id] = data;}))
    return;

  // read all SE from database
  QHash<qint64, QVector<InfrastructureManagement::Database::IsmStructureElement>> structureElements;
  if (!db->select([&structureElements](const InfrastructureManagement::Database::IsmStructureElement &data) { structureElements[data.mainStructureElementId].push_back(data);}))
    return;

  QHash<qint64, qint64> seId2mseId;
  for (const auto &mse : qAsConst(mainStructureElements))
  {
    auto mseDds = InfrastructureManagement::Database::convert(mse);
    auto itContSe = structureElements.constFind(mse.id);
    if (itContSe == structureElements.constEnd())
      continue;
    for (const auto &se : itContSe.value())
    {
      // currently only the building, not floors, rooms or mounting points needed 
      // DEDÖÖM we need rooms and floors and every thing else!
      //if (se.structureElementTypeId != InfrastructureManagement::StructureElementType_def::Building)
      //  continue;
      mseDds.elements().push_back(InfrastructureManagement::Database::convert(se));
      seId2mseId[se.id] = mseDds.id();
     // break;
    }
    if (mseDds.elements().size() > 0)
      m_ismMainStructureElement->write(mseDds);
  }

  QHash<int, QMap<int, InfrastructureManagement::Database::IsmStructureElementFootprint>> footprintSorted;
  auto cb = [&footprintSorted](const InfrastructureManagement::Database::IsmStructureElementFootprint &fp)
  {
    footprintSorted[fp.structureElementId][fp.indexNo] = fp;
  };

  if (!db->select(cb))
    return;

  InfrastructureManagement::MainFootprint mf;
  InfrastructureManagement::FootprintElement elem;
  for (const QMap<int, InfrastructureManagement::Database::IsmStructureElementFootprint> &cont : qAsConst(footprintSorted))
  {
    if (cont.empty())
      continue;
    const int structureElementId = cont.first().structureElementId;
    const int mainStructureElementId = seId2mseId.value(structureElementId);
    if (!mainStructureElementId)
      continue;

    mf.id(mainStructureElementId);
    mf.structureElementId(structureElementId);
    mf.name(mainStructureElements.value(mainStructureElementId).name.toStdString());
    mf.elements().clear();
    mf.elements().reserve(cont.size());
    for (const auto &pos : cont)
    {
      elem.id(pos.id);
      elem.relPosition(Core::RelativePosition(pos.relPosition.x(),
                                              pos.relPosition.y(),
                                              pos.relPosition.z()));
      mf.elements().push_back(elem);
    }
    m_ismMainFootprint->write(mf);
  }
}

void StaticPublisher::publishTranslationBlob(const std::shared_ptr<ProjectDataManagement::DatabaseInterface> &db)
{
  QJsonArray arr;
  const auto cb = [&arr](const ProjectDataManagement::Database::PdmTranslation &data)
  {
    arr += QJsonObject({{QStringLiteral("isoCode"), data.isoCode},
                        {QStringLiteral("context"), data.context},
                        {QStringLiteral("key"), data.key},
                        {QStringLiteral("disambiguation"), data.disambiguation},
                        {QStringLiteral("translation"), data.translation}
                       });
  };

  if (!db->select(cb))
    return;

  const QJsonObject jObj{ {QStringLiteral("translations"), arr} };
  const QByteArray data = QJsonDocument(jObj).toBinaryData();
  const QByteArray compressed = qCompress(data, 9);
  const QByteArray md5Sum = QCryptographicHash::hash(compressed, QCryptographicHash::Md5).toHex();

  m_pdmTranslationBlob->write(ProjectDataManagement::TranslationBlob(
                                1,
                                LtsUtils::convert<std::vector<uint8_t>>(compressed),
                                md5Sum.data()));
}

}