/**
  * @RDE_HEADER@
  * Class SidcBuilder
  * $Id$
  * $HeadURL$
  * $Author$
  */

// Own
#include "sidc_builder.h"
#include "sidc_codec.h"


//                                                     1234567890
qint32 AdvancedSymbology::SidcBuilder::_smallest     = 1000000000;
qint32 AdvancedSymbology::SidcBuilder::_specialPartA = 1001980000;
qint32 AdvancedSymbology::SidcBuilder::_invalidPartB = 1000000000;
qint32 AdvancedSymbology::SidcBuilder::_retiredPartB = 1100000000;



namespace AdvancedSymbology
{

//-----------------------------------------------------------------------------
// SidcBuilder
//-----------------------------------------------------------------------------
SidcBuilder::SidcBuilder(AdvancedSymbology::SymbolDictionary *symbolDictionary)
  : SidcBuilderBase(symbolDictionary, "SidcBuilder")
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  init();
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}

void SidcBuilder::init()
{
  m_first10_mil2525D = QString::number(_specialPartA);
  m_second10_mil2525D = QString::number(_invalidPartB);
  initAmplifier();
}

void SidcBuilder::initAmplifier()
{
  m_amplifierGroup      = AmplifierGroup::Unknown;

  m_e_BrigadeAndBelow   = EchelonBrigadeAndBelow::Unknown;
  m_e_DivisionAndAbove  = EchelonDivisionAndAbove::Unknown;

  m_e_MobilityOnLand    = MobilityOnLand::Unknown;
  m_e_MobilityOnSnow    = MobilityOnSnow::Unknown;
  m_e_MobilityOnWater   = MobilityOnWater::Unknown;

  m_e_NavalTowedArray   = NavalTowedArray::Unknown;
}




SidcDefinitions::StandardIdentity SidcBuilder::standardIdentity() const
{
  StandardIdentity si;
  si.context  = context();
  si.identity = identity();
  return si;
}

void SidcBuilder::setStandardIdentity(const SidcDefinitions::StandardIdentity &standardIdentity)
{
  setContext(standardIdentity.context);
  setIdentity(standardIdentity.identity);
}

SidcDefinitions::Context SidcBuilder::context() const
{
  return static_cast<Context>(QStringRef(&m_first10_mil2525D, 2, 1).toInt());
}
void SidcBuilder::setContext(SidcDefinitions::Context context)
{
  m_first10_mil2525D.replace(2, 1, QString::number((int)context));
}
SidcDefinitions::Identity SidcBuilder::identity() const
{
  return static_cast<Identity>(QStringRef(&m_first10_mil2525D, 3, 1).toInt());
}

void SidcBuilder::setIdentity(SidcDefinitions::Identity identity)
{
  m_first10_mil2525D.replace(3, 1, QString::number((int)identity));
}

bool SidcBuilder::isIdentityAssumed() const
{
  const SidcDefinitions::Identity identityValue = identity();

  switch (identityValue) {
  case SidcDefinitions::Identity::Pending:
    return true;
  case SidcDefinitions::Identity::AssumedFriend:
    return true;
  case SidcDefinitions::Identity::SuspectJoker:
    return true;
    break;
  default:
    // empty
    break;
  }
  return false;
}

SidcDefinitions::SymbolSet SidcBuilder::symbolSet() const
{
  SymbolSet sset = static_cast<SymbolSet>(QStringRef(&m_first10_mil2525D, 4, 2).toString().toInt());
  return sset;
}
void SidcBuilder::setSymbolSet(const SymbolSet &symbolSet)
{
  m_first10_mil2525D.replace(4, 2, QStringLiteral("%1").arg((int)symbolSet, 2, 10, QLatin1Char('0')));
}


SidcDefinitions::Status SidcBuilder::status() const
{
  Status status = static_cast<Status>(QStringRef(&m_first10_mil2525D, 6, 1).toInt());
  return status;
}

void SidcBuilder::setStatus(const Status &status)
{
  m_first10_mil2525D.replace(6, 1, QString::number((int)status));
}


