/**
  * Class for reading oc data
  * $Id: handler_oc_situation_data.h 57655 2022-07-20 11:38:28Z karwat $
  * $HeadURL: svn://192.168.133.21/TDS/branches/product/features/3dws_devel/Lts/Services/OcSituationClient/handler_oc_situation_data.h $
  * $Author: karwat $
  * Created by Hannes Fritsche, SLTE, 30-08-2023
  */

#include "central_aes_byte_reader.h"

#include <LtsUtilsCore/qbytearray_byteaccess.h>

#include "main_handler.h"
#include "settings.h"

namespace OcSituationClient
{

CentralAesByteReader::CentralAesByteReader(const QByteArray &data)
  : m_data(data)
  , m_logger(getLogger("CentralAesByteReader"))
{}

bool CentralAesByteReader::getRemoveMessage(size_t &pos, CentralAesByteReader::RemoveMessage &removeMessage) const
{
  bool result = getAesItemId(pos, removeMessage.aesItemId);
  result &= getAesType(pos, removeMessage.aesType);

  DEBUG_LOG(m_logger) << "Got remove message:"
                      << "\naesItemId = " << removeMessage.aesItemId
                      << "\naesType = " << removeMessage.aesType;

  return result;
}

bool CentralAesByteReader::getNContamination(size_t &pos, AreaEffectSimulation::NContaminationModifyRequest &nContamination) const
{
  bool result = getAesItemId(pos, nContamination.id());
  result &= getName(pos, nContamination.name());
  result &= getOptionalNumber(pos, nContamination.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getEffectDuration(pos, nContamination.effectDuration());
  result &= getChargeTypeId(pos, nContamination.chargeTypeId());
  result &= getImpactPosition(pos, nContamination.impactPosition());
  result &= getBorderLengthInner(pos, nContamination.borderLengthInner());
  result &= getBorderLengthOuter(pos, nContamination.borderLengthOuter());
  result &= getImpactRadius(pos, nContamination.impactRadius());
  result &= getSpanAngle(pos, nContamination.spanAngle());
  result &= getRotationAngle(pos, nContamination.rotationAngle());
  result &= getDetonationValue(pos, nContamination.detonationValue());
  result &= getOptionalNumber(pos, nContamination.partyId(), &CentralAesByteReader::getPartyId);

  nContamination.weatherSource(AreaEffectSimulation::AesWeatherSource::AwsNoUpdate);

  DEBUG_LOG(m_logger) << "Got NContamination:"
                      << "\nid = " << nContamination.id()
                      << "\nname = " << nContamination.name()
                      << "\neffectStart = " << nContamination.effectStart()
                      << "\neffectDuration = " << nContamination.effectDuration()
                      << "\nchargeTypeId = " << nContamination.chargeTypeId()
                      << "\nimpactPosition = " << nContamination.impactPosition()
                      << "\nborderLengthInner = " << nContamination.borderLengthInner()
                      << "\nborderLengthOuter = " << nContamination.borderLengthOuter()
                      << "\nimpactRadius = " << nContamination.impactRadius()
                      << "\nspanAngle = " << nContamination.spanAngle()
                      << "\nrotationAngle = " << nContamination.rotationAngle()
                      << "\ndetonationValue = " << nContamination.detonationValue()
                      << "\npartyId = " << nContamination.partyId();

  return result;
}

bool CentralAesByteReader::getBCContamination(size_t &pos, AreaEffectSimulation::BCContaminationModifyRequest &bCContamination) const
{
  bool result = getAesItemId(pos, bCContamination.id());
  result &= getName(pos, bCContamination.name());
  result &= getOptionalNumber(pos, bCContamination.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getEffectDuration(pos, bCContamination.effectDuration());
  result &= getChargeTypeId(pos, bCContamination.chargeTypeId());
  result &= getImpactPosition(pos, bCContamination.impactPosition());
  result &= getImpactRadius(pos, bCContamination.impactRadius());
  result &= getOptionalNumber(pos, bCContamination.partyId(), &CentralAesByteReader::getPartyId);
  result &= getOptionalNumber(pos, bCContamination.propagationDirection(), &CentralAesByteReader::getPropagationDirection);
  result &= getOptionalNumber(pos, bCContamination.windSpeed(), &CentralAesByteReader::getWindSpeed);

  bCContamination.weatherSource(AreaEffectSimulation::AesWeatherSource::AwsNoUpdate);

  DEBUG_LOG(m_logger) << "Got BCContamination:"
                      << "\nid = " << bCContamination.id()
                      << "\nname = " << bCContamination.name()
                      << "\neffectStart = " << bCContamination.effectStart()
                      << "\neffectDuration = " << bCContamination.effectDuration()
                      << "\nchargeTypeId = " << bCContamination.chargeTypeId()
                      << "\nimpactPosition = " << bCContamination.impactPosition()
                      << "\nimpactRadius = " << bCContamination.impactRadius()
                      << "\nweatherSource = " << bCContamination.weatherSource()
                      << "\npartyId = " << bCContamination.partyId()
                      << "\npropagationDirection = " << bCContamination.propagationDirection()
                      << "\nwindSpeed = " << bCContamination.windSpeed()
                      << "\nweatherPosition = " << bCContamination.weatherPosition()
                      << "\nweatherTimestamp = " << bCContamination.weatherTimestamp();

  return result;
}

bool CentralAesByteReader::getExplosionArea(size_t &pos, AreaEffectSimulation::ExplosionAreaModifyRequest &explosionArea) const
{
  bool result = getAesItemId(pos, explosionArea.id());
  result &= getName(pos, explosionArea.name());
  result &= getOptionalNumber(pos, explosionArea.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getEffectDuration(pos, explosionArea.effectDuration());
  result &= getChargeTypeId(pos, explosionArea.chargeTypeId());
  result &= getArea(pos, explosionArea.area());
  result &= getOptionalNumber(pos, explosionArea.partyId(), &CentralAesByteReader::getPartyId);
  result &= getCannonCount(pos, explosionArea.cannonCount());
  result &= getCannonRounds(pos, explosionArea.cannonRounds());
  result &= getFireRequestTime(pos, explosionArea.fireRequestTime());
  result &= getAltitude(pos, explosionArea.altitude());
  result &= getPurpose(pos, explosionArea.purpose());

  DEBUG_LOG(m_logger) << "Got ExplosionArea:"
                      << "\nid = " << explosionArea.id()
                      << "\nname = " << explosionArea.name()
                      << "\neffectStart = " << explosionArea.effectStart()
                      << "\neffectDuration = " << explosionArea.effectDuration()
                      << "\nchargeTypeId = " << explosionArea.chargeTypeId()
                      << "\narea = " << explosionArea.area()
                      << "\npartyId = " << explosionArea.partyId()
                      << "\ncannonCount = " << explosionArea.cannonCount()
                      << "\ncannonRounds = " << explosionArea.cannonRounds()
                      << "\nfireRequestTime = " << explosionArea.fireRequestTime()
                      << "\naltitude = " << explosionArea.altitude()
                      << "\npurpose = " << explosionArea.purpose();

  return result;
}

bool CentralAesByteReader::getExplosionSingle(size_t &pos, AreaEffectSimulation::ExplosionSingleModifyRequest &explosionSingle) const
{
  bool result = getAesItemId(pos, explosionSingle.id());
  result &= getName(pos, explosionSingle.name());
  result &= getOptionalNumber(pos, explosionSingle.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getChargeTypeId(pos, explosionSingle.chargeTypeId());
  result &= getImpactPosition(pos, explosionSingle.impactPosition());
  result &= getOptionalNumber(pos, explosionSingle.partyId(), &CentralAesByteReader::getPartyId);
  result &= getFireRequestTime(pos, explosionSingle.fireRequestTime());
  result &= getAltitude(pos, explosionSingle.altitude());
  result &= getPurpose(pos, explosionSingle.purpose());

  DEBUG_LOG(m_logger) << "Got ExplosionSingle:"
                      << "\nid = " << explosionSingle.id()
                      << "\nname = " << explosionSingle.name()
                      << "\neffectStart = " << explosionSingle.effectStart()
                      << "\nchargeTypeId = " << explosionSingle.chargeTypeId()
                      << "\nimpactPosition = " << explosionSingle.impactPosition()
                      << "\npartyId = " << explosionSingle.partyId()
                      << "\nfireRequestTime = " << explosionSingle.fireRequestTime()
                      << "\naltitude = " << explosionSingle.altitude()
                      << "\npurpose = " << explosionSingle.purpose();

  return result;
}

bool CentralAesByteReader::getMineArea(size_t &pos, AreaEffectSimulation::MineAreaModifyRequest &mineArea) const
{
  bool result = getAesItemId(pos, mineArea.id());
  result &= getName(pos, mineArea.name());
  result &= getOptionalNumber(pos, mineArea.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getEffectDuration(pos, mineArea.effectDuration());
  result &= getDensity(pos, mineArea.density());
  result &= getWidth(pos, mineArea.width());
  result &= getChargeTypeId(pos, mineArea.chargeStruct().chargeTypeId());
  result &= getOptionalNumber(pos, mineArea.partyId(), &CentralAesByteReader::getPartyId);
  result &= getAesMaLayingProcedureType(pos, mineArea.layingProcedureType());
  result &= getIsLayedHidden(pos, mineArea.isLaidHidden());
  result &= getIsCenterLine(pos, mineArea.isCenterLine());
  result &= getSegments(pos, mineArea.segments());

  DEBUG_LOG(m_logger) << "Got MineArea:"
                      << "\nid = " << mineArea.id()
                      << "\nname = " << mineArea.name()
                      << "\neffectStart = " << mineArea.effectStart()
                      << "\neffectDuration = " << mineArea.effectDuration()
                      << "\ndensity = " << mineArea.density()
                      << "\nwidth = " << mineArea.width()
                      << "\nchargeTypeId = " << mineArea.chargeStruct().chargeTypeId()
                      << "\npartyId = " << mineArea.partyId()
                      << "\nlayingProcedureType = " << mineArea.layingProcedureType()
                      << "\nisLaidHidden = " << mineArea.isLaidHidden()
                      << "\nisCenterLine = " << mineArea.isCenterLine()
                      << "\nsegments.size = " << mineArea.segments().size();

  return result;
}

bool CentralAesByteReader::getFunctionalArea(size_t &pos, AreaEffectSimulation::FunctionalAreaModifyRequest &functionalArea) const
{
  bool result = getAesItemId(pos, functionalArea.id());
  result &= getName(pos, functionalArea.name());
  result &= getOptionalNumber(pos, functionalArea.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getEffectDuration(pos, functionalArea.effectDuration());
  result &= getChargeTypeId(pos, functionalArea.chargeTypeId());
  result &= getArea(pos, functionalArea.area());
  result &= getOptionalNumber(pos, functionalArea.partyId(), &CentralAesByteReader::getPartyId);
  std::string pointSymbol;
  result &= getPointSymbol(pos, pointSymbol);
  if (pointSymbol != std::string())
    functionalArea.pointSymbol().set(pointSymbol);
  result &= getFunctionalAreaTypeId(pos, functionalArea.functionalAreaTypeId());
  result &= getDeconMode(pos, functionalArea.deconMode());
  result &= getDeconTime(pos, functionalArea.deconTime());
  result &= getMaintMode(pos, functionalArea.maintMode());
  result &= getMaintTime(pos, functionalArea.maintTime());
  result &= getMedicMode(pos, functionalArea.medicMode());
  result &= getMedicTime(pos, functionalArea.medicTime());

  DEBUG_LOG(m_logger) << "Got MineArea:"
                      << "\nid = " << functionalArea.id()
                      << "\nname = " << functionalArea.name()
                      << "\neffectStart = " << functionalArea.effectStart()
                      << "\neffectDuration = " << functionalArea.effectDuration()
                      << "\nchargeTypeId = " << functionalArea.chargeTypeId()
                      << "\narea = " << functionalArea.area()
                      << "\npartyId = " << functionalArea.partyId()
                      << "\npointSymbol = " << functionalArea.pointSymbol()
                      << "\nfunctionalAreaTypeId = " << functionalArea.functionalAreaTypeId()
                      << "\ndeconMode = " << functionalArea.deconMode()
                      << "\ndeconTime = " << functionalArea.deconTime()
                      << "\nmaintMode = " << functionalArea.maintMode()
                      << "\nmaintTime = " << functionalArea.maintTime()
                      << "\nmedicMode = " << functionalArea.medicMode()
                      << "\n medicTime= " << functionalArea.medicTime();

  return result;
}

bool CentralAesByteReader::getBoobyTrap(size_t &pos, AreaEffectSimulation::BoobyTrapModifyRequest &boobyTrap) const
{
  bool result = getAesItemId(pos, boobyTrap.id());
  result &= getName(pos, boobyTrap.name());
  result &= getEffectDuration(pos, boobyTrap.effectDuration());
  result &= getChargeTypeId(pos, boobyTrap.chargeTypeId());
  result &= getImpactPosition(pos, boobyTrap.impactPosition());
  result &= getImpactRadius(pos, boobyTrap.impactRadius());
  result &= getTriggerRadius(pos, boobyTrap.triggerRadius());
  result &= getOptionalNumber(pos, boobyTrap.rotationAngle(), &CentralAesByteReader::getRotationAngle);
  result &= getOptionalNumber(pos, boobyTrap.centralAngle(), &CentralAesByteReader::getCentralAngle);
  result &= getOptionalNumber(pos, boobyTrap.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getOptionalNumber(pos, boobyTrap.partyId(), &CentralAesByteReader::getPartyId);

  DEBUG_LOG(m_logger) << "Got BoobyTrap:"
                      << "\nid = " << boobyTrap.id()
                      << "\nname = " << boobyTrap.name()
                      << "\neffectDuration = " << boobyTrap.effectDuration()
                      << "\nchargeTypeId = " << boobyTrap.chargeTypeId()
                      << "\nimpactPosition = " << boobyTrap.impactPosition()
                      << "\nimpactRadius = " << boobyTrap.impactRadius()
                      << "\ntriggerRadius = " << boobyTrap.triggerRadius()
                      << "\nrotationAngle = " << boobyTrap.rotationAngle()
                      << "\ncentralAngle = " << boobyTrap.centralAngle()
                      << "\neffectStart = " << boobyTrap.effectStart()
                      << "\npartyId = " << boobyTrap.partyId();

  return result;
}

bool CentralAesByteReader::getOffRouteMine(size_t &pos, AreaEffectSimulation::OffRouteMineModifyRequest &offRouteMine) const
{
  bool result = getAesItemId(pos, offRouteMine.id());
  result &= getName(pos, offRouteMine.name());
  result &= getEffectDuration(pos, offRouteMine.effectDuration());
  result &= getChargeTypeId(pos, offRouteMine.chargeTypeId());
  result &= getArea(pos, offRouteMine.area());
  result &= getOptionalNumber(pos, offRouteMine.impactRadius(), &CentralAesByteReader::getImpactRadius);
  result &= getOptionalNumber(pos, offRouteMine.effectStart(), &CentralAesByteReader::getEffectStart);
  result &= getOptionalNumber(pos, offRouteMine.partyId(), &CentralAesByteReader::getPartyId);

  DEBUG_LOG(m_logger) << "Got OffRouteMine: "
                      << "\nid: " << offRouteMine.id()
                      << "\nname = " << offRouteMine.name()
                      << "\neffectDuration = " << offRouteMine.effectDuration()
                      << "\nchargeTypeId = " << offRouteMine.chargeTypeId()
                      << "\narea = " << offRouteMine.area()
                      << "\nimpactRadius = " << offRouteMine.impactRadius()
                      << "\neffectStart = " << offRouteMine.effectStart()
                      << "\npartyId = " << offRouteMine.partyId();

  return result;
}

bool CentralAesByteReader::getExplosionCluster(size_t &pos, AreaEffectSimulation::ExplosionClusterOcModifyRequest &explosionCluster) const
{
  bool result = getAesItemId(pos, explosionCluster.id());
  result &= getName(pos, explosionCluster.name());
  result &= getEffectStart(pos, explosionCluster.effectStart());
  result &= getEffectDuration(pos, explosionCluster.effectDuration());
  result &= getArea(pos, explosionCluster.area());
  result &= getMhpCount(pos, explosionCluster.mhpCount());
  result &= getMhpRotation(pos, explosionCluster.mhpRotation());
  result &= getImpactCount(pos, explosionCluster.impactCount());
  result &= getChargeTypeId(pos, explosionCluster.chargeStruct().chargeTypeId());
  result &= getPartyId(pos, explosionCluster.partyId());

  DEBUG_LOG(m_logger) << "Got ExplosionCluster:"
                      << "\nid: " << explosionCluster.id()
                      << "\nname: " << explosionCluster.name()
                      << "\neffectStart: " << explosionCluster.effectStart()
                      << "\neffectDuration: " << explosionCluster.effectDuration()
                      << "\narea: " << explosionCluster.area()
                      << "\nmhpCount: " << explosionCluster.mhpCount()
                      << "\nmhpRotation: " << explosionCluster.mhpRotation()
                      << "\nimpactCount: " << explosionCluster.impactCount()
                      << "\nchargeTypeId: " << explosionCluster.chargeStruct().chargeTypeId()
                      << "\npartyId: " << explosionCluster.partyId();

  return result;
}

bool CentralAesByteReader::getAesItemId(size_t &pos, int32_t &aesItemId) const
{
  return LtsUtils::get4Byte(m_data, pos, aesItemId);
}

bool CentralAesByteReader::getAesMaLayingProcedureType(size_t &pos, AreaEffectSimulation::AesMaLayingProcedureType &aesMaLayingProcedureType) const
{
  return getDdsEnumVal(pos, aesMaLayingProcedureType);
}

bool CentralAesByteReader::getAesType(size_t &pos, AreaEffectSimulation::AesType &aesType) const
{
  return getDdsEnumVal(pos, aesType);
}

bool CentralAesByteReader::getAltitude(size_t &pos, int32_t &altitude) const
{
  return LtsUtils::get4Byte(m_data, pos, altitude);
}

bool CentralAesByteReader::getArea(size_t &pos, AreaEffectSimulation::Area &area) const
{
  bool result = getPosition2D(pos, area.cornerBottomLeft());
  result &= LtsUtils::get8Byte(m_data, pos, area.width());
  result &= LtsUtils::get8Byte(m_data, pos, area.height());
  result &= LtsUtils::get8Byte(m_data, pos, area.rotation());

  return result;
}

bool CentralAesByteReader::getBorderLengthInner(size_t &pos, double &borderLengthInner) const
{
  return LtsUtils::get8Byte(m_data, pos, borderLengthInner);
}

bool CentralAesByteReader::getBorderLengthOuter(size_t &pos, double &borderLengthOuter) const
{
  return LtsUtils::get8Byte(m_data, pos, borderLengthOuter);
}

bool CentralAesByteReader::getCannonCount(size_t &pos, int32_t &cannonCount) const
{
  return LtsUtils::get4Byte(m_data, pos, cannonCount);
}

bool CentralAesByteReader::getCannonRounds(size_t &pos, int32_t &cannonRounds) const
{
  return LtsUtils::get4Byte(m_data, pos, cannonRounds);
}

bool CentralAesByteReader::getChargeTypeId(size_t &pos, int32_t &chargeType) const
{
  return LtsUtils::get4Byte(m_data, pos, chargeType);
}

bool CentralAesByteReader::getCentralAesChangeType(size_t &pos, OcSituation::CentralAesChangeType &changeType) const
{
  return LtsUtils::get1Byte(m_data, pos, changeType);
}

bool CentralAesByteReader::getCentralAngle(size_t &pos, double &centralAngle) const
{
  return LtsUtils::get8Byte(m_data, pos, centralAngle);
}

template<typename T>
bool CentralAesByteReader::getDdsEnumVal(size_t &pos, T &ddsEnumVal) const
{
  int32_t tempVal;

  bool result = LtsUtils::get4Byte(m_data, pos, tempVal);

  ddsEnumVal = static_cast<typename T::inner_enum>(tempVal);

  return result;
}

bool CentralAesByteReader::getDeconMode(size_t &pos, AreaEffectSimulation::AesOperatingMode &deconMode) const
{
  return getDdsEnumVal(pos, deconMode);
}

bool CentralAesByteReader::getDeconTime(size_t &pos, int32_t &deconTime) const
{
  return LtsUtils::get4Byte(m_data, pos, deconTime);
}

bool CentralAesByteReader::getDensity(size_t &pos, double &density) const
{
  return LtsUtils::get8Byte(m_data, pos, density);
}

bool CentralAesByteReader::getDetonationValue(size_t &pos, double &detonationValue) const
{
  return LtsUtils::get8Byte(m_data, pos, detonationValue);
}

bool CentralAesByteReader::getEffectDuration(size_t &pos, int32_t &effectDuration) const
{
  return LtsUtils::get4Byte(m_data, pos, effectDuration);
}

bool CentralAesByteReader::getEffectStart(size_t &pos, rti::core::int64 &effectStart) const
{
  return LtsUtils::get8Byte(m_data, pos, effectStart);
}

bool CentralAesByteReader::getExplosionGeometry(size_t &pos, AreaEffectSimulation::AesExplosionGeometry &explosionGeometry) const
{
  return getDdsEnumVal(pos, explosionGeometry);
}

bool CentralAesByteReader::getFireRequestTime(size_t &pos, rti::core::int64 &fireRequestTime) const
{
  return LtsUtils::get8Byte(m_data, pos, fireRequestTime);
}

bool CentralAesByteReader::getFunctionalAreaTypeId(size_t &pos, int32_t &functionalAreaTypeId) const
{
  return LtsUtils::get4Byte(m_data, pos, functionalAreaTypeId);
}

bool CentralAesByteReader::getIgniterType(size_t &pos, int32_t igniterTypeId) const
{
  return LtsUtils::get4Byte(m_data, pos, igniterTypeId);
}

bool CentralAesByteReader::getImpactCount(size_t &pos, int32_t &impactCount) const
{
  return LtsUtils::get4Byte(m_data, pos, impactCount);
}

bool CentralAesByteReader::getImpactPosition(size_t &pos, Core::GeoPosition2D &position) const
{
  return getPosition2D(pos, position);
}

bool CentralAesByteReader::getImpactRadius(size_t &pos, double &impactRadius) const
{
  return LtsUtils::get8Byte(m_data, pos, impactRadius);
}

bool CentralAesByteReader::getIsCenterLine(size_t &pos, bool &isCenterLine) const
{
  return LtsUtils::get1Byte(m_data, pos, isCenterLine);
}

bool CentralAesByteReader::getIsLayedHidden(size_t &pos, bool &isLayedHidden) const
{
  return LtsUtils::get1Byte(m_data, pos, isLayedHidden);
}

bool CentralAesByteReader::getMaintMode(size_t &pos, AreaEffectSimulation::AesOperatingMode &maintMode) const
{
  return getDdsEnumVal(pos, maintMode);
}

bool CentralAesByteReader::getMaintTime(size_t &pos, int32_t &maintTime) const
{
  return LtsUtils::get4Byte(m_data, pos, maintTime);
}

bool CentralAesByteReader::getMedicMode(size_t &pos, AreaEffectSimulation::AesOperatingMode &medicMode) const
{
  return getDdsEnumVal(pos, medicMode);
}

bool CentralAesByteReader::getMedicTime(size_t &pos, int32_t &medicTime) const
{
  return LtsUtils::get4Byte(m_data, pos, medicTime);
}

bool CentralAesByteReader::getMhpCount(size_t &pos, int32_t &mhpCount) const
{
  return LtsUtils::get4Byte(m_data, pos, mhpCount);
}

bool CentralAesByteReader::getMhpRotation(size_t &pos, double &mhpRotation) const
{
  return LtsUtils::get8Byte(m_data, pos, mhpRotation);
}

bool CentralAesByteReader::getName(size_t &pos, std::string &name) const
{
  return getString(pos, name);
}

template<typename T>
bool CentralAesByteReader::getOptionalNumber(size_t &pos, rti::core::optional<T> &optionalNumber, bool(CentralAesByteReader::*method)(size_t &pos, T &number) const) const
{
  T value;
  bool result = (*this.*method)(pos, value);

  if (value != -1)
    optionalNumber.set(value);

  return result;
}

bool CentralAesByteReader::getPartyId(size_t &pos, int32_t &partyId) const
{
  return LtsUtils::get4Byte(m_data, pos, partyId);
}

bool CentralAesByteReader::getPointSymbol(size_t &pos, std::string &pointSymbol) const
{
  return getString(pos, pointSymbol);
}

bool CentralAesByteReader::getPosition2D(size_t &pos, Core::GeoPosition2D &position) const
{
  bool result = LtsUtils::get8Byte(m_data, pos, position.lon());
  result &= LtsUtils::get8Byte(m_data, pos, position.lat());

  return result;
}

bool CentralAesByteReader::getPropagationDirection(size_t &pos, double &propagationDirection) const
{
  return LtsUtils::get8Byte(m_data, pos, propagationDirection);
}

bool CentralAesByteReader::getPurpose(size_t &pos, std::string &purpose) const
{
  return getString(pos, purpose);
}

bool CentralAesByteReader::getRotationAngle(size_t &pos, double &rotationAngle) const
{
  return LtsUtils::get8Byte(m_data, pos, rotationAngle);
}

bool CentralAesByteReader::getSegments(size_t &pos, std::vector<Core::GeoPosition2D> &segments) const
{
  int tmp;

  bool result = LtsUtils::get1Byte(m_data, pos, tmp);

  size_t len = tmp;

  if (len < 1)
    return result;

  Core::GeoPosition2D geoPos;

  for (size_t counter = 0; counter < len; ++counter)
  {
    result &= getPosition2D(pos, geoPos);

    segments.push_back(geoPos);
  }

  return result;
}

bool CentralAesByteReader::getSpanAngle(size_t &pos, double &spanAngle) const
{
  return LtsUtils::get8Byte(m_data, pos, spanAngle);
}

bool CentralAesByteReader::getString(size_t &pos, std::string &str) const
{
  int tmp;
  bool result = LtsUtils::get1Byte(m_data, pos, tmp);
  size_t len = tmp;

  if (static_cast<size_t>(m_data.size()) < (pos + len))
    result = false;

  if (result)
    str = m_data.mid(pos, len).toStdString();

  pos += len;

  return result;
}

bool CentralAesByteReader::getTriggerRadius(size_t &pos, double &triggerRadius) const
{
  return LtsUtils::get8Byte(m_data, pos, triggerRadius);
}

bool CentralAesByteReader::getWidth(size_t &pos, double &width) const
{
  return LtsUtils::get8Byte(m_data, pos, width);
}

bool CentralAesByteReader::getWindSpeed(size_t &pos, double &windSpeed) const
{
  return LtsUtils::get8Byte(m_data, pos, windSpeed);
}

} // namespace OcSituationClient