qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Plugins/Timeline/Gui/EventTimelineClassic/detail_data.cpp

#include "detail_data.h"
#include "logger.h"
#include "tln_legend.h"
#include "attribute_value_lookup.h"

#include <LtsTimelineClassic/Event.h>
#include <LtsWidgets/lts_date_time_edit.h>
#include <LtsSession/lts_session.h>
#include <LtsUtilsSettings/settings.h>


#include <ParticipantManagement/ppm_data_plugin_interface.h>
#include <Plugins/MarkerManagement/mrk_data_plugin_interface.h>
#include <Plugins/InfrastructureManagement/ism_data_plugin_interface.h>
#include <Plugins/OperatorManagement/opm_data_plugin_interface.h>
#include <Plugins/AudioVideoManagement/avm_data_plugin_interface.h>
#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>



#include <Services/ExerciseEventManagement/eem_enums.hpp>
#include <Services/ExerciseEventManagement/eem_translation.h>
#include <Services/ProjectDataManagement/pdm_translation.h>
#include <Services/AreaEffectSimulation/aes_translation.h>
#include <Services/MarkerManagement/mrk_translation.h>

#include <QtCore/QJsonDocument>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonValue>
#include <QtCore/QVariant>


namespace Timeline
{

static inline QString removeSpaces(const QString &str)
{
  
  QString ret;
  ret.reserve(str.size());
  for (const QChar c : str)
  {
    if (!c.isSpace())
      ret += c;
  }
  return ret;
}

DetailData::DetailData(LtsSession::LtsSession *session, QObject *parent)
  : QObject(parent)
  , m_session(session)
  , __already_populated__(false)
{
  populate();
}

void DetailData::addRedirectedAttributeType(const QString &newAttributeTypeId, const QString &attributeText, const QString &redirectToAttributeTypeId)
{
  attributeTypeLookup.addAttributeText(newAttributeTypeId, attributeText);
  attributeRedirectionLookup.addRedirection(newAttributeTypeId, redirectToAttributeTypeId);
}


void DetailData::addAttributeType(const QString &attributeTypeId, const QString &attributeText, const int uiTypeId, const int interpreterTypeId)
{
  attributeTypeLookup.addAttributeText(attributeTypeId, attributeText);
  attributeUITypeLookup.addUITypeToAttribute(attributeTypeId, uiTypeId);
  attributeInterpreterLookup.addInterpreterTypeToAttribute(attributeTypeId, interpreterTypeId);
}


void DetailData::addEventType(int eventTypeId, const QString &eventTypeString) 
{
  eventTypeLookup.addEventType(eventTypeId, eventTypeString);
  attributeEventLookup.addAttributesToEvent(eventTypeId, {QStringLiteral("TimeRange")});
}


void DetailData::addEventType(const ProjectDataManagement::EventType &eventType) 
{
  addEventType(eventType.underlying(), ProjectDataManagement::toString(eventType));
}


void DetailData::populate() 
{
  if (__already_populated__) 
    return;
  __already_populated__ = true;



  

  
  

  addEventType(0, tr("General")); 

  addEventType(markerTypeId, tr("Marker"));
  attributeEventLookup.addAttributesToEvent(markerTypeId, {QStringLiteral("MarkerName"),
                                                           QStringLiteral("MarkerNote"),
                                                           QStringLiteral("Operator"),
                                                           QStringLiteral("MarkerOffset"),
                                                           QStringLiteral("IsSituationType"),
                                                           QStringLiteral("IsVideoType"),
                                                           QStringLiteral("IsAudioType")});


  using namespace ProjectDataManagement;
  const auto possibleEventTypes = TimelineLegendDialog::possibleEvents();
  for (const auto eventType : possibleEventTypes)
  {
    switch (eventType.underlying())
    {
    case EventType::Hit:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("VulnerabilityState"),
                                                            QStringLiteral("OriginatorChargeTypeId"),
                                                            QStringLiteral("FriendlyFire"),
                                                            
                                                            
                                                            QStringLiteral("OriginatorEquipmentNumber")});
      break;
    case EventType::BiteMessage:
      break;
    case EventType::WeaponAssignment:
    case EventType::FireEvent:
      attributeEventLookup.addAttributesToEvent(eventType, {
                                                            QStringLiteral("GearTypeId"),
                                                            QStringLiteral("ChargeTypeId")});
      break;
    case EventType::HitBuilding:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("AesType"),
                                                            QStringLiteral("ChargeTypeId"),
                                                            QStringLiteral("OriginatorEquipmentNumber"),
                                                            QStringLiteral("MainStructureElementId"),
                                                            QStringLiteral("VulnerabilityState"),
                                                            QStringLiteral("damagePercent"), 
                                                            
                                                }); 
      break;
    case EventType::Manipulation:
      break;
    case EventType::Sanitation:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("Vitality"),
                                                            QStringLiteral("SanitationProceduresNeeded"),
                                                            QStringLiteral("SanitationProceduresTaken")});
      break;
    case EventType::CameraVideo:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("PartyId"),
                                                            QStringLiteral("MainStructureElementId"),
                                                            QStringLiteral("duration"),
                                                            QStringLiteral("streamName")});
      break;
    case EventType::RadioCnr:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("PartyId"),
                                                            QStringLiteral("duration"),
                                                            QStringLiteral("streamName")});
      break;
    case EventType::RadioTvc:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("duration"),
                                                            QStringLiteral("streamName")});

      break;
    case EventType::HitEffectSimulation:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("AesType"),
                                                            QStringLiteral("AesName"),
                                                            QStringLiteral("OriginatorChargeTypeId")});
      break;
    case EventType::HitC:
    case EventType::HitB:
    case EventType::HitMine:
    case EventType::EnterMineArea:
    case EventType::LeaveMineArea:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("AesName"),
                                                            QStringLiteral("OriginatorChargeTypeId")});
      break;
    case EventType::HitN:
    case EventType::HitGasPipe:
    case EventType::EnterDangerArea:
    case EventType::LeaveDangerArea:
    case EventType::CrossLocalBorderline:
    case EventType::CrossGlobalBorderline:
    case EventType::EnterFunctionalArea:
    case EventType::LeaveFunctionalArea:
    case EventType::EnterNuclear:
    case EventType::LeaveNuclear:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("AesName")});
      break;
    case EventType::Borderline:
    case EventType::NContamination:
    case EventType::DangerArea:
    case EventType::FunctionalArea:
    case EventType::MineCorridor:
    case ProjectDataManagement::EventType::GasPipe:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("AesName"),
                                                            QStringLiteral("duration")});
      break;
    case EventType::MineArea:
    case EventType::BCContamination:
      attributeEventLookup.addAttributesToEvent(eventType, {QStringLiteral("AesName"),
                                                            QStringLiteral("duration"),
                                                            QStringLiteral("ChargeTypeId")});
      break;
    case EventType::Unknown:
    case EventType::FriendlyFire:
    case EventType::TechnicalArea:
    case EventType::EquipmentErrorReport:
    case EventType::EmergencyCall:
      Q_ASSERT(false);
      continue;
    }
    addEventType(eventType);
  }

  
  


  


  

  addAttributeType(QStringLiteral("TimeRange"), tr("Time range:"), ATTRIBUTE_UI_TYPE_TIME_RANGE_WIDGET , INTERPRETER_TYPE_TIME); 


  
  addAttributeType(QStringLiteral("VulnerabilityState"), tr("Vulnerability State:"));
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::CombatReady);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::LightDamage);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::MediumDamage);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::HeavyDamage);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::MobilityKill);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::VisibleMobilityKill);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::WeaponSystemDamage);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::VisibleWeaponSystemDamage);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::CatastrophicKill);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::TemporarySeverance);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::NearMiss);
  addAttributeValue(QStringLiteral("VulnerabilityState"), ProjectDataManagement::VulnerabilityState::HitWithNoEffect);
  


  
  addAttributeTypeWithYesAndNo(QStringLiteral("IsSituationType"), tr("Is situation type:"));
  addAttributeTypeWithYesAndNo(QStringLiteral("IsVideoType"), tr("Is video type:"));
  addAttributeTypeWithYesAndNo(QStringLiteral("IsAudioType"), tr("Is audio type:"));


  

  addAttributeType(QStringLiteral("AesType"), tr("Aes Type:"));

  
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtNContamination);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtBCContamination);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtExplosionArea);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtExplosionSingle);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtMineArea);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtDangerArea);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtFunctionalArea);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtMineCorridor);
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtBorderline);
  
  
  addAttributeValue(QStringLiteral("AesType"), AreaEffectSimulation::AesType::AtMineAreaSingleMines);


  
  addAttributeTypeWithYesAndNo(QStringLiteral("FriendlyFire"), tr("Friendly Fire:"));

  
  addAttributeTypeWithYesAndNo(QStringLiteral("DryFire"), tr("Dry Fire:"));




  
  addAttributeType(QStringLiteral("MarkerName"), tr("Name:"), ATTRIBUTE_UI_TYPE_CHECKBOX , INTERPRETER_TYPE_NONE);
  addAttributeType(QStringLiteral("MarkerNote"), tr("Note:"), ATTRIBUTE_UI_TYPE_CHECKBOX , INTERPRETER_TYPE_NONE);


  
  


  
  addAttributeType(QStringLiteral("MarkerOffset"), tr("Offset [msecs]:"), ATTRIBUTE_UI_TYPE_DEFAULT_RANGE_WIDGET , INTERPRETER_TYPE_RANGE);
  {
    DetailData::AttributeParameterLookup::ParameterMap pm;
    pm.insert(DetailData::UI_PARAM_TYPE_MIN, QVariant::fromValue<unsigned int>(0));
    pm.insert(DetailData::UI_PARAM_TYPE_MAX, QVariant::fromValue<unsigned int>(9999999));
    pm.insert(DetailData::UI_PARAM_TYPE_SUFFIX, QVariant::fromValue<QString>(QString()));
    pm.insert(DetailData::UI_PARAM_TYPE_PREFIX, QVariant::fromValue<QString>(QString()));
    attributeParameterLookup.addParameter(QStringLiteral("MarkerOffset"), pm);
  }


  
  addAttributeType(QStringLiteral("duration"), tr("Duration [msecs]:"), ATTRIBUTE_UI_TYPE_DEFAULT_RANGE_WIDGET , INTERPRETER_TYPE_RANGE);
  {
    DetailData::AttributeParameterLookup::ParameterMap pm;
    pm.insert(DetailData::UI_PARAM_TYPE_MIN, QVariant::fromValue<unsigned int>(0));
    pm.insert(DetailData::UI_PARAM_TYPE_MAX, QVariant::fromValue<unsigned int>(99999999));
    pm.insert(DetailData::UI_PARAM_TYPE_SUFFIX, QVariant::fromValue<QString>(QString()));
    pm.insert(DetailData::UI_PARAM_TYPE_PREFIX, QVariant::fromValue<QString>(QString()));
    attributeParameterLookup.addParameter(QStringLiteral("duration"), pm);
  }


  
  addAttributeType(QStringLiteral("damagePercent"), tr("Damage [%]:"), ATTRIBUTE_UI_TYPE_DEFAULT_RANGE_WIDGET , INTERPRETER_TYPE_RANGE);
  addRedirectedAttributeType(QStringLiteral("damagePercentOld"), tr("Damage before [%]:"), QStringLiteral("damagePercent"));

  {
    DetailData::AttributeParameterLookup::ParameterMap pm;
    pm.insert(DetailData::UI_PARAM_TYPE_MIN, QVariant::fromValue<unsigned int>(0));
    pm.insert(DetailData::UI_PARAM_TYPE_MAX, QVariant::fromValue<unsigned int>(100));
    pm.insert(DetailData::UI_PARAM_TYPE_SUFFIX, QVariant::fromValue<QString>(tr(" %")));
    pm.insert(DetailData::UI_PARAM_TYPE_PREFIX, QVariant::fromValue<QString>(QString()));
    attributeParameterLookup.addParameter(QStringLiteral("damagePercent"), pm); 
  }

  
  std::shared_ptr<ParticipantManagement::Interface::Dtc> dtcPpm;
  m_session->getDtc<ParticipantManagement::DataInterface>(dtcPpm);
  addAttributeType(QStringLiteral("EquipmentNumber"), tr("Equip. No.:"));
  m_attributeValueLookupDtc.addHandlerForDtc(QStringLiteral("EquipmentNumber"), new AvmEquipmentNumber(dtcPpm));
  addRedirectedAttributeType(QStringLiteral("OriginatorEquipmentNumber"), tr("Equip. No. of Originator:"), QStringLiteral("EquipmentNumber"));

  std::shared_ptr<ProjectDataManagement::Interface::Dtc> dtcPdm;
  m_session->getDtc<ProjectDataManagement::DataInterface>(dtcPdm);
  
  addAttributeType(QStringLiteral("ChargeTypeId"), tr("Charge Type:")); 
  addRedirectedAttributeType(QStringLiteral("OriginatorChargeTypeId"), tr("Originator Charge Type:"), QStringLiteral("ChargeTypeId"));
  m_attributeValueLookupDtc.addHandlerForDtc(QStringLiteral("ChargeTypeId"), new AvmChargeType(dtcPdm));

  
  addAttributeType(QStringLiteral("GearTypeId"), tr("Gear Type:"));
  m_attributeValueLookupDtc.addHandlerForDtc(QStringLiteral("GearTypeId"), new AvmGearType(dtcPdm));

  
  addAttributeType(QStringLiteral("OriginatorType"), tr("Originator Type:"));
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::Unknown);
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::Participant);
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::AreaEffectSimulation);
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::ObserverController);
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::ExerciseControl);
  
  
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::FunctionalArea);
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::Initialization);
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::ImprovisedExplosiveDevice);
  addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::DusMine);
  const bool showPvSan = LtsUtils::ProjectSettings::isFunctionEnabled(QStringLiteral("ParticipantInformation"),
                                                                      QStringLiteral("HasPvSan"));
  if (showPvSan)
    addAttributeValue(QStringLiteral("OriginatorType"), ProjectDataManagement::StateChangeOriginator::Sanitation);


  
  std::shared_ptr<InfrastructureManagement::Interface::Dtc> dtcIsm;
  m_session->getDtc<InfrastructureManagement::DataInterface>(dtcIsm);
  addAttributeType(QStringLiteral("MainStructureElementId"), tr("Building:"));
  m_attributeValueLookupDtc.addHandlerForDtc(QStringLiteral("MainStructureElementId"), new AvmBuilding(dtcIsm));

  
  addAttributeType(QStringLiteral("PartyId"), tr("Party:"));
  m_attributeValueLookupDtc.addHandlerForDtc(QStringLiteral("PartyId"), new AvmParty(dtcPpm));

  
  std::shared_ptr<OperatorManagement::Interface::Dtc> dtcOpm;
  m_session->getDtc<OperatorManagement::DataInterface>(dtcOpm);
  addAttributeType(QStringLiteral("Operator"), tr("Operator:"));
  m_attributeValueLookupDtc.addHandlerForDtc(QStringLiteral("Operator"), new AvmOperator(dtcOpm));


  
  std::shared_ptr<AudioVideoManagement::Interface::Dtc> dtcAvm;
  m_session->getDtc<AudioVideoManagement::DataInterface>(dtcAvm);
  addAttributeType(QStringLiteral("streamName"), tr("Stream Name:"));
  m_attributeValueLookupDtc.addHandlerForDtc(QStringLiteral("streamName"), new AvmStreamName(dtcAvm));
}