QString SidcBuilder::symbolEntityCode() const
{
  SymbologyType symbologyType = m_symbolDictionary->symbologyType();
  switch (symbologyType)
  {
    case SymbologyType::APP6B    : return SidcCodec::decodeRawSidc(concreteSidcToBaseSymbolCode(SidcCodec::encodeComplete(symbologyType,m_app6bRawSidc)));
    case SymbologyType::APP6D    : return m_second10_mil2525D.left(6);
    case SymbologyType::MIL2525C : return QString();
    case SymbologyType::MIL2525D : return m_second10_mil2525D.left(6);
    case SymbologyType::None     : return QString();
  }
  return QString();
}


void SidcBuilder::setSymbolEntityCode(const QString &entityCode)
{
  if (entityCode.size() == 6) m_second10_mil2525D.replace(0, 6, entityCode);
}


SidcDefinitions::HQTFDummy SidcBuilder::hqTfFd() const
{
  HQTFDummy hdtffd = static_cast<HQTFDummy>(QStringRef(&m_first10_mil2525D, 7, 1).toInt());
  return hdtffd;
}

uint SidcBuilder::hqTfFd_UInt() const
{
  return static_cast<int>(hqTfFd());
}

void SidcBuilder::setHqTfFd(const HQTFDummy &hqTfFd)
{
  m_first10_mil2525D.replace(7, 1, QString::number((int)hqTfFd));
}

bool SidcBuilder::headquarters() const
{
  bool headquarters;
  bool taskForce;
  bool feintDummy;
  SidcDefinitions::HQTFDummyConverter::toBool(hqTfFd(), headquarters, taskForce, feintDummy);
  return headquarters;
}

bool SidcBuilder::taskForce() const
{
  bool headquarters;
  bool taskForce;
  bool feintDummy;
  SidcDefinitions::HQTFDummyConverter::toBool(hqTfFd(), headquarters, taskForce, feintDummy);
  return taskForce;
}

bool SidcBuilder::feintDummy() const
{
  bool headquarters;
  bool taskForce;
  bool feintDummy;
  SidcDefinitions::HQTFDummyConverter::toBool(hqTfFd(), headquarters, taskForce, feintDummy);
  return feintDummy;
}


SidcDefinitions::AmplifierGroup SidcBuilder::amplifierGroup() const
{
  AmplifierGroup amplifierGroup = static_cast<AmplifierGroup>(QStringRef(&m_first10_mil2525D, 8, 1).toInt());
  return amplifierGroup;
}
void SidcBuilder::setAmplifierGroup(const AmplifierGroup &amplifierGroup)
{
  m_first10_mil2525D.replace(8, 1, QString::number((int)amplifierGroup));
}

unsigned int SidcBuilder::amplifier2ndDigit() const
{
  return QStringRef(&m_first10_mil2525D, 9, 1).toUInt();
} // unsigned int SidcBuilder::amplifier2ndDigit() const


void SidcBuilder::setAmplifier2ndDigit(unsigned int amplifierSecondDigit)
{
  if (amplifierSecondDigit > 9) return;  // ToDo error message
  m_first10_mil2525D.replace(9, 1, QString::number(amplifierSecondDigit));
}

unsigned int SidcBuilder::sectorModifier1Digit()
{
  return QStringRef(&m_second10_mil2525D, 6, 2).toUInt();
} // unsigned int SidcBuilder::sectorModifier1Digit()


unsigned int SidcBuilder::sectorModifier2Digit()
{
  return QStringRef(&m_second10_mil2525D, 8, 2).toUInt();
} // unsigned int SidcBuilder::sectorModifier2Digit()


void SidcBuilder::setSectorModifier1Digit(unsigned int digit)
{
  if (digit > 99) return; // ToDo error message
  m_second10_mil2525D.replace(6, 2, QStringLiteral("%1").arg(digit, 2, 10, QLatin1Char('0')));
} // void SidcBuilder::setSectorModifier1Digit( unsigned int )


void SidcBuilder::setSectorModifier2Digit(unsigned int digit)
{
  if (digit > 99) return; // ToDo error message
  m_second10_mil2525D.replace(8, 2, QStringLiteral("%1").arg(digit, 2, 10, QLatin1Char('0')));
} // void SidcBuilder::setSectorModifier2Digit( unsigned int digit )





