/**
  * @RDE_HEADER@
  * Interface of SymbolDictionary
  * $Id$
  * $HeadURL$
  * $Author$
  */

// Own
#include "symbol_dictionary.h"
#include <Common/resource_path.h>
#include <SymbologyImpl/symbol_dictionary_impl.h>


#include "sidc_codec.h"


// Qt
#include <QCoreApplication>
#include <QMap>
#include <QProcessEnvironment>

void initResource()
{
  Q_INIT_RESOURCE(symbols);
}


namespace AdvancedSymbology
{

bool SymbolDictionary::doParanoiaChecks()
{
  static bool s_read = false;
  static bool s_doParanoiaChecks = false;
  if (!s_read)
  {
    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
    QString val = env.value(QStringLiteral("DO_SITMAP_CHECKS"), QStringLiteral("1"));

    s_read = true;

    s_doParanoiaChecks = (val.compare(QStringLiteral("1"))==0);

    if (s_doParanoiaChecks)
      qCritical() << " paranoiaChecks are ON (via DO_SITMAP_CHECKS)";
    else
      qCritical() << " paranoiaChecks are OFF (via DO_SITMAP_CHECKS)";
  }
  return s_doParanoiaChecks;
}



static QMap<SymbologyType, QString> &s_symbologyResourcePaths()
{
  static QMap<SymbologyType, QString> map;
  return map;
} //  QMap<SymbologyType, QString> &s_symbologyResourcePaths()


static QMap<SymbologyType, SymbolDictionary *> &s_symbologyDictionaries()
{
  static QMap<SymbologyType, SymbolDictionary *> map;
  return map;
} // QMap<SymbologyType, SymbolDictionary *> &s_symbologyDictionaries


static void cleanupDictionary()
{
  qDeleteAll(s_symbologyDictionaries());
  s_symbologyDictionaries().clear();
}


bool SearchParameters::isEmpty() const
{
  return keys.isEmpty() &&
         names.isEmpty() &&
         categories.isEmpty() &&
         symbolClasses.isEmpty() &&
         tags.isEmpty();
}

int SearchParameters::numberOfParameter() const
{
  int count = 0;
  if (!keys.isEmpty())            ++count;
  if (!names.isEmpty())           ++count;
  if (!categories.isEmpty())      ++count;
  if (!symbolClasses.isEmpty())   ++count;
  if (!tags.isEmpty())            ++count;
  return count;
}



SymbolDictionary::SymbolDictionary(QObject *parent)
  : QObject(parent)
{
  LOGGER_T m_logger = getLogger("SymbolDictionary");
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  initResource();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}


static SymbologyType _defaultSymbologyType = SymbologyType::None;


SymbologyType SymbolDictionary::defaultSymbologyType()
{
  return _defaultSymbologyType;
} // SymbologyType SymbolDictionary::defaultSymbologyType()


void SymbolDictionary::setDefaultSymbologyType( SymbologyType symbologyType )
{
  if (SymbologyType::None == _defaultSymbologyType)
  {
    // set default only once
    _defaultSymbologyType = symbologyType;
  }
} // void SymbolDictionary::setDefaultSymbologyType( SymbologyType symbologyType )


QString SymbolDictionary::initializeSymbologyResourcePath(SymbologyType symbologyType)
{
  LOGGER_T m_logger = getLogger("SymbolDictionary");

  TRACE_LOG(m_logger) << LOGFUNCTION << " START"
                      << " symbologyType=" << symbologyType;

  if (s_symbologyResourcePaths()[symbologyType].isEmpty())
  {

#ifdef USE_ARCADE_SYMBOLOGY
    QString finalSymbologyResourcePath = SituationMap::getResourcePath() + QLatin1String("symbols_arcade/");
#else
    QString finalSymbologyResourcePath = SituationMap::getResourcePath() + QLatin1String("symbols/");
#endif // USE_ARCADE_SYMBOLOGY

    switch (symbologyType)
    {
    case AdvancedSymbology::SymbologyType::MIL2525D:
      finalSymbologyResourcePath.append(QLatin1String("mil2525d/mil2525d.stylx")); // like /arcgis/runtime_sdk/qt100.0/resources/symbols/mil2525d/mil2525d.stylx
      break;

    case AdvancedSymbology::SymbologyType::MIL2525C:
      finalSymbologyResourcePath.append(QLatin1String("mil2525c_b2/mil2525c_2b.stylX"));
      break;
    case AdvancedSymbology::SymbologyType::APP6B:
      finalSymbologyResourcePath.append(QLatin1String("app6b/app6b.stylx"));
      break;
    case AdvancedSymbology::SymbologyType::APP6D:
      finalSymbologyResourcePath.append(QLatin1String("app6d/app6d.stylx"));
      break;
    case AdvancedSymbology::SymbologyType::None:
      finalSymbologyResourcePath.clear();
      break;
    } // switch

    s_symbologyResourcePaths()[symbologyType] = finalSymbologyResourcePath;
  }

  DEBUG_LOG(m_logger) << LOGFUNCTION << " dict of type/path:"
                      << " symbologyType=" << symbologyType
                      << ", symbologyResourcePath='" << s_symbologyResourcePaths()[symbologyType] << "'";

  TRACE_LOG(m_logger) << LOGFUNCTION << " END"
                      << " symbologyType=" << symbologyType
                      << ", symbologyResourcePath='" << s_symbologyResourcePaths()[symbologyType] << "'";

  return s_symbologyResourcePaths()[symbologyType];
}


SymbolDictionary &SymbolDictionary::dictionary(SymbologyType symbologyType)
{
  LOGGER_T m_logger = getLogger("SymbolDictionary");

  TRACE_LOG(m_logger) << LOGFUNCTION << " START"
                      << " symbologyType=" << symbologyType;


  if (!s_symbologyDictionaries().contains(symbologyType))
  {
    // store and get final path:
    const QString &resPath = initializeSymbologyResourcePath(symbologyType);

    // Do NOT removed this message!!!
    NOTICE_LOG(m_logger) << LOGFUNCTION << " dictionary path: '" << resPath << "'"
                         << ", symbologyType " << symbologyType;
    // Do NOT removed this message!!!

    // create dict:
    AdvancedSymbology::SymbolDictionaryImpl *dict =
      new AdvancedSymbology::SymbolDictionaryImpl(symbologyType, resPath);

    // store dict:
    s_symbologyDictionaries()[symbologyType] = dict;

    qAddPostRoutine(cleanupDictionary);
  }

  TRACE_LOG(m_logger) << LOGFUNCTION << " END"
                      << " symbologyType=" << symbologyType;

  return *(s_symbologyDictionaries()[symbologyType]);
}

bool SymbolDictionary::alreadyExists(SymbologyType symbologyType)
{
  return s_symbologyDictionaries().contains(symbologyType);
}

QImage SymbolDictionary::temporaryImage(int sizeL)
{
  return SymbolDictionaryImpl::temporaryImage(sizeL);
}

void cleanupSymbolDictionaryInternal()
{
  LOGGER_T m_logger = getLogger("SymbolDictionary");

  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  cleanupDictionary();

  if (! s_symbologyDictionaries().isEmpty())
    FATAL_LOG(m_logger) << LOGFUNCTION << " s_symbologyDictionaries NOT empty";

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}


} // namespace AdvancedSymbology