DetailData::GetDetailDataResultList DetailData::getDetailData(const LtsTimelineClassic::Event *event)
{
  GetDetailDataResultList result;

  if (event->detailData().isEmpty()) 
    return result;

  const QJsonObject &root = event->detailData();
  for (auto i = root.constBegin(); i != root.constEnd(); ++i)
  {
    DEBUG_LOG(m_logger) << "Adding Detail Data for: " << i.key();
    result.append(getDetailDataForAttribute(i.key(), *i));
  }

  return result;
}


DetailData::GetDetailDataForAttributeResult DetailData::getDetailDataForAttribute(const LtsTimelineClassic::Event *event, const QString &attributeType)
{
  GetDetailDataForAttributeResult result;

  const QJsonObject &root = event->detailData();
  root[QStringLiteral("TimeRange")] = event->startTime() / 1000 ; 
  root[QStringLiteral("PartyId")] = event->partyId();

  const QJsonValue attribute = root[attributeType];

  if (attribute.isNull() || attribute.isUndefined())
  {
    WARNING_LOG(m_logger) << "DetailData::getDetailDataForAttribute: no attribute type " << attributeType
                          << " in " << QJsonDocument(root).toJson();

    result.requestResult = DetailData::RequestResult::InvalidAttributeType;
    return result;
  }

  return getDetailDataForAttribute(attributeType, attribute);
}


