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

#pragma once


#include <QMap>
#include <QString>

namespace SymbologyXML
{

// Um die Moeglichkeiten des typechecking zu nutzehn, erstellen wird die
// folgende Klasse als template-class:
template<typename TYPE>
class AttributeData
{
protected:
  //  enum -> internal String (XML-File)
  QMap<TYPE, QString> enum2str;

  //  internal String (XML-File)-> enum
  QMap<QString, TYPE> str2enum;

  //  enum -> external String (for translation)
  QMap<TYPE, QString> enum2Tr;

  // Order to fill the ComboBox
  QVector<TYPE> order;

public:
  void insert(const TYPE &enumKey, const QString &InternalString, const QString &ExternalString) {
    enum2str.insert(enumKey, InternalString);
    str2enum.insert(InternalString, enumKey);
    enum2Tr.insert(enumKey, ExternalString);
    order.push_back(enumKey);
  }

  QString convert_enum2str(const TYPE &enumKey) const
  {
    QString ret;
    if ( enum2str.contains(enumKey) )
    {
      ret = enum2str[enumKey];
    }
    else
    {
      ret = enum2str.value(*order.begin());   // == "FOO_UNDEFINED"
    }
    return ret;
  }

  QString convert_enum2tr(const TYPE &enumKey) const
  {
    QString ret;
    if ( enum2Tr.contains(enumKey) )
    {
      ret = enum2Tr[enumKey];
    }
    else
    {
      ret = enum2str.value(*order.begin());   // == "FOO_UNDEFINED"
    }
    return ret;
  }

  TYPE convert_str2enum(const QString& str_ref, bool* bOk = nullptr) const
  {
    TYPE ret = *order.begin();   // == FOO_UNDEFINED
    if ( str2enum.contains(str_ref) )
    {
      ret = str2enum[str_ref];
      if (bOk)
        *bOk = true;
    } else {
      if (bOk)
        *bOk = false;
    }
    return ret;
  }

  TYPE convert_str2enum(const QStringRef& str_ref, bool* bOk = nullptr) const
  {
    return convert_str2enum(str_ref.toString(), bOk);
  }

  void clear()
  {
    enum2str.clear();
    str2enum.clear();
    enum2Tr.clear();
    order.clear();
  }

  size_t size() const {
    return order.size();
  }

  QMap<int, QString> getContainerAsInt() const {
    QMap<int, QString> retMap;

    QVectorIterator<TYPE> i(order);
    TYPE val;
    while (i.hasNext()) {
      val = i.next();
      retMap.insert((int)val, convert_enum2tr(val));
    }
    return retMap;
  }

  QVectorIterator<TYPE> getIterator() const {
    return order;
  }

};



// Um die Moeglichkeiten des typechecking zu nutzen, erstellen wird die
// folgende Klasse als template-class:
template<typename TYPE_SECTORICON>
class AttributeDataSectorIcon : public AttributeData<TYPE_SECTORICON>
{
protected:

  QVector<TYPE_SECTORICON> orderSector1;
  QVector<TYPE_SECTORICON> orderSector2;

  QVector<TYPE_SECTORICON> orderSectorMain;
  QVector<TYPE_SECTORICON> orderSectorMainComboBox;
  QVector<TYPE_SECTORICON> orderSectorMainListView;

  QVector<TYPE_SECTORICON> orderSectorFullFramed;

public:
  size_t size() const = delete;

  void clear()
  {
    AttributeData<TYPE_SECTORICON>::clear();
    orderSector1.clear();
    orderSector2.clear();

    orderSectorMain.clear();
    orderSectorMainComboBox.clear();
    orderSectorMainListView.clear();

    orderSectorFullFramed.clear();
  }

  bool contains(const TYPE_SECTORICON &id,
                SymbolTypes::t_sector_position sectorPosition,
                SymbolTypes::t_select_widget selectWidget = SymbolTypes::SELECT_WIDGET_UNDEFINED) const
  {
    bool found = false;

    const QVector<TYPE_SECTORICON>* cont_p = this->getContainer(sectorPosition, selectWidget);
    if (cont_p)
    {
       found = cont_p->contains(id);
    }

    return found;
  }

  void insert(const TYPE_SECTORICON &enumKey,
              const QString &InternalString,
              const QString &ExternalString,
              int sectorPositions,
              SymbolTypes::t_select_widget selectWidget = SymbolTypes::SELECT_WIDGET_UNDEFINED) {
    AttributeData<TYPE_SECTORICON>::insert(enumKey, InternalString, ExternalString);

    if (sectorPositions & SymbolTypes::SECTOR1)
      this->orderSector1.push_back(enumKey);

    if (sectorPositions & SymbolTypes::SECTOR2)
      this->orderSector2.push_back(enumKey);

    if (sectorPositions & SymbolTypes::SECTORMAIN) {
      this->orderSectorMain.push_back(enumKey);

      switch (selectWidget)
      {
      case SymbolTypes::SELECT_WIDGET_UNDEFINED:
        {
          // empty
        }
        break;
      case SymbolTypes::SELECT_WIDGET_CB:
        this->orderSectorMainComboBox.push_back(enumKey);
        break;
      case SymbolTypes::SELECT_WIDGET_LV:
        this->orderSectorMainListView.push_back(enumKey);
        break;
      } // switch

    } // if

    if (sectorPositions & SymbolTypes::SECTORFF)
      this->orderSectorFullFramed.push_back(enumKey);
  };

  const QVector<TYPE_SECTORICON>* getContainer(SymbolTypes::t_sector_position sectorPosition,
                                               SymbolTypes::t_select_widget selectWidget = SymbolTypes::SELECT_WIDGET_UNDEFINED) const
  {
    const QVector<TYPE_SECTORICON>* cont_p = nullptr;

    switch(sectorPosition)
    {
    case SymbolTypes::SECTOR1:
      cont_p = &orderSector1;
      break;
    case SymbolTypes::SECTOR2:
      cont_p = &orderSector2;
      break;
    case SymbolTypes::SECTORMAIN:
      {

        switch (selectWidget)
        {
        case SymbolTypes::SELECT_WIDGET_UNDEFINED:
          cont_p = &orderSectorMain;
          break;
        case SymbolTypes::SELECT_WIDGET_CB:
          cont_p = &orderSectorMainComboBox;
          break;
        case SymbolTypes::SELECT_WIDGET_LV:
          cont_p = &orderSectorMainListView;
          break;
        } // switch

      }
      break;
    case SymbolTypes::SECTORFF:
      cont_p = &orderSectorFullFramed;
      break;
    case SymbolTypes::SECTOR_POSITION_UNDEFINED:
      {
        // empty - avoiding compiler warning
      }

    } // switch

    return cont_p;
  }

  const QMap<int, QString> getContainerAsInt(SymbolTypes::t_sector_position sectorPosition,
                                             SymbolTypes::t_select_widget selectWidget = SymbolTypes::SELECT_WIDGET_UNDEFINED) const {
    QMap<int, QString> retMap;

    const QVector<TYPE_SECTORICON>* cont_p = getContainer(sectorPosition, selectWidget);
    QVectorIterator<TYPE_SECTORICON> iter(*cont_p);
    TYPE_SECTORICON val;
    while (iter.hasNext()) {
      val = iter.next();
      retMap.insert((int)val, this->convert_enum2tr(val));
    }
    return retMap;
  };

}; // AttributeDataSectorIcon

}; // namespace SymbologyXML