QString SidcBuilder::toRawSidc() const
{
  if (!m_symbolDictionary)
    return QString();
  switch (m_symbolDictionary->symbologyType())
  {
    case SymbologyType::APP6B    : return m_app6bRawSidc;
    case SymbologyType::APP6D    : return m_first10_mil2525D + m_second10_mil2525D;
    case SymbologyType::MIL2525C : return QString();
    case SymbologyType::MIL2525D : return m_first10_mil2525D + m_second10_mil2525D;
    case SymbologyType::None     : return QString();
  }
  return QString();
}


QString SidcBuilder::toSidc() const
{
  if (!m_symbolDictionary)
    return QString();
  const QString &rawSidc = toRawSidc();
  
  return (rawSidc.isEmpty()) ? QString() : SidcCodec::encodeComplete(m_symbolDictionary->symbologyType(), rawSidc);
} // QString SidcBuilder::toSidc() const


bool SidcBuilder::initFromSymbologyType(SymbologyType symbologyType, const QString &sidc)
{
  QString  rawSidc(sidc);

  if (SidcCodec::isEncoded(sidc))
  {
    SymbologyType        sidcSymbolType = SidcCodec::decodeSymbologyType(sidc);
    SidcCodec::SidcType  sidcType       = SidcCodec::decodeSidcType(sidc);

    rawSidc = SidcCodec::decodeRawSidc(sidc);

    if (symbologyType != sidcSymbolType)
    {
      ERROR_LOG(m_logger) << LOGFUNCTION
                          << " sidc='" << sidc << "'"
                          << ", wrong symbology type";
      return false;
    }

    if (SidcCodec::SidcType::Complete != sidcType)
    {
      ERROR_LOG(m_logger) << LOGFUNCTION
                          << " sidcMIL2525D='" << sidc << "'"
                          << ", wrong sidc type";
      return false;
    }
  }

  // check size
  if (rawSidc.size() != 20)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION
                        << " sidc='" << sidc << "'"
                        << ", size failed";
    return false;
  }

  // check version
  if (QStringRef(&rawSidc, 0, 2) != QLatin1String("10"))
  {
    ERROR_LOG(m_logger) << LOGFUNCTION
                        << " sidc='" << sidc << "'"
                        << ", wrong version";
    return false;
  }

  init();

  m_first10_mil2525D = rawSidc.mid( 0, 10);
  m_second10_mil2525D = rawSidc.mid(10, 10);

  DEBUG_LOG(m_logger) << LOGFUNCTION
                      << " m_first10='" << m_first10_mil2525D << "'"
                      << " m_second10='" << m_second10_mil2525D << "'";

  return true;
}


bool SidcBuilder::initFromSymbologyTypeBaseSymbolCode(SymbologyType symbologyType, const QString &baseSymbolCode)
{
  QString rawBaseSymbolCode(baseSymbolCode);

  if (SidcCodec::isEncoded(baseSymbolCode))
  {
    if (SidcCodec::decodeSymbologyType(baseSymbolCode) != symbologyType)
    {
      ERROR_LOG(m_logger) << LOGFUNCTION
                          << " sidc='" << baseSymbolCode << "'"
                          << ", wrong symbology type";
      return false;
    }

    if (SidcCodec::decodeSidcType(baseSymbolCode) != SidcCodec::SidcType::Base)
    {
      ERROR_LOG(m_logger) << LOGFUNCTION
                          << " sidc='" << baseSymbolCode << "'"
                          << ", wrong sidc type";
      return false;
    }

    rawBaseSymbolCode = SidcCodec::decodeRawSidc(baseSymbolCode);
  }

  // check size
  if (rawBaseSymbolCode.size() != 8)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION
                        << " baseSymbolCode='" << baseSymbolCode << "'"
                        << ", size failed";
    return false;
  }

  init();

  // set SymbolSet:
  SymbolSet sSet = static_cast<SymbolSet>(QStringRef(&rawBaseSymbolCode, 0, 2).toInt());
  this->setSymbolSet(sSet);

  // set Entity:
  const QString &entityChars = rawBaseSymbolCode.mid(2, 6);

  // merge into second10:
  m_second10_mil2525D.replace(0, 6, entityChars);

  return true;
} // bool SidcBuilder::initFromSymbologyTypeBaseSymbolCode(SymbologyType symbologyType, const QString &baseSymbolCode)