DetailData::GetDetailDataForAttributeResult DetailData::getDetailDataForAttribute(const QString &attributeType, const QJsonValue &attributeValueJson)
{
  GetDetailDataForAttributeResult result;
  result.attributeTypeId = attributeType;
  result.attributeValueId = -1;
  result.requestResult = DetailData::RequestResult::Error;
  QString attributeTypeTranslated = attributeTypeLookup.getAttributeText(attributeType);

  if (attributeTypeTranslated.isEmpty())
  {
    result.requestResult = DetailData::RequestResult::InvalidAttributeType;
    
    return result;
  }

  result.attributeType = attributeTypeTranslated;

  int attributeValueId = -1;

  


  switch (attributeValueJson.type())
  {
    
    case QJsonValue::Double:
    {
      attributeValueId = attributeValueJson.toInt(-1);
      break;
    }

    case QJsonValue::Null:
    case QJsonValue::Undefined:
    {
      WARNING_LOG(m_logger) << "Timeline: DetailData::getDetailDataForAttribute: attribute value is null or undefined! " << attributeValueJson.toString();
      result.requestResult = DetailData::RequestResult::InvalidAttributeTypeJson;
      return result;
    }

    case QJsonValue::Bool:
    {
      attributeValueId = attributeValueJson.toBool() ? 1 : 0;
      break;
    }

    case QJsonValue::String:
    {
      bool k = false;
      QString attributeValueString = attributeValueJson.toString();

      if (attributeValueString.isEmpty())
      {
        attributeValueId = -1;
        break;
      }

      attributeValueId = attributeValueString.toInt(&k);

      if (!k) 
      {
        result.attributeValue = attributeValueString;
        result.requestResult = DetailData::RequestResult::Okay;
        return result;
      }

      break;
    }

    default:
    {
      WARNING_LOG(m_logger) << "Timeline: DetailData::getDetailDataForAttribute: attribute value cannot be handled. Type " << attributeValueJson.type() << attributeValueJson.toString();
      result.requestResult = DetailData::RequestResult::InvalidAttributeType;
      return result;
    }
  }

  if (attributeValueId == -1)
  {
    result.requestResult = DetailData::RequestResult::InvalidAttributeType;
    return result;
  }

  result.attributeValueId = attributeValueId;


  
  int attributeUiType = attributeUITypeLookup.getUIType(attributeType);
  switch (attributeUiType)
  {
    
    case ATTRIBUTE_UI_TYPE_TIME_RANGE_WIDGET:
    case ATTRIBUTE_UI_TYPE_DEFAULT_RANGE_WIDGET:
    case ATTRIBUTE_UI_TYPE_RAD_RANGE_WIDGET:
    case ATTRIBUTE_UI_TYPE_AREA_RANGE_WIDGET:
    {
      result.attributeValue = QString::number(attributeValueId); 
      result.requestResult = DetailData::RequestResult::Okay;

      break;
    }

    
    case ATTRIBUTE_UI_TYPE_COMBO_BOX:
    case ATTRIBUTE_UI_TYPE_CHECKBOX:
    {
      result.attributeValue = attributeValueLookup.getValueStringFromValueId(attributeType, attributeValueId);
      if (result.attributeValue.isEmpty())
        result.attributeValue = m_attributeValueLookupDtc.getValueStringFromValueId(attributeType, attributeValueId);
      result.requestResult = DetailData::RequestResult::Okay;
      break;
    }


    default: 
    {
      
      QString concreteAttributeType = attributeRedirectionLookup.getRedirection(attributeType);

      if (concreteAttributeType == attributeType) 
      {
        ERROR_LOG(m_logger) << "getDetailDataForAttribute: attribute type " << attributeType << " does not have an UiType !!!";
        result.requestResult = DetailData::RequestResult::NoUiTypeForAttribute;
      }
      else 
      {
        

        
        QString attributeType = result.attributeType;
        QString attributeTypeId = result.attributeTypeId;

        result = getDetailDataForAttribute(concreteAttributeType, attributeValueJson);

        result.attributeType = attributeType;
        result.attributeTypeId = attributeTypeId;
      }

      break;
    }
  }

  return result;
}


