/**
  * @RDE_HEADER@
  * MapObjectModel
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Norbert Thoden, SLSE, 2017-04-11
  */

#pragma once

// Own
#include <Map/map.h>
#include <Symbology/symbol_result.h>
#include <Common/situation_map_logging.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>

namespace SituationMap
{

// --------------------------------------------------------
// MapObjectData
// --------------------------------------------------------
class MapObjectData : public QObject
{
  Q_OBJECT

public:
  explicit MapObjectData(UniqueMapId uniqueMapId = INVALID_MAP_ID)
    : m_uniqueMapId(uniqueMapId)
  {}
  ~MapObjectData();

  void requestImage(AdvancedSymbology::SymbolDictionary *dict);
  void setImage(const QImage &img);

  // basic data:
  UniqueMapId                             m_uniqueMapId;
  int                                     m_participantId{-1};
  int                                     m_equipmentNumber{-1};
  int                                     m_partyId{-1};
  int                                     m_typeId{-1};
  int                                     m_vulnerabilityState{-1};
  QString                                 m_partyName;
  QString                                 m_typeName;
  QString                                 m_vulnerabilityString;

  int                                     m_buildingId{-1};

  QString                                 m_description1;
  QString                                 m_description2;


  // sidc -> icon/image:
  SymbolDataToRender                      m_symDataToRender;
  QPixmap                                 m_pixIcon;
  QPixmap                                 m_pixPicture;

private:
  AdvancedSymbology::SymbolResultWatcher *m_symbolResultWatcher = nullptr;

Q_SIGNALS:
  void dataChanged(UniqueMapId uniqueMapId);

public Q_SLOTS:
  void onResultReady();
private:
};


// --------------------------------------------------------
// MapObjectModel
// --------------------------------------------------------
class MapObjectModel : public LtsWidgets::LtsAbstractTableModel<QSharedPointer<MapObjectData>>
{
  Q_OBJECT
  using BaseClass = LtsWidgets::LtsAbstractTableModel<QSharedPointer<MapObjectData>>;

public:
  enum Columns
  {
    UNIQUE_MAP_ID = 0,
    SIDC,
    SINGLE_DESCRIPTION,
    ICON,
    PARTICIPANT_ID,
    EQUIPMENT_NUMBER,
    PARTY,
    TYPE_ID,
    TYPE_NAME,
    VULNERABILITY_STATE_ID,
    VULNERABILITY_STATE,
    DESCRIPTION1,
    DESCRIPTION2,
    PICTURE
  };

  explicit MapObjectModel(QObject *parent = nullptr);
  ~MapObjectModel();

  void initModel(Map *map);

  bool contains(UniqueMapId uniqueMapId) const;

  void remove(UniqueMapId uniqueMapId);

  void setMapObjectData(const QVector<QSharedPointer<MapObjectData>> &mapObjectDataVec);
  bool addMapObjectData(const QSharedPointer<MapObjectData> &mapObjectData);
  bool updateMapObjectData(const QSharedPointer<MapObjectData> &mapObjectData);

  template<typename T = QVector<UniqueMapId>>
  T allMapObjects() const
  {
    T uniqueMapIds;
    uniqueMapIds.reserve(m_vecData.size());

    for (const DATA_T &item : m_vecData)
      if (item)
        uniqueMapIds += item->m_uniqueMapId;
    return uniqueMapIds;
  }

  template<typename T = QVector<int>>
  T allEquipmentNumbers() const
  {
    T equipmentNumbers;
    equipmentNumbers.reserve(m_vecData.size());

    for (const DATA_T &item : m_vecData)
      if (item && item->m_equipmentNumber > 0)
        equipmentNumbers += item->m_equipmentNumber;
    return equipmentNumbers;
  }

  QVariant headerData(int section, Qt::Orientation orientation, int role) const override final;
  QVariant data(const QModelIndex &, int) const override final;

  UniqueMapId uniqueMapIdOfIndex(const QModelIndex &index) const;

private Q_SLOTS:
  void onDataChanged(UniqueMapId uniqueMapId);
  void requestCivilIcons();
  void updateUsedPartyIds();

private:
  using DATA_T = QSharedPointer<MapObjectData>;

  int findRowForUniqueMapId(UniqueMapId uniqueMapId) const;
  void requestIcon(const DATA_T &data) const;

  Map                                    *m_map           = nullptr;
  AdvancedSymbology::SymbolDictionary    *m_dictionary    = nullptr;

  QMap<int, int>                          m_usedPartyIds;  // keep sorted
  QSet<QString>                           m_usedTypeName;
  QMap<int, QString>                      m_usedVulnerabilities;  // keep sorted

  LOGGER_T m_logger;

  friend class MapObjectProxyModel;

};
// MapObjectModel


// --------------------------------------------------------
// MapObjectProxyModel
// --------------------------------------------------------
class MapObjectProxyModel : public LtsWidgets::LtsColumnFilterProxyModel
{
  Q_OBJECT
  using BaseClass = LtsWidgets::LtsColumnFilterProxyModel;

public:
  using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
  void setSourceModel(QAbstractItemModel *sourceModel) override;

protected:
  bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;

protected:
  MapObjectModel *m_sourceModel = nullptr;
};


} // namespace SituationMap