/**
  * @RDE_HEADER@
  * SidcCodec for internal handling of SIDCs
  * $Id$
  * $HeadURL$
  * $Author$
  */

// Own
#include "sidc_codec.h"  // enbles highlighting and is harmless since 'pragma once'
#include "sidc_definitions.h"

#include <SymbologyXML/xml_symbol_codec.h>

// Qt
#include <QRegExp>


namespace AdvancedSymbology
{


//
// SidcCodecHelper
//
namespace SidcCodecHelper
{

QString encode(SymbologyType symbologyType)
{
  switch (symbologyType)
  {
  case SymbologyType::None:     return QStringLiteral("NONE"); break;
  case SymbologyType::APP6B:    return QStringLiteral("AP6B"); break;
  case SymbologyType::APP6D:    return QStringLiteral("AP6D"); break;
  case SymbologyType::MIL2525C: return QStringLiteral("M25C"); break;
  case SymbologyType::MIL2525D: return QStringLiteral("M25D"); break;
  };
  return QLatin1String("EROR");
}

SymbologyType decodeSymbology(const QStringRef &symbologyTypeStr)
{
  SymbologyType symbologyType = SymbologyType::None;
  if (symbologyTypeStr.compare(QLatin1String("NONE")) == 0) symbologyType = SymbologyType::None;
  else if (symbologyTypeStr.compare(QLatin1String("AP6B")) == 0) symbologyType = SymbologyType::APP6B;
  else if (symbologyTypeStr.compare(QLatin1String("AP6D")) == 0) symbologyType = SymbologyType::APP6D;
  else if (symbologyTypeStr.compare(QLatin1String("M25C")) == 0) symbologyType = SymbologyType::MIL2525C;
  else if (symbologyTypeStr.compare(QLatin1String("M25D")) == 0) symbologyType = SymbologyType::MIL2525D;
  return symbologyType;
}

QString encode(SidcCodec::SidcType sidcType)
{
  switch (sidcType)
  {
  case SidcCodec::SidcType::None:      return QStringLiteral("NONE"); break;
  case SidcCodec::SidcType::Base:      return QStringLiteral("BASE"); break;
  case SidcCodec::SidcType::Complete:  return QStringLiteral("CMPL"); break;
  case SidcCodec::SidcType::CivilEts:  return QStringLiteral("CVLE"); break;
  case SidcCodec::SidcType::CivilXml:  return QStringLiteral("CVLX"); break;
  }
  return QLatin1String("EROR");
}

SidcCodec::SidcType decodeSidc(const QStringRef &sidcTypeStr)
{
  SidcCodec::SidcType symbologyType = SidcCodec::SidcType::None;
  if (     sidcTypeStr.compare(QLatin1String("NONE")) == 0) symbologyType = SidcCodec::SidcType::None;
  else if (sidcTypeStr.compare(QLatin1String("BASE")) == 0) symbologyType = SidcCodec::SidcType::Base;
  else if (sidcTypeStr.compare(QLatin1String("CMPL")) == 0) symbologyType = SidcCodec::SidcType::Complete;
  else if (sidcTypeStr.compare(QLatin1String("CVLE")) == 0) symbologyType = SidcCodec::SidcType::CivilEts;
  else if (sidcTypeStr.compare(QLatin1String("CVLX")) == 0) symbologyType = SidcCodec::SidcType::CivilXml;
  return symbologyType;
}

} // SidcCodecHelper


unsigned int SidcCodec::rawSidcOffset() { return 10;  }
//
// isEncoded
//
bool SidcCodec::isEncoded(const QString &encodedSidc)
{
  const QChar separator(QLatin1Char('|'));
  return ((encodedSidc.size() > 9) && (encodedSidc.at(4) == separator) && (encodedSidc.at(9) == separator));
}


bool SidcCodec::checkSidcSyntax(const QString &encodedSidc)
{
  if (!isEncoded(encodedSidc)) return false;

  SidcCodec::SidcType sidcType = SidcCodecHelper::decodeSidc(QStringRef(&encodedSidc, 5, 4));

  const QStringRef symbologyTypeStr(&encodedSidc, 0, 4);

  if (symbologyTypeStr.compare(QLatin1String("NONE")) == 0)      return true;
  else if (symbologyTypeStr.compare(QLatin1String("AP6B")) == 0) return true;
  else if (symbologyTypeStr.compare(QLatin1String("AP6D")) == 0) return true;
  else if (symbologyTypeStr.compare(QLatin1String("M25C")) == 0) return true;
  else if ((symbologyTypeStr.compare(QLatin1String("M25D")) == 0) || (symbologyTypeStr.compare(QLatin1String("AP6D")) == 0))
  {
    const QString &rawSidcStr(encodedSidc.mid(10));

    QRegExp isDigit(QStringLiteral("^[0..9]*$"));

    if (isDigit.exactMatch(rawSidcStr))
    {
      switch (sidcType)
      {
      case SidcCodec::SidcType::Base     : return (rawSidcStr.size() ==  8); break;
      case SidcCodec::SidcType::Complete : return (rawSidcStr.size() == 20); break;
      default: break;
      }
    }
  }
  return false;
}

bool SidcCodec::isCivil(const QString &encodedSidc)
{
  SidcCodec::SidcType sidcType = SidcCodec::decodeSidcType(encodedSidc);
  return ((sidcType == SidcCodec::SidcType::CivilEts) || (sidcType == SidcCodec::SidcType::CivilXml));
}

//
// ENCODE
//
QString SidcCodec::encodeBaseSymbolCode(SymbologyType symbologyType, const QString &baseSymboCodeSidc)
{
  return QStringLiteral("%1|BASE|%3").arg(SidcCodecHelper::encode(symbologyType), baseSymboCodeSidc);
}

QString SidcCodec::encodeComplete(SymbologyType symbologyType, const QString &completeSidc)
{
  return QStringLiteral("%1|CMPL|%3").arg(SidcCodecHelper::encode(symbologyType), completeSidc);
}

QString SidcCodec::encodeCivilEts(const QString &civilSidc)
{
  return QStringLiteral("NONE|CVLE|%1").arg(civilSidc);
}

QString SidcCodec::encodeCivilXml(const QString &civilSidc)
{
  return QStringLiteral("NONE|CVLX|%1").arg(civilSidc);
}

int SidcCodec::decodeCivilXml(const QString &civilSidc)
{
  return decodeRawSidc(civilSidc).toInt();
}

//
// DECODE
//
// QStringRef(const QString *string, int position, int size);
// QString mid(int position, int n = -1) const Q_REQUIRED_RESULT;
//

SymbologyType SidcCodec::decodeSymbologyType(const QString &encodedSidc)
{
  return SidcCodecHelper::decodeSymbology(QStringRef(&encodedSidc, 0, 4));
}

SidcCodec::SidcType SidcCodec::decodeSidcType(const QString &encodedSidc)
{
  return SidcCodecHelper::decodeSidc(QStringRef(&encodedSidc, 5, 4));
}

QString SidcCodec::decodeRawSidc(const QString &encodedSidc)
{
  return (isEncoded(encodedSidc)) ? encodedSidc.mid(rawSidcOffset()) : encodedSidc;
}


QString SidcCodec::encodeCivilXmlSymbolId( uint symbolId )
{
  const QString &rawSidc = QString::number(symbolId);
  return encodeCivilXml(rawSidc);
} // QString SidcCodec::encodeCivilXmlSymbolId( uint symbolId )


QString SidcCodec::encodeCivilXmlSymbolId( uint symbolId
                                         , SymbologyXML::SymbolTypes::t_state        state
                                         , SymbologyXML::SymbolTypes::t_uncertainty  uncertainty
                                         , SymbologyXML::SymbolTypes::t_affil        affil
                                         , SymbologyXML::SymbolTypes::t_mob          mob          )
{
  const QString &rawSidc = SymbologyXML::xmlSymbolEncodeId(symbolId,state,uncertainty,affil,mob);
  return encodeCivilXml(rawSidc);
} // QString SidcCodec::encodeCivilXmlSymbolId(...)

QString SidcCodec::extractCivilXmlBaseSidc( const QString &sidc )
{
  return SymbologyXML::xmlSymbolExtractBaseSidc(sidc);
} // QString SidcCodec::extractCivilXmlBaseSidc( const QString &sidc )


//
// Some convenience functions

QString SidcCodec::encodeBaseSymbolCode(SymbologyType symbologyType, const QStringRef  &baseSymboCodeSidc) { return encodeBaseSymbolCode(symbologyType, *baseSymboCodeSidc.string()); }
QString SidcCodec::encodeBaseSymbolCode(SymbologyType symbologyType, const std::string &baseSymboCodeSidc) { return encodeBaseSymbolCode(symbologyType, QString::fromStdString(baseSymboCodeSidc));}
QString SidcCodec::encodeBaseSymbolCode(SymbologyType symbologyType, const char        *baseSymboCodeSidc) { return encodeBaseSymbolCode(symbologyType, QString::fromLatin1(baseSymboCodeSidc));}

QString SidcCodec::encodeComplete(SymbologyType symbologyType, const QStringRef  &completeSidc)            { return encodeComplete(symbologyType, *completeSidc.string());}
QString SidcCodec::encodeComplete(SymbologyType symbologyType, const std::string &completeSidc)            { return encodeComplete(symbologyType, QString::fromStdString(completeSidc)); }
QString SidcCodec::encodeComplete(SymbologyType symbologyType, const char        *completeSidc)            { return encodeComplete(symbologyType, QString::fromLatin1(completeSidc)); }

QString SidcCodec::encodeCivilEts(const QStringRef  &civilSidc)                                            { return encodeCivilEts(*civilSidc.string());}
QString SidcCodec::encodeCivilEts(const std::string &civilSidc)                                            { return encodeCivilEts(QString::fromStdString(civilSidc)); }
QString SidcCodec::encodeCivilEts(const char        *civilSidc)                                            { return encodeCivilEts(QString::fromLatin1(civilSidc)); }

QString SidcCodec::encodeCivilXml(const QStringRef  &civilSidc)                                            { return encodeCivilXml(*civilSidc.string());}
QString SidcCodec::encodeCivilXml(const std::string &civilSidc)                                            { return encodeCivilXml(QString::fromStdString(civilSidc)); }
QString SidcCodec::encodeCivilXml(const char        *civilSidc)                                            { return encodeCivilXml(QString::fromLatin1(civilSidc)); }

} // namespace AdvancedSymbology