/**
  * @RDE_HEADER@
  * Data Plugin for AdvancedSymbology
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2016-02-29
  */

#include "asb_foreign_interface_impl.h"
#include "logger.h"
#include <AreaEffectSimulation/aes_dtc.h>
#include <ParticipantManagement/ppm_dtc.h>
#include <SymbologyImpl/advanced_symbology_logging.h>
#include <Symbology/symbol_data_to_render_role.h>

namespace AdvancedSymbology
{
ForeignInterfaceImpl::ForeignInterfaceImpl(const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
                                           const std::shared_ptr<AreaEffectSimulation::Interface::Dtc> &aesDtc,
                                           const std::shared_ptr<GuezIedManagement::Interface::Dtc>    &guezIedDtc)
  : m_ppmDtc(ppmDtc)
  , m_aesDtc(aesDtc)
  , m_guezIedDtc(guezIedDtc)
  , m_logger(getLogger("AdvancedSymbologyPlugin"))
{
  if (!m_ppmDtc)
  {
    WARNING_LOG(m_logger) << "m_ppmDtc not available, No color and injury information will be included in created symbols";
    Q_ASSERT(false);
  }
}


AdvancedSymbology::SymbolDictionary &ForeignInterfaceImpl::getSymbolDictionary(AdvancedSymbology::SymbologyType type) const
{
  // The underlying dictionary should be created and initialized during login.
  return AdvancedSymbology::SymbolDictionary::dictionary(type);
}


AdvancedSymbology::SymbologyType ForeignInterfaceImpl::defaultSymbologyType() const
{
  return AdvancedSymbology::SymbolDictionary::defaultSymbologyType();
} // AdvancedSymbology::SymbologyType ForeignInterfaceImpl::defaultSymbologyType() const


QSharedPointer<SymbolResult> ForeignInterfaceImpl::findImage(const SymbolDictionary &dict,
                                                             const SymbolDataToRender &symDataToRender) const
{
  return dict.findImage(symDataToRender);
}


QSharedPointer<SymbolResult> ForeignInterfaceImpl::findImage(const SymbolDataToRender &symDataToRender) const
{
  return AdvancedSymbology::SymbolDictionary::dictionary(defaultSymbologyType()).findImage(symDataToRender);
}


QSharedPointer<SymbolResult> ForeignInterfaceImpl::findImage(const ParticipantManagement::Participant &participant, int sizeL, const QColor &desiredColor) const
{
  AdvancedSymbology::SymbolDataToRender symDataToRender(QString::fromStdString(participant.symbol()), sizeL);

  if (!m_ppmDtc)
    return findImage(symDataToRender);

  // Party Role (aka Identity / Affiliation)
  const ParticipantManagement::Party &party = m_ppmDtc->party(participant.partyId());
  symDataToRender.role = AdvancedSymbology::roleToRole<>(party.role());

  // Party color
  symDataToRender.fillColor = desiredColor.isValid() ? desiredColor : QColor::fromRgb(QRgb(party.color()));
  symDataToRender.fillColorReplace = true;

  // Injury color (which party caused the damage)
  QColor injuryColor = QColor(100, 100, 0); // 100, 100, 0 -> ocker;;
  ProjectDataManagement::VulnerabilityState currentState = ProjectDataManagement::VulnerabilityState::CombatReady;

  const ParticipantManagement::DynamicParticipantData dData = m_ppmDtc->dynamicParticipantData(participant.id());

  if (dData.stateHistory().size())
  {
    const ParticipantManagement::StateInformation &lastState = m_ppmDtc->youngestStateInformation(dData.stateHistory());
    currentState = lastState.vulnerabilityState();

    switch (lastState.originatorType().underlying())
    {
    case ProjectDataManagement::StateChangeOriginator::ImprovisedExplosiveDevice:
    {
      if (m_guezIedDtc)
      {
        const GuezIedManagement::Ied &gIed = m_guezIedDtc->iedForEquipmentNumber(lastState.originatorId());
        if (gIed.id() > 0)
        {
          int injuryPartyId = gIed.partyId();
          if (injuryPartyId >= 0)
            injuryColor = m_ppmDtc->party(injuryPartyId).color();
        }
      }
      break;
    }
    case ProjectDataManagement::StateChangeOriginator::DusMine:
    {
      if (!m_aesDtc)
      {
        WARNING_LOG(m_logger) << "Fetching 'm_aesDtc' failed,  No color and injury information will be included in symbol created for participant.id() " << participant.id();
        return findImage(symDataToRender);
      }
      const int partyId = m_aesDtc->partyForDusMine(lastState.originatorId());
      if (partyId >= 0)
        injuryColor = m_ppmDtc->party(partyId).color();
      break;
    }
    case ProjectDataManagement::StateChangeOriginator::AreaEffectSimulation:
    case ProjectDataManagement::StateChangeOriginator::FunctionalArea:
    {
      if (!m_aesDtc)
      {
        WARNING_LOG(m_logger) << "Fetching 'm_aesDtc' failed,  No color and injury information will be included in symbol created for participant.id() " << participant.id();
        return findImage(symDataToRender);
      }

      AreaEffectSimulation::AesItem aesItem;
      m_aesDtc->aesItemFromId(lastState.originatorId(), aesItem);

      if (aesItem.partyId().is_set())
        injuryColor = m_ppmDtc->party(aesItem.partyId().get()).color();

      break;
    }

    case ProjectDataManagement::StateChangeOriginator::Participant: // it's a participant not a party
    {
      const ParticipantManagement::Participant &participantOrigin = m_ppmDtc->participant(lastState.originatorId());

      // Is the participant which caused the damaged known?
      if (participantOrigin.id())
        injuryColor = m_ppmDtc->party(participantOrigin.partyId()).color();
      break;
    }
    case ProjectDataManagement::StateChangeOriginator::Party:
    {
      const ParticipantManagement::Party &partyOrigin = m_ppmDtc->party(lastState.originatorId());

      if (partyOrigin.id())
        injuryColor = partyOrigin.color();
      break;
    }
    case ProjectDataManagement::StateChangeOriginator::ObserverController:
    case ProjectDataManagement::StateChangeOriginator::ExerciseControl:
    case ProjectDataManagement::StateChangeOriginator::Initialization:
      injuryColor = m_ppmDtc->party(1).color(); //OC
      break;
    case ProjectDataManagement::StateChangeOriginator::WoundTreatmentDevice:
    case ProjectDataManagement::StateChangeOriginator::MedicalTimeout:
    case ProjectDataManagement::StateChangeOriginator::Sanitation:
    case ProjectDataManagement::StateChangeOriginator::MaintainanceDevice:
    case ProjectDataManagement::StateChangeOriginator::Unknown:
      break;
    }
  }

  symDataToRender.injury = stateToInjury(currentState);
  symDataToRender.injuryColor = injuryColor;

  return findImage(symDataToRender);
}


AdvancedSymbology::Injury ForeignInterfaceImpl::stateToInjury(const ProjectDataManagement::VulnerabilityState &state)
{
  switch (state.underlying())
  {
  case ProjectDataManagement::VulnerabilityState::CombatReady:
  case ProjectDataManagement::VulnerabilityState::TemporarySeverance:
  case ProjectDataManagement::VulnerabilityState::NearMiss:
  case ProjectDataManagement::VulnerabilityState::HitWithNoEffect:
    return AdvancedSymbology::Injury::NoInjury;
  case ProjectDataManagement::VulnerabilityState::LightDamage:
  case ProjectDataManagement::VulnerabilityState::MediumDamage:
  case ProjectDataManagement::VulnerabilityState::HeavyDamage:
  case ProjectDataManagement::VulnerabilityState::NotReady:
    return AdvancedSymbology::Injury::Hit;
  case ProjectDataManagement::VulnerabilityState::MobilityKill:
  case ProjectDataManagement::VulnerabilityState::VisibleMobilityKill:
    return AdvancedSymbology::Injury::MobilityKill;
  case ProjectDataManagement::VulnerabilityState::WeaponSystemDamage:
  case ProjectDataManagement::VulnerabilityState::VisibleWeaponSystemDamage:
    return AdvancedSymbology::Injury::WeaponKill;
  case ProjectDataManagement::VulnerabilityState::CatastrophicKill:
    return AdvancedSymbology::Injury::TotalKill;
  case ProjectDataManagement::VulnerabilityState::NContamination:
  case ProjectDataManagement::VulnerabilityState::BContamination:
  case ProjectDataManagement::VulnerabilityState::CContamination:
  case ProjectDataManagement::VulnerabilityState::VulnerabilityBitsChanged:
  case ProjectDataManagement::VulnerabilityState::Reserved:
  case ProjectDataManagement::VulnerabilityState::NoChange:
    break;
  } // switch
  return AdvancedSymbology::Injury::NoInjury;
}


QSharedPointer<SymbolResult> ForeignInterfaceImpl::findPreview(const SymbolDictionary &dict, const QString &sidc) const
{
  return dict.findPreview(sidc);
}

QSharedPointer<SymbolResult> ForeignInterfaceImpl::findPreview(const QString &sidc) const
{
  return AdvancedSymbology::SymbolDictionary::dictionary(defaultSymbologyType()).findPreview(sidc);
}

QSharedPointer<SymbolResult> ForeignInterfaceImpl::findBaseSymbol(const SymbolDictionary &dict, const QString &sidc) const
{
  return dict.findBaseSymbol(sidc);
}

QSharedPointer<SymbolResult> ForeignInterfaceImpl::findBaseSymbol(const QString &sidc) const
{
  return AdvancedSymbology::SymbolDictionary::dictionary(defaultSymbologyType()).findBaseSymbol(sidc);
}

} // namespace AdvancedSymbology