void DetailData::createRetrieveCurrentTimeCallback(LtsWidgets::LtsDateTimeEdit *dateTimeEdit)
{
  dateTimeEdit->setRetrieveCurrentTimeCallback([this]() { return m_session->partitionTime(); });
}



DetailData::LookupBase::LookupBase(const QString &lookupClassName)
  : m_lookupClassName(lookupClassName)
  , m_logger(getLogger(QStringLiteral("DetailData.") + lookupClassName))
{

}



DetailData::EventTypeLookup::EventTypeLookup()
  : LookupBase(QStringLiteral("EventTypeLookup"))
{
}

void DetailData::EventTypeLookup::addEventType(const int key, const QString &value)
{
  m_eventTypeMap.insert(key, value);
}

int DetailData::EventTypeLookup::getEventType(const QString &eventText) const
{
  

  const QString paramText = removeSpaces(eventText);
  for (auto i = m_eventTypeMap.constBegin(); i != m_eventTypeMap.constEnd(); ++i)
  {
    const QString mapText = removeSpaces(i.value());
    if (mapText == paramText)
      return i.key();
  }

  return -1; 
}

QString DetailData::EventTypeLookup::getEventText(const int eventType) const
{
  return m_eventTypeMap.value(eventType);
}

bool DetailData::EventTypeLookup::isEventExists(const int eventType) const
{
  return m_eventTypeMap.contains(eventType);
}

