/**
  * @RDE_HEADER@
  * Helper classes to retrieve attribute values
  * $Id$
  * $HeadURL$
  * $Author$
  *
  * Created by Christian Ehrlicher, NLE, 2020-02-07
  */

#include "attribute_value_lookup.h"

#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/stream_name_mapping.h>
#include <InfrastructureManagement/ism_dtc.h>
#include <OperatorManagement/opm_dtc.h>
#include <ParticipantManagement/ppm_dtc.h>
#include <ProjectDataManagement/pdm_dtc.h>

#include <OperatorManagement/opm_translation.h>
#include <ParticipantManagement/ppm_translation.h>

#include <QVector>

namespace Timeline
{

//
// AvmChargeType
//
AttributeValueMap AvmChargeType::getAttributeValueMap(int eventType) const
{
  if (!m_dtc)
    return {};

  using namespace ProjectDataManagement;
  QVector<ChargeType> charges;
  switch (eventType)
  {
  case EventType::Hit:
  case EventType::WeaponAssignment:
  case EventType::FireEvent:
    charges = m_dtc->chargesForGearClass(GearClass::DuelSim);
    break;
  case EventType::HitBuilding:
    charges = m_dtc->chargesForGearClass(GearClass::DuelSim);
    Q_FALLTHROUGH();
  case EventType::HitEffectSimulation:
    charges += m_dtc->chargesForGearClass(GearClass::Artillery);
    charges += m_dtc->chargesForGearClass(GearClass::Mortar);
    charges += m_dtc->chargesForGearClass(GearClass::Geopairing);
    charges += m_dtc->chargesForGearClass(GearClass::AirSupport);
    charges += m_dtc->chargesForGearClass(GearClass::MineArea);
    charges += m_dtc->chargesForGearClass(GearClass::Biological);
    charges += m_dtc->chargesForGearClass(GearClass::Chemical);
    break;
  case EventType::HitB:
    charges = m_dtc->chargesForGearClass(GearClass::Biological);
    break;
  case EventType::HitC:
    charges = m_dtc->chargesForGearClass(GearClass::Chemical);
    break;
  case EventType::BCContamination:
    charges = m_dtc->chargesForGearClass(GearClass::Biological);
    charges += m_dtc->chargesForGearClass(GearClass::Chemical);
    break;
  case EventType::HitMine:
  case EventType::EnterMineArea:
  case EventType::LeaveMineArea:
  case EventType::MineArea:
    charges = m_dtc->chargesForGearClass(GearClass::MineArea);
    //charges =+ dtc->chargesForGearClass(GearClass::MineSingle); // same charges
    break;
  }
  Q_ASSERT(!charges.isEmpty());

  AttributeValueMap ret;
  for (const ChargeType &data : qAsConst(charges))
    ret.insert(data.id(), m_dtc->trChargeTypeShortName(data.id()));
  return ret;
}

QString AvmChargeType::getValueStringFromValueId(int attributeValueId) const
{
  if (!m_dtc)
    return {};
  return m_dtc->trChargeTypeShortName(attributeValueId);
}

//
// AvmGearType
//
AttributeValueMap AvmGearType::getAttributeValueMap(int eventType) const
{
  using namespace ProjectDataManagement;
  if (eventType != EventType_def::WeaponAssignment &&
      eventType != EventType_def::FireEvent)
  {
    Q_ASSERT(false);
    return {};
  }

  if (!m_dtc)
    return {};

  const auto gearTypes = m_dtc->gearTypes();
  AttributeValueMap ret;
  for (const auto &data : gearTypes)
  {
    if (data.gearClassId() == GearClass::DuelSim &&
        data.tasCode() != 0)
      ret.insert(data.id(), m_dtc->trGearTypeName(data.id()));
  }
  return ret;
}

QString AvmGearType::getValueStringFromValueId(int attributeValueId) const
{
  if (!m_dtc)
    return {};
  return m_dtc->trGearTypeName(attributeValueId);
}

//
// AvmParty
//
AttributeValueMap AvmParty::getAttributeValueMap(int eventType) const
{
  Q_UNUSED(eventType);

  using namespace ParticipantManagement;

  if (!m_dtc)
    return {};

  const auto parties = m_dtc->partys();
  AttributeValueMap ret;
  for (const auto &data : parties)
    ret.insert(data.id(), trPartyName(data.name()));
  return ret;
}

QString AvmParty::getValueStringFromValueId(int attributeValueId) const
{
  using namespace ParticipantManagement;
  if (!m_dtc)
    return {};
  return trPartyName(m_dtc->party(attributeValueId).name());
}

//
// AvmEquipmentNumber
//
AttributeValueMap AvmEquipmentNumber::getAttributeValueMap(int eventType) const
{
  Q_UNUSED(eventType);

  using namespace ParticipantManagement;

  if (!m_dtc)
    return {};

  AttributeValueMap ret;
  auto cb = [&ret](const ParticipantManagement::Participant & p) -> void
  {
    if (!p.equipmentNumber().is_set())
      return;
    const auto equipNo = p.equipmentNumber().get();
    ret.insert(equipNo, QString::number(equipNo));
  };
  m_dtc->participants(cb);
  return ret;
}

QString AvmEquipmentNumber::getValueStringFromValueId(int attributeValueId) const
{
  if (!m_dtc)
    return {};
  auto ret = m_dtc->participant(attributeValueId).equipmentNumber();
  return ret.is_set() ? QString::number(ret.get()) : QString();
}

//
// AvmOperator
//
AttributeValueMap AvmOperator::getAttributeValueMap(int eventType) const
{
  Q_UNUSED(eventType);

  using namespace OperatorManagement;

  if (!m_dtc)
    return {};

  const auto users = m_dtc->users();
  AttributeValueMap ret;
  for (const auto &data : users)
    ret.insert(data.id(), QString::fromStdString(data.name()));
  ret.insert(0, QObject::tr("EXCON"));
  return ret;
}

QString AvmOperator::getValueStringFromValueId(int attributeValueId) const
{
  if (attributeValueId == 0)
    return QObject::tr("EXCON");
  if (!m_dtc)
    return {};
  return QString::fromStdString(m_dtc->user(attributeValueId).name());
}

//
// AvmBuilding
//
AttributeValueMap AvmBuilding::getAttributeValueMap(int eventType) const
{
  Q_UNUSED(eventType);

  if (!m_dtc)
    return {};

  AttributeValueMap ret;
  auto cb = [this, &ret](const InfrastructureManagement::MainStructureElement &mse) -> void
  {
    if (mse.structureElementTypeId() != InfrastructureManagement::StructureElementType::Building)
      return;
    ret.insert(mse.id(), m_dtc->getBuildingDisplayName(mse));
  };
  m_dtc->mainStructureElements(cb);
  return ret;
}

QString AvmBuilding::getValueStringFromValueId(int attributeValueId) const
{
  if (!m_dtc)
    return {};
  return m_dtc->getBuildingDisplayName(attributeValueId);
}

//
// AvmStreamName
//
AvmStreamName::AvmStreamName(const std::shared_ptr<AudioVideoManagement::Interface::Dtc> &dtc)
  : m_dtc(dtc)
  , m_snm(AudioVideoManagement::StreamNameMapping::create(m_dtc.get()))
{}

AvmStreamName::~AvmStreamName() = default;

AttributeValueMap AvmStreamName::getAttributeValueMap(int eventType) const
{
  AttributeValueMap ret;

  if (!m_dtc)
    return ret;

  switch (eventType)
  {
  case ProjectDataManagement::EventType::RadioCnr:
  {
    auto cb = [&ret](const AudioVideoManagement::CnrConfig &cnrConfig) -> void
    {
      ret.insert(cnrConfig.id(), QString::fromStdString(cnrConfig.radioCircuit()));
    };
    m_dtc->cnrConfigs(cb);
    break;
  }
  case ProjectDataManagement::EventType::RadioTvc:
  {
    auto cb = [&ret](const AudioVideoManagement::TvcConfig &tvcConfig) -> void
    {
      ret.insert(tvcConfig.id(), QString::fromStdString(tvcConfig.radioCircuit()));
    };
    m_dtc->tvcConfigs(cb);
    break;
  }
  case ProjectDataManagement::EventType::CameraVideo:
  {
    auto cb = [this, &ret](const AudioVideoManagement::Stream &stream) -> void
    {
      if (stream.mountingPointId() == 0 ||
          stream.type() != AudioVideoManagement::StreamType::Video)
        return;
      ret.insert(stream.id(), m_snm->displayName(stream.mountingPointId()));
    };
    m_dtc->streams(cb);
    break;
  }
  default:
    break;
  }
  return ret;
}

QString AvmStreamName::getValueStringFromValueId(int attributeValueId) const
{
  if (!m_dtc)
    return {};
  return QString::fromStdString(m_dtc->stream(attributeValueId).name());
}


} // namespace Timeline