/**
  * Manages central aes data to be sent
  * $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/OcSituationServer/handler_oc_situation_data.h $
  * $Author: karwat $
  * Created by Hannes Fritsche, SLTE, 16-08-2022
  */

#include "central_aes_data_builder.h"
#include "LtsUtils/LtsUtilsCore/qbytearray_byteaccess.h"
#include "QLineF"

namespace OcSituationServer
{

namespace DataBuilder
{

QByteArray getByteStreamAesItem(const AreaEffectSimulation::EffectCluster &effectCluster, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionCluster); // we send EffectCluster as ExplosionCluster
  addAesItemId(byteStream, effectCluster.id);
  addName(byteStream, effectCluster.name);
  addEffectStart(byteStream, effectCluster.effectStart.is_set() ? effectCluster.effectStart.get() : -1);
  addEffectDuration(byteStream, effectCluster.effectDuration);
  addArea(byteStream, effectCluster.area);
  addMhpCount(byteStream, static_cast<int32_t>(effectCluster.effectors.size()));
  addMhpRotation(byteStream, effectCluster.effectors.size() ? effectCluster.effectors[0].mhpRotation : 1);
  addImpactCount(byteStream, static_cast<int32_t>(effectCluster.effectors.size()));
  addChargeTypeId(byteStream, effectCluster.chargeStruct.chargeTypeId);
  addPartyId(byteStream, effectCluster.partyId.is_set() ? effectCluster.partyId.get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::NContamination &nContamination, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtNContamination);
  addAesItemId(byteStream, nContamination.id);
  addName(byteStream, nContamination.name);
  addEffectStart(byteStream, nContamination.effectStart.is_set() ? nContamination.effectStart.get() : -1);
  addEffectDuration(byteStream, nContamination.effectDuration);
  addChargeTypeId(byteStream, nContamination.chargeStruct.chargeTypeId);
  addImpactPosition(byteStream, nContamination.impactPosition);
  addBorderLengthInner(byteStream, nContamination.borderLengthInner);
  addBorderLengthOuter(byteStream, nContamination.borderLengthOuter);
  addImpactRadius(byteStream, nContamination.impactRadius);
  addSpanAngle(byteStream, nContamination.spanAngle);
  addRotationAngle(byteStream, nContamination.rotationAngle);
  addDetonationValue(byteStream, nContamination.detonationValue);
  addPartyId(byteStream, nContamination.partyId.is_set() ? nContamination.partyId.get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::BCContamination &bCContamination, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtBCContamination);
  addAesItemId(byteStream, bCContamination.id);
  addName(byteStream, bCContamination.name);
  addEffectStart(byteStream, bCContamination.effectStart.is_set() ? bCContamination.effectStart.get() : -1);
  addEffectDuration(byteStream, bCContamination.effectDuration);
  addChargeTypeId(byteStream, bCContamination.chargeStruct.chargeTypeId);
  addImpactPosition(byteStream, bCContamination.impactPosition);
  addImpactRadius(byteStream, bCContamination.impactRadius);
  addPartyId(byteStream, bCContamination.partyId.is_set() ? bCContamination.partyId.get() : -1);
  addPropagationDirection(byteStream, bCContamination.propagationDirection);
  addWindSpeed(byteStream, bCContamination.windSpeed);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::ExplosionArea &explosionArea, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionArea);
  addAesItemId(byteStream, explosionArea.id);
  addName(byteStream, explosionArea.name);
  addEffectStart(byteStream, explosionArea.effectStart.is_set() ? explosionArea.effectStart.get() : -1);
  addEffectDuration(byteStream, explosionArea.effectDuration);
  addChargeTypeId(byteStream, explosionArea.chargeStruct.chargeTypeId);
  addArea(byteStream, explosionArea.area);
  addPartyId(byteStream, explosionArea.partyId.is_set() ? explosionArea.partyId.get() : -1);
  addCannonCount(byteStream, explosionArea.cannonCount);
  addCannonRounds(byteStream, explosionArea.cannonRounds);
  addFireRequestTime(byteStream, explosionArea.fireRequestTime);
  addAltitude(byteStream, explosionArea.altitude);
  addPurpose(byteStream, explosionArea.purpose);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::ExplosionSingle &explosionSingle, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionSingle);
  addAesItemId(byteStream, explosionSingle.id);
  addName(byteStream, explosionSingle.name);
  addEffectStart(byteStream, explosionSingle.effectStart.is_set() ? explosionSingle.effectStart.get() : -1);
  addChargeTypeId(byteStream, explosionSingle.chargeStruct.chargeTypeId);
  addImpactPosition(byteStream, explosionSingle.impactPosition);
  addPartyId(byteStream, explosionSingle.partyId.is_set() ? explosionSingle.partyId.get() : -1);
  addFireRequestTime(byteStream, explosionSingle.fireRequestTime);
  addAltitude(byteStream, explosionSingle.altitude);
  addPurpose(byteStream, explosionSingle.purpose);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::MineArea &mineArea, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtMineArea);
  addAesItemId(byteStream, mineArea.id);
  addName(byteStream, mineArea.name);
  addEffectStart(byteStream, mineArea.effectStart.is_set() ? mineArea.effectStart.get() : -1);
  addEffectDuration(byteStream, mineArea.effectDuration);
  addDensity(byteStream, mineArea.density);
  addWidth(byteStream, mineArea.width);
  addChargeTypeId(byteStream, mineArea.chargeStruct.chargeTypeId);
  addPartyId(byteStream, mineArea.partyId.is_set() ? mineArea.partyId.get() : -1);
  addAesMaLayingProcedureType(byteStream, mineArea.layingProcedureType);
  addIsLayedHidden(byteStream, mineArea.isLaidHidden);
  addIsCenterLine(byteStream, mineArea.isCenterLine);
  addSegments(byteStream, mineArea.segments);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::FunctionalArea &functionalArea, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtFunctionalArea);
  addAesItemId(byteStream, functionalArea.id);
  addName(byteStream, functionalArea.name);
  addEffectStart(byteStream, functionalArea.effectStart.is_set() ? functionalArea.effectStart.get() : -1);
  addEffectDuration(byteStream, functionalArea.effectDuration);
  addChargeTypeId(byteStream, functionalArea.chargeStruct.chargeTypeId);
  addArea(byteStream, functionalArea.area);
  addPartyId(byteStream, functionalArea.partyId.is_set() ? functionalArea.partyId.get() : -1);
  addPointSymbol(byteStream, functionalArea.pointSymbol.is_set() ? functionalArea.pointSymbol.get() : std::string());
  addFunctionalAreaTypeId(byteStream, functionalArea.functionalAreaTypeId);
  addDeconMode(byteStream, functionalArea.deconMode);
  addDeconTime(byteStream, functionalArea.deconTime);
  addMaintMode(byteStream, functionalArea.maintMode);
  addMaintTime(byteStream, functionalArea.maintTime);
  addMedicMode(byteStream, functionalArea.medicMode);
  addMedicTime(byteStream, functionalArea.medicTime);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::BoobyTrap &boobyTrap, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtBoobyTrap);
  addAesItemId(byteStream, boobyTrap.id);
  addName(byteStream, boobyTrap.name);
  addEffectDuration(byteStream, boobyTrap.effectDuration);
  addChargeTypeId(byteStream, boobyTrap.chargeStruct.chargeTypeId);
  addImpactPosition(byteStream, boobyTrap.impactPosition);
  addImpactRadius(byteStream, boobyTrap.impactRadius);
  addTriggerRadius(byteStream, boobyTrap.triggerRadius);
  addRotationAngle(byteStream, boobyTrap.rotationAngle.is_set() ? boobyTrap.rotationAngle.get() : -1);
  addCentralAngle(byteStream, boobyTrap.centralAngle.is_set() ? boobyTrap.centralAngle.get() : -1);
  addEffectStart(byteStream, boobyTrap.effectStart.is_set() ? boobyTrap.effectStart.get() : -1);
  addPartyId(byteStream, boobyTrap.partyId.is_set() ? boobyTrap.partyId.get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::OffRouteMine &offRouteMine, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtOffRouteMine);
  addAesItemId(byteStream, offRouteMine.id);
  addName(byteStream, offRouteMine.name);
  addEffectDuration(byteStream, offRouteMine.effectDuration);
  addChargeTypeId(byteStream, offRouteMine.chargeStruct.chargeTypeId);
  addArea(byteStream, offRouteMine.area);
  addImpactRadius(byteStream, offRouteMine.impactRadius.is_set() ? offRouteMine.impactRadius.get() : -1);
  addEffectStart(byteStream, offRouteMine.effectStart.is_set() ? offRouteMine.effectStart.get() : -1);
  addPartyId(byteStream, offRouteMine.partyId.is_set() ? offRouteMine.partyId.get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::ExplosionCluster &explosionCluster, bool &isPrioritized)
{
  QByteArray byteStream;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionCluster);
  addAesItemId(byteStream, explosionCluster.id);
  addName(byteStream, explosionCluster.name);
  addEffectStart(byteStream, explosionCluster.effectStart.is_set() ? explosionCluster.effectStart.get() : -1);
  addEffectDuration(byteStream, explosionCluster.effectDuration);
  addArea(byteStream, explosionCluster.area);
  addMhpCount(byteStream, static_cast<int32_t>(explosionCluster.mhPoints.size()));
  addMhpRotation(byteStream, explosionCluster.mhpRotation);
  addImpactCount(byteStream, explosionCluster.impactCount);
  addChargeTypeId(byteStream, explosionCluster.chargeStruct.chargeTypeId);
  addPartyId(byteStream, explosionCluster.partyId.is_set() ? explosionCluster.partyId.get() : -1);

  isPrioritized = explosionCluster.impactCount == 1;  // we prioritize every single fire

  return byteStream;
}