QStringList DetailData::EventTypeLookup::getEventTexts() const
{
  return m_eventTypeMap.values();
}




DetailData::AttributeEventLookup::AttributeEventLookup()
  : LookupBase(QStringLiteral("AttributeEventLookup"))
{
}

void DetailData::AttributeEventLookup::addAttributesToEvent(const int eventType, const AttributeList &attributeTypeList)
{
  AttributeList &al = m_attributeEventLookupMap[eventType];
  al += attributeTypeList;
}

void DetailData::AttributeEventLookup::addAttributesToEvent(const ProjectDataManagement::EventType &eventType, const AttributeList &attributeTypeList)
{
  addAttributesToEvent(eventType.underlying(), attributeTypeList);
}

bool DetailData::AttributeEventLookup::isAttributeInEvent(const int eventType, const QString &attributeType)
{
  auto eventTypeIt = m_attributeEventLookupMap.constFind(eventType);

  if (eventTypeIt == m_attributeEventLookupMap.constEnd())
    return false; 

  const AttributeList &attributeList = *eventTypeIt;

  if (attributeList.contains(attributeType))
    return true;

  return false;
}

DetailData::AttributeEventLookup::AttributeList DetailData::AttributeEventLookup::getEventsAttributeList(const int eventType) const 
{
  return m_attributeEventLookupMap.value(eventType);
}