bool SidcBuilder::initFromMil2525D(const QString &sidcMil2525D)
{
  return SidcBuilder::initFromSymbologyType(SymbologyType::MIL2525D,sidcMil2525D);
}


bool SidcBuilder::initFromMil2525DBaseSymbolCode(const QString &sidcMil2525D_baseSymbolCode)
{
  return initFromSymbologyTypeBaseSymbolCode(SymbologyType::MIL2525D, sidcMil2525D_baseSymbolCode);
}


bool SidcBuilder::initFromApp6B(const QString &sidcApp6B)
{
  m_app6bRawSidc = SidcCodec::decodeRawSidc(sidcApp6B);
  return true;
}


bool SidcBuilder::initFromApp6BBaseSymbolCode(const QString &sidcApp6B_baseSymbolCode)
{
  m_app6bRawSidc = SidcCodec::decodeRawSidc(baseSymbolCodeToSidc( sidcApp6B_baseSymbolCode ));
  return false;
}

bool SidcBuilder::initFromApp6D(const QString &sidcAPP6D)
{
  return SidcBuilder::initFromSymbologyType(SymbologyType::APP6D,sidcAPP6D);
}


bool SidcBuilder::initFromApp6DBaseSymbolCode(const QString &sidcAPP6D_baseSymbolCode)
{
  return initFromSymbologyTypeBaseSymbolCode(SymbologyType::APP6D, sidcAPP6D_baseSymbolCode);
}



/*
        private void _BuildSIDC()
        {
            // Builds a current (2525D) SIDC from the JMSML Library elements currently associated
            // with this symbol.

            if (_version != null && _context != null &&
               _standardIdentity != null && _symbolSet != null && _status != null &&
               _hqTFDummy != null && _amplifierGroup != null && _amplifier != null)
            {
                _sidc.PartAUInt = (uint)_version.VersionCode.DigitOne * 1000000000 +
                                    (uint)_version.VersionCode.DigitTwo * 100000000 +
                                    (uint)_context.ContextCode * 10000000 +
                                    (uint)_standardIdentity.StandardIdentityCode * 1000000 +
                                    (uint)_symbolSet.SymbolSetCode.DigitOne * 100000 +
                                    (uint)_symbolSet.SymbolSetCode.DigitTwo * 10000 +
                                    (uint)_status.StatusCode * 1000 +
                                    (uint)_hqTFDummy.HQTFDummyCode * 100 +
                                    (uint)_amplifierGroup.AmplifierGroupCode * 10 +
                                    (uint)_amplifier.AmplifierCode;
            }

            if (_entity != null)
            {
                _sidc.PartBUInt = (uint)_entity.EntityCode.DigitOne * 1000000000 +
                                     (uint)_entity.EntityCode.DigitTwo * 100000000;
            }

            if (_entityType != null)
            {
                _sidc.PartBUInt = _sidc.PartBUInt + (uint)_entityType.EntityTypeCode.DigitOne * 10000000 +
                                                          (uint)_entityType.EntityTypeCode.DigitTwo * 1000000;
            }

            if (_entitySubType != null)
            {
                _sidc.PartBUInt = _sidc.PartBUInt + (uint)_entitySubType.EntitySubTypeCode.DigitOne * 100000 +
                                                          (uint)_entitySubType.EntitySubTypeCode.DigitTwo * 10000;
            }

            if (_modifierOne != null)
            {
                _sidc.PartBUInt = _sidc.PartBUInt + (uint)_modifierOne.ModifierCode.DigitOne * 1000 +
                                                          (uint)_modifierOne.ModifierCode.DigitTwo * 100;
            }

            if (_modifierTwo != null)
            {
                _sidc.PartBUInt = _sidc.PartBUInt + (uint)_modifierTwo.ModifierCode.DigitOne * 10 +
                                                          (uint)_modifierTwo.ModifierCode.DigitTwo;
            }
        }

*/


} // namespace AdvancedSymbology