void addAesItemId(QByteArray &buf, int32_t aesItemId)
{
  LtsUtils::set4Byte(aesItemId, buf);
}

void addAesMaLayingProcedureType(QByteArray &buf, const AreaEffectSimulation::AesMaLayingProcedureType &aesMaLayingProcedureType)
{
  addDdsEnumVal(buf, aesMaLayingProcedureType);
}

void addAesType(QByteArray &buf, const AreaEffectSimulation::AesType &aesType)
{
  using namespace AreaEffectSimulation;

  // we treat EffectClusters as ExplosionClusters
  addDdsEnumVal(buf, aesType == AesType::AtEffectCluster ? AesType::AtExplosionCluster : aesType);
}

void addAltitude(QByteArray &buf, int32_t altitude)
{
  LtsUtils::set4Byte(altitude, buf);
}

void addArea(QByteArray &buf, const AreaEffectSimulation::Area &area)
{
  addPosition2D(buf, area.cornerBottomLeft);
  LtsUtils::set8Byte(area.width, buf);
  LtsUtils::set8Byte(area.height, buf);
  LtsUtils::set8Byte(area.rotation, buf);
}

void addBorderLengthInner(QByteArray &buf, double borderLengthInner)
{
  LtsUtils::set8Byte(borderLengthInner, buf);
}