DetailData::AttributeTypeLookup::AttributeTypeLookup()
  : LookupBase(QStringLiteral("AttributeTypeLookup"))
{
}

void DetailData::AttributeTypeLookup::addAttributeText(const QString &attributeType, const QString &attributeText)
{
  m_attributeTypeLookupMap.insert(attributeType, attributeText);
}

QString DetailData::AttributeTypeLookup::getAttributeType(const QString &attributeText) const
{
  const QString paramText = removeSpaces(attributeText);
  
  for (auto i = m_attributeTypeLookupMap.constBegin(); i != m_attributeTypeLookupMap.constEnd(); ++i)
  {
    const QString mapText = removeSpaces(i.value());
    if (mapText == paramText)
      return i.key();
  }

  WARNING_LOG(m_logger) << "getAttributeType: attribute type not found by text '" << attributeText << "'";
  return QString(); 
}

DetailData::AttributeTypeLookup::AttributeTypeList DetailData::AttributeTypeLookup::getAttributeTypes() const
{
  return m_attributeTypeLookupMap.keys();
}

QString DetailData::AttributeTypeLookup::getAttributeText(const QString &attributeType, const QString &defaultReturnValue) const
{
  return m_attributeTypeLookupMap.value(attributeType, defaultReturnValue);
}

DetailData::AttributeTypeLookup::AttributeTextList DetailData::AttributeTypeLookup::getAttributeTexts() const
{
  return m_attributeTypeLookupMap.values();
}



DetailData::AttributeParameterLookup::AttributeParameterLookup()
  : LookupBase(QStringLiteral("AttributeParameterLookup"))
{
}

void DetailData::AttributeParameterLookup::addParameter(const QString &attributeType, const ParameterMap &parameterMap)
{
  if (!parameterMap.count())
  {
    WARNING_LOG(m_logger) << "addParameter: parameter map is empty!";
    return;
  }

  m_attributeParameterMap.insert(attributeType, parameterMap);
}

DetailData::AttributeParameterLookup::ParameterMap DetailData::AttributeParameterLookup::getParameterMap(const QString &attributeType) const
{
  return m_attributeParameterMap.value(attributeType);
}

QVariant DetailData::AttributeParameterLookup::getParameterValue(const QString &attributeType, const int parameterType) const
{
  const ParameterMap &pm = getParameterMap(attributeType);

  auto pmci = pm.constFind(parameterType);

  if (pmci == pm.constEnd()) 
    return QVariant();

  return *pmci;
}




DetailData::AttributeUITypeLookup::AttributeUITypeLookup()
  : LookupBase(QStringLiteral("AttributeUITypeLookup"))
{
}

void DetailData::AttributeUITypeLookup::addUITypeToAttribute(const QString &attributeType, const int uiType)
{
  m_attributeUITypeLookupMap.insert(attributeType, uiType);
}

int DetailData::AttributeUITypeLookup::getUIType(const QString &attributeType) const
{
  return m_attributeUITypeLookupMap.value(attributeType, -1); 
}



DetailData::AttributeInterpreterLookup::AttributeInterpreterLookup()
  : LookupBase(QStringLiteral("AttributeInterpreterLookup"))
{
}

void DetailData::AttributeInterpreterLookup::addInterpreterTypeToAttribute(const QString &attributeType, const int interpreterType)
{
  m_attributeInterpreterLookupMap.insert(attributeType, interpreterType);
}

int DetailData::AttributeInterpreterLookup::getInterpreterType(const QString &attributeType) const
{
  return m_attributeInterpreterLookupMap.value(attributeType);
}




DetailData::AttributeValueLookup::AttributeValueLookup()
  : LookupBase(QStringLiteral("AttributeValueLookup"))
{
}


void DetailData::AttributeValueLookup::removeValueFromAttributeValueMap(const QString &attributeType, const int valueKey)
{
  auto attributeTypeValueMapIt = m_attributeTypeValueMap.find(attributeType);

  if (attributeTypeValueMapIt == m_attributeTypeValueMap.end()) 
    return; 

  AttributeValueMap &currentAttributeValueMap = *attributeTypeValueMapIt;
  currentAttributeValueMap.remove(valueKey);
}


void DetailData::AttributeValueLookup::addValueToAttributeValueMap(const QString &attributeType, const int valueKey, const QString &valueValue)
{
  AttributeValueMap &avm = m_attributeTypeValueMap[attributeType];
  avm.insert(valueKey, valueValue);
}


void DetailData::AttributeValueLookup::addValuesToAttributeValueMap(const QString &attributeType, const AttributeValueMap &avm) 
{
  AttributeValueMap &thisAvm = m_attributeTypeValueMap[attributeType];
  for (auto i = avm.constBegin(); i != avm.constEnd(); ++i)
  {
    thisAvm.insert(i.key(), i.value());
  }
}

AttributeValueMap DetailData::AttributeValueLookup::getAttributeValueMap(const QString &attributeType) const
{
  return m_attributeTypeValueMap.value(attributeType);
}

QString DetailData::AttributeValueLookup::getValueStringFromValueId(const QString &attributeType, const int attributeValueId, const QString& defaultValue) const
{
  return getAttributeValueMap(attributeType).value(attributeValueId, defaultValue);
}

void DetailData::AttributeValueLookup::clear()
{
  m_attributeTypeValueMap.clear();
}



DetailData::AttributeRedirectionLookup::AttributeRedirectionLookup()
  : LookupBase(QStringLiteral("AttributeRedirectionLookup"))
{
}

void DetailData::AttributeRedirectionLookup::addRedirection(const QString &attributeType, const QString &redirectTo)
{
  m_attributeRedirectionMap.insert(attributeType, redirectTo);
}

QString DetailData::AttributeRedirectionLookup::getRedirection(const QString &attributeType) const
{
  auto it = m_attributeRedirectionMap.find(attributeType);
  if (it == m_attributeRedirectionMap.end())
    return attributeType;
  return it.value();
}


}