void addBorderLengthOuter(QByteArray &buf, double borderLengthOuter)
{
  LtsUtils::set8Byte(borderLengthOuter, buf);
}

void addCannonCount(QByteArray &buf, int32_t cannonCount)
{
  LtsUtils::set4Byte(cannonCount, buf);
}

void addCannonRounds(QByteArray &buf, int32_t cannonRounds)
{
  LtsUtils::set4Byte(cannonRounds, buf);
}

void addCentralAesChangeType(QByteArray &buf, OcSituation::CentralAesChangeType changeType)
{
  LtsUtils::set1Byte(changeType, buf);
}

void addCentralAngle(QByteArray &buf, double centralAngle)
{
  LtsUtils::set8Byte(centralAngle, buf);
}

void addChargeTypeId(QByteArray &buf, int32_t chargeType)
{
  LtsUtils::set4Byte(chargeType, buf);
}

template<typename T>
void addDdsEnumVal(QByteArray &buf, const T &ddsEnumVal)
{
  LtsUtils::set4Byte(static_cast<int32_t>(ddsEnumVal), buf);
}

void addDeconMode(QByteArray &buf, const AreaEffectSimulation::AesOperatingMode &deconMode)
{
  addDdsEnumVal(buf, deconMode);
}

void addDeconTime(QByteArray &buf, int32_t deconTime)
{
  LtsUtils::set4Byte(deconTime, buf);
}

void addDensity(QByteArray &buf, double density)
{
  LtsUtils::set8Byte(density, buf);
}

void addDetonationValue(QByteArray &buf, double detonationValue)
{
  LtsUtils::set8Byte(detonationValue, buf);
}

void addEffectDuration(QByteArray &buf, int32_t effectDuration)
{
  LtsUtils::set4Byte(effectDuration, buf);
}

void addEffectStart(QByteArray &buf, rti::core::int64 effectStart)
{
  LtsUtils::set8Byte(effectStart, buf);
}

void addExplosionGeometry(QByteArray &buf, const AreaEffectSimulation::AesExplosionGeometry &explosionGeometry)
{
  addDdsEnumVal(buf, explosionGeometry);
}

void addFireRequestTime(QByteArray &buf, rti::core::int64 fireRequestTime)
{
  LtsUtils::set8Byte(fireRequestTime, buf);
}

void addIgniterType(QByteArray &buf, int32_t igniterTypeId)
{
  LtsUtils::set4Byte(igniterTypeId, buf);
}

void addFunctionalAreaTypeId(QByteArray &buf, int32_t functionalAreaTypeId)
{
  LtsUtils::set4Byte(functionalAreaTypeId, buf);
}

void addImpactCount(QByteArray &buf, int32_t impactCount)
{
  LtsUtils::set4Byte(impactCount, buf);
}

void addImpactPosition(QByteArray &buf, const Core::GeoPosition2D &position)
{
  addPosition2D(buf, position);
}

void addImpactRadius(QByteArray &buf, double impactRadius)
{
  LtsUtils::set8Byte(impactRadius, buf);
}

void addIsCenterLine(QByteArray &buf, bool isCenterLine)
{
  LtsUtils::set1Byte(isCenterLine, buf);
}

void addIsLayedHidden(QByteArray &buf, bool isLayedHidden)
{
  LtsUtils::set1Byte(isLayedHidden, buf);
}

void addMaintMode(QByteArray &buf, const AreaEffectSimulation::AesOperatingMode &maintMode)
{
  addDdsEnumVal(buf, maintMode);
}

void addMaintTime(QByteArray &buf, int32_t maintTime)
{
  LtsUtils::set4Byte(maintTime, buf);
}

void addMedicMode(QByteArray &buf, const AreaEffectSimulation::AesOperatingMode &medicMode)
{
  addDdsEnumVal(buf, medicMode);
}

void addMedicTime(QByteArray &buf, int32_t medicTime)
{
  LtsUtils::set4Byte(medicTime, buf);
}

void addMhpCount(QByteArray &buf, int32_t mhpCount)
{
  LtsUtils::set4Byte(mhpCount, buf);
}

void addMhpRotation(QByteArray &buf, double mhpRotation)
{
  LtsUtils::set8Byte(mhpRotation, buf);
}

void addName(QByteArray &buf, const std::string &name)
{
  addString(buf, name, 8);
}

void addPartyId(QByteArray &buf, int32_t partyId)
{
  LtsUtils::set4Byte(partyId, buf);
}

void addPointSymbol(QByteArray &buf, const std::string &pointSymbol)
{
  addString(buf, pointSymbol, pointSymbol.length());
}

void addPosition2D(QByteArray &buf, const Core::GeoPosition2D &position)
{
  LtsUtils::set8Byte(position.lon, buf);
  LtsUtils::set8Byte(position.lat, buf);
  // no timestamp, as it is set in the client anyway
}

void addPurpose(QByteArray &buf, const std::string &purpose)
{
  addString(buf, purpose);
}

void addRotationAngle(QByteArray &buf, double rotationAngle)
{
  LtsUtils::set8Byte(rotationAngle, buf);
}

void addSegments(QByteArray &buf, const std::vector<AreaEffectSimulation::MineSegment> &segments)
{
  unsigned char len = segments.size() + 1;
  LtsUtils::set1Byte(len, buf);

  if (len == 1)
    return;

  AreaEffectSimulation::MineSegment lastSeg;

  for (const AreaEffectSimulation::MineSegment &currentMineSegment : qAsConst(segments))
  {
    addPosition2D(buf, currentMineSegment.positionStart);
    lastSeg = currentMineSegment;
  }
  addPosition2D(buf, lastSeg.positionEnd);
}

void addSpanAngle(QByteArray &buf, double spanAngle)
{
  LtsUtils::set8Byte(spanAngle, buf);
}

void addString(QByteArray &buf, const std::string &str, size_t maxLen)
{
  unsigned char len = std::min(str.size(), size_t(maxLen));
  LtsUtils::set1Byte(len, buf);
  buf.append(str.c_str(), len);
}

void addTriggerRadius(QByteArray &buf, double triggerRadius)
{
  LtsUtils::set8Byte(triggerRadius, buf);
}

void addWidth(QByteArray &buf, double width)
{
  LtsUtils::set8Byte(width, buf);
}

void addPropagationDirection(QByteArray &buf, double propagationDirection)
{
  LtsUtils::set8Byte(propagationDirection, buf);
}

void addWindSpeed(QByteArray &buf, double windSpeed)
{
  LtsUtils::set8Byte(windSpeed, buf);
}

} // namespace DataBuilder

} // namespace OcSituationServer