/**
**
** @RDE_HEADER@
** plan_overlay_model.h
** $Id$
** $HeadURL$
** $Author$
**
** -----------------------------------------------------------------------------------------------
**
** Hardware-Environment: Intel-PC
** Software-Environment: Windows 7, Qt 5.7. ArcGIS 100
**
** Language ........: C++ 11
**
** -----------------------------------------------------------------------------------------------
**
** Author ...........: Jörg Turla, SPD G, Tel. 3132
**
** -----------------------------------------------------------------------------------------------
**
** Notes .........:
**
**   10.07.2017, JT  : First edition for use with Qt5
**
** -----------------------------------------------------------------------------------------------
*/

#include "plan_overlay_model.h"

#include <QByteArray>
#include <QDataStream>
#include <QMimeData>
#include <QJsonArray>

#include <FileManagement/flm_dtc.h>
#include <NGLLogger/NGLLoggerBootstrap.h>

template<class _Ty, class _Other = _Ty> inline _Ty doExchange(_Ty &_Val, _Other && _New_val)
{
  // assign _New_val to _Val, return previous _Val
  _Ty _Old_val = std::move(_Val);
  _Val = std::forward<_Other>(_New_val);
  return (_Old_val);
}


namespace PlanOverlaysPlugin
{

const QLatin1String REORDER_MIMETYPE("application/LtsPlanOverlayItemData/Reorder");

class PlanOverlayModel::InternalData
{
public:

  QMap<unsigned int, PlanOverlayModel::PlanItem>  m_planStore;
  QVector<int>                                    m_planOrder;
  QString                                         m_fileDialogMimeType;

  InternalData()
    : m_planStore(), m_planOrder(), m_fileDialogMimeType()
  {
  } // InternalData(const std::shared_ptr<SituationMap::ForeignGuiInterface>  & sitMapGui)

  ~InternalData() = default;

}; // PlanOverLayModel::InternalData


PlanOverlayModel::PlanOverlayModel() : QAbstractItemModel(), m_internal(new InternalData())
  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("PlanOverlayModel"))
{;}

PlanOverlayModel::~PlanOverlayModel()
{
  delete m_internal;
} // PlanOverlayModel::~PlanOverlayModel

#ifdef LTS_DEBUG
// show exercise id and phase id, last 2 columns in Debug mode
int PlanOverlayModel::columnCount(const QModelIndex &) const  { return int(ColumnSection::CustomSection) + 3; }
#else
int PlanOverlayModel::columnCount(const QModelIndex &) const  { return int(ColumnSection::CustomSection) + 1; }
#endif
int PlanOverlayModel::rowCount(const QModelIndex &) const { return m_internal->m_planStore.size(); }
int PlanOverlayModel::size()                        const { return m_internal->m_planStore.size(); }
QMap<unsigned int, PlanOverlayModel::PlanItem> PlanOverlayModel::planStore() const { return m_internal->m_planStore; }

bool PlanOverlayModel::isEmpty()                    const { return m_internal->m_planStore.isEmpty(); }


QVariant PlanOverlayModel::headerData(int section, Qt::Orientation orientation, int role) const
{
  if (role != Qt::DisplayRole ||
      orientation == Qt::Orientation::Vertical)
    return QVariant();

  switch (static_cast<ColumnSection>(section))
  {
  case ColumnSection::OrderButtons:
    return QVariant();
  case ColumnSection::PlanName:
    return tr("Plan");
  case ColumnSection::MinScale:
    return tr("Min. Scale");
  case ColumnSection::MaxScale:
    return tr("Max. Scale");
  case ColumnSection::Opacity:
    return tr("Opacity");
  case ColumnSection::CustomSection:
    return QVariant();
  case ColumnSection::ExerciseId:
    return tr("Exercise");
  case ColumnSection::PhaseId:
    return tr("Phase");
  }
  return QVariant();
} // QVariant PlanOverlayModel::headerData( int section, Qt::Orientation orientation, int role ) const


QVariant PlanOverlayModel::data(const QModelIndex &index, int role) const
{
  if (index.row() < 0 || index.row() >= m_internal->m_planOrder.size())
    return QVariant();

  if (Qt::ItemDataRole::TextAlignmentRole == role)
  {
    switch (static_cast<ColumnSection>(index.column()))
    {
    case ColumnSection::PlanName:
      return QVariant(Qt::Alignment::enum_type::AlignCenter);
    case ColumnSection::MinScale:
      return QVariant(Qt::Alignment::enum_type::AlignRight | Qt::Alignment::enum_type::AlignHCenter);
    case ColumnSection::MaxScale:
      return QVariant(Qt::Alignment::enum_type::AlignRight | Qt::Alignment::enum_type::AlignHCenter);
    case ColumnSection::OrderButtons:
    case ColumnSection::Opacity:
    case ColumnSection::CustomSection:
    case ColumnSection::ExerciseId:
    case ColumnSection::PhaseId:
      return QVariant();
    }
  }

  if (Qt::ItemDataRole::DisplayRole == role)
  {
    const PlanItem &planItem = m_internal->m_planStore[m_internal->m_planOrder.at(index.row())];
    switch (static_cast<ColumnSection>(index.column()))
    {
    case ColumnSection::OrderButtons:
      return QString();
    case ColumnSection::PlanName:
      return planItem.m_fileName;
    case ColumnSection::MinScale:
      return (planItem.m_minScale > 0) ? QStringLiteral("1:%1").arg(planItem.m_minScale) : tr("undefined");
    case ColumnSection::MaxScale:
      return (planItem.m_maxScale > 0) ? QStringLiteral("1:%1").arg(planItem.m_maxScale) : tr("undefined");
    case ColumnSection::Opacity:
      return planItem.m_opacity;
    case ColumnSection::CustomSection:
      return QString();
    case ColumnSection::ExerciseId:
      return planItem.m_exerciseId > 0 ? QVariant(planItem.m_exerciseId) : QVariant();
    case ColumnSection::PhaseId:
      return planItem.m_phaseId > 0 ? QVariant(planItem.m_phaseId) : QVariant();
    }
  }

  return QVariant();

} // QVariant PlanOverlayModel::data( const QModelIndex & index, int role ) const


QStringList PlanOverlayModel::mimeTypes() const
{
  QStringList typeList;
  typeList << REORDER_MIMETYPE;
  if (!m_internal->m_fileDialogMimeType.isEmpty())
    typeList << m_internal->m_fileDialogMimeType;
  return typeList;
} //  QStringList PlanOverlayModel::mimeTypes() const


void PlanOverlayModel::setFileDialogMimeType(const QString &mimeType)
{
  m_internal->m_fileDialogMimeType = mimeType;
} // void PlanOverlayModel::setFileDialogMimeType( const QString & mimeType )


QMimeData *PlanOverlayModel::mimeData(const QModelIndexList &indexes) const
{
  if (indexes.isEmpty()) return nullptr;

  int          row         = indexes.first().row();
  unsigned int keyId       = m_internal->m_planOrder.at(row);
  QMimeData   *mimeData    = new QMimeData();
  QByteArray   encodedData;

  mimeData->setData(REORDER_MIMETYPE, encodedData.setNum(keyId));

  return mimeData;
} // QMimeData * PlanOverlayModel::mimeData( const QModelIndexList & indexes ) const


bool PlanOverlayModel::canDropMimeData(const QMimeData *data, Qt::DropAction, int row, int, const QModelIndex &) const
{
  if ((row >= 0) && (row < m_internal->m_planOrder.size()))
  {
    if (data->hasFormat(REORDER_MIMETYPE))
    {
      QByteArray   encodedData = data->data(REORDER_MIMETYPE);
      bool         ok          = false;
      unsigned int keyId       = encodedData.toUInt(&ok);

      if (ok) return (m_internal->m_planOrder.indexOf(keyId) != row);
    }

    if ((!m_internal->m_fileDialogMimeType.isEmpty()) && (data->hasFormat(m_internal->m_fileDialogMimeType)))
    {
      QByteArray   encodedData = data->data(m_internal->m_fileDialogMimeType);
      bool         ok          = false;
      int          keyId       = encodedData.toUInt(&ok);

      if (ok) return (keyId > 0);
    }
  }
  return false;
} // bool PlanOverlayModel::canDropMimeData( const QMimeData * data, Qt::DropAction, int, int, const QModelIndex & ) const


bool PlanOverlayModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
  if (!canDropMimeData(data, action, row, column, parent)) return false;

  if (action == Qt::IgnoreAction) return true;

  emit dropPlanAccepted();

  if (data->hasFormat(REORDER_MIMETYPE))
  {
    QByteArray   encodedData = data->data(REORDER_MIMETYPE);
    bool         ok          = false;
    int          keyId       = encodedData.toInt(&ok);

    if (!ok) return false;

    int rowToMove = m_internal->m_planOrder.indexOf(keyId);

    if (row != rowToMove)
    {
      if (row < rowToMove)
      {
        for (; row <= rowToMove; ++row)
        {
          unsigned int idSwap = m_internal->m_planOrder[row];
          m_internal->m_planOrder[row] = keyId;
          keyId = idSwap;
        }
      }
      else
      {
        for (--row; row >= rowToMove; --row)
        {
          unsigned int idSwap = m_internal->m_planOrder[row];
          m_internal->m_planOrder[row] = keyId;
          keyId = idSwap;
        }
      }
      emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
      emit layoutChanged();
      emit planOrderChanged(m_internal->m_planOrder);
    }
    return true;
  }

  if ((!m_internal->m_fileDialogMimeType.isEmpty()) && (data->hasFormat(m_internal->m_fileDialogMimeType)))
  {
    QByteArray   encodedData = data->data(m_internal->m_fileDialogMimeType);
    bool         ok          = false;
    int          fileId      = encodedData.toInt(&ok);

    if ((ok) && (fileId > 0))
    {
      emit requestLoadPlan(fileId);

      // so the plan is now loaded at end of overlay list, move it a the right position

      int rowToMove = m_internal->m_planOrder.size() - 1;
      int keyId     = m_internal->m_planOrder[rowToMove];

      if (row != rowToMove)
      {
        for (; row <= rowToMove; ++row)
          keyId = doExchange(m_internal->m_planOrder[row], keyId);
        emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
        emit layoutChanged();
        emit planOrderChanged(m_internal->m_planOrder);
      }
      return true;
    }
  }
  return false;
}


QJsonArray PlanOverlayModel::toJson() const
{
  QJsonArray result;

  if (m_internal->m_planStore.count() != m_internal->m_planOrder.count())
  {
    Q_ASSERT(m_internal->m_planStore.count() == m_internal->m_planOrder.count());
    return result;
  }

  // save in reverse order, because loadPlan appends plans instead of prepending
  for (int i = m_internal->m_planStore.count() - 1; i >= 0; i--)
  {
    PlanItem planItem = m_internal->m_planStore[m_internal->m_planOrder.at(i)];
    result += planItem.toJson();
  }

  return result;
}


PlanOverlayModel::PlanItem PlanOverlayModel::planItem(int keyId)
{
  if (keyId < 1)
  {
    static int nextKey = 1;

    keyId = nextKey++;
  }

  PlanItem &planItem = m_internal->m_planStore[keyId];
  planItem.m_keyId = keyId;
  return planItem;
}


PlanOverlayModel::PlanItem &PlanOverlayModel::planItemRef(int keyId)
{
  return m_internal->m_planStore[keyId];
}


PlanOverlayModel::PlanItem  PlanOverlayModel::planItemValue(int keyId)
{
  QMap<unsigned int, PlanOverlayModel::PlanItem>::Iterator found = m_internal->m_planStore.find(keyId);

  return (found == m_internal->m_planStore.end()) ? PlanItem() : found.value();
}


PlanOverlayModel::PlanItem PlanOverlayModel::planItemAtRow(int row)
{
  if ((row < 0) || (row >= m_internal->m_planOrder.size())) return PlanItem();
  unsigned int planKeyId = m_internal->m_planOrder.at(row);
  return m_internal->m_planStore[planKeyId];
}


PlanOverlayModel::PlanItem PlanOverlayModel::findPlanItemByFileId(int fileId)
{
  if (fileId < 1)
    return PlanItem();

  QMap<unsigned int, PlanOverlayModel::PlanItem>::const_iterator it;
  for (it = m_internal->m_planStore.constBegin(); it != m_internal->m_planStore.constEnd(); ++it)
  {
    if (it.value().m_fileId == fileId)
      return it.value();
  }

  return PlanItem();
}


Qt::ItemFlags PlanOverlayModel::flags(const QModelIndex &modelIndex) const
{
  Qt::ItemFlags flags = QAbstractItemModel::flags(modelIndex) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;

  switch (static_cast<ColumnSection>(modelIndex.column()))
  {
  case ColumnSection::OrderButtons:
  case ColumnSection::PlanName:
  case ColumnSection::MinScale:
  case ColumnSection::MaxScale:
  case ColumnSection::Opacity:
    flags |= Qt::ItemIsEditable;
    break;
  case ColumnSection::CustomSection:
  case ColumnSection::ExerciseId:
  case ColumnSection::PhaseId:
    break;
  }

  return flags;
} // Qt::ItemFlags PlanOverlayModel::flags( const QModelIndex & modelIndex ) const


void PlanOverlayModel::updatePlanItem(const PlanItem &planItem)
{
  if (!planItem.isValid())
  {
    ERROR_LOG(m_logger) << "planItem has invalid key";
    return;
  }

  m_internal->m_planStore[planItem.m_keyId] = planItem;

  beginResetModel();
  {
    if (!m_internal->m_planOrder.contains(planItem.m_keyId))
      m_internal->m_planOrder.prepend(planItem.m_keyId);
  }
  endResetModel();

  int row = m_internal->m_planOrder.size() - 1;
  emit dataChanged(index(row, 0, QModelIndex()), index(row, columnCount(QModelIndex()) - 1, QModelIndex()));
  emit layoutChanged();
} //  void PlanOverlayModel::updatePlanItem(PlanItem & planItem)


void PlanOverlayModel::swapRow(int row1, int row2)
{
  if (row1 < 0) return;
  if (row2 < 0) return;
  if (row1 >= m_internal->m_planOrder.size()) return;
  if (row2 >= m_internal->m_planOrder.size()) return;

  m_internal->m_planOrder[row2] = doExchange(m_internal->m_planOrder[row1], m_internal->m_planOrder[row2]);

  QModelIndex topLeftIndex;
  QModelIndex bottomRightIndex;

  if (row1 < row2)
  {
    topLeftIndex = createIndex(row1, 0);
    bottomRightIndex = createIndex(row2, columnCount(QModelIndex()) - 1);
  }
  else
  {
    topLeftIndex = createIndex(row2, 0);
    bottomRightIndex = createIndex(row1, columnCount(QModelIndex()) - 1);
  }

  emit dataChanged(topLeftIndex, bottomRightIndex);
  emit planOrderChanged(m_internal->m_planOrder);

} // void PlanOverlayModel::swapRow(int row1, int row2)


int PlanOverlayModel::getRowOfId(int keyId) const
{
  return m_internal->m_planOrder.indexOf(keyId);
} // PlanOverlayModel::getRowOfId( int id )


void PlanOverlayModel::setMinScale(int row, double scale)
{
  if (row < 0)                               return;
  if (row >= m_internal->m_planOrder.size()) return;

  const int id = m_internal->m_planOrder[row];

  planItemRef(id).m_minScale = scale;

  emit planMinScaleChanged(id, scale);

  const QModelIndex &modelIndex = createIndex(row, int(ColumnSection::MinScale));
  emit dataChanged(modelIndex, modelIndex);
} // void PlanOverlayModel::setMinScale( int row, double scale )


void PlanOverlayModel::setMaxScale(int row, double scale)
{
  if (row < 0)                               return;
  if (row >= m_internal->m_planOrder.size()) return;

  const int id = m_internal->m_planOrder[row];

  planItemRef(id).m_maxScale = scale;

  emit planMaxScaleChanged(id, scale);

  const QModelIndex &modelIndex = createIndex(row, int(ColumnSection::MaxScale));
  emit dataChanged(modelIndex, modelIndex);
} // void PlanOverlayModel::setMaxScale( int row, double scale )


void PlanOverlayModel::setOpacity(int row, double opacity)
{
  if (row < 0)                               return;
  if (row >= m_internal->m_planOrder.size()) return;

  if (opacity < 0) opacity = 0.0;
  if (opacity > 1) opacity = 1.0;

  const int id = m_internal->m_planOrder[row];

  planItemRef(id).m_opacity = opacity;

  emit planOpacityChanged(id, opacity);

  const QModelIndex &modelIndex = createIndex(row, int(ColumnSection::Opacity));
  emit dataChanged(modelIndex, modelIndex);
} // void PlanOverlayModel::setAlpha( int row, double alpha )


void PlanOverlayModel::updateOverlay(int keyId)
{
  // keep in mimd fileId is same as planId here
  int row = m_internal->m_planOrder.indexOf(keyId);

  if (row < 0)                               return;
  if (row >= m_internal->m_planOrder.size()) return;

  emit dataChanged(createIndex(row, 0), createIndex(row, columnCount(QModelIndex()) - 1));
  emit requestUpdatePlan(keyId);

} // void PlanOverlayModel::updateOverlay(int fileId)


void PlanOverlayModel::renewPlanItem(const PlanItem &planItem)
{
  int row = m_internal->m_planOrder.indexOf(planItem.m_keyId);

  if (row < 0)                               return;
  if (row >= m_internal->m_planOrder.size()) return;

  m_internal->m_planStore[planItem.m_keyId] = planItem;
  emit dataChanged(createIndex(row, 0), createIndex(row, columnCount(QModelIndex()) - 1));

} // void PlanOverlayModel::renewPlanItem( const PlanItem & planItem )


void PlanOverlayModel::removeOverlay(int keyId)
{
  int row = m_internal->m_planOrder.indexOf(keyId);

  if (row < 0)                               return;
  if (row >= m_internal->m_planOrder.size()) return;

  emit requestRemovePlan(keyId); // Important: remove first from situation map and there for we need information from model entry

  beginResetModel();
  {
    m_internal->m_planStore.remove(keyId);
    m_internal->m_planOrder.remove(row);
  }
  endResetModel();



  emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
  emit layoutChanged();

} // void PlanOverlayModel::removeOverlay( int keyId )


bool PlanOverlayModel::reInitModel(int exerciseId, int phaseId)
{
  DEBUG_LOG(m_logger) << "ReInit Model for exerciseId = " << exerciseId << ", phaseId = " << phaseId;

  if ((exerciseId < 1) || (phaseId < 1))
  {
    // what's to do here??
    WARNING_LOG(m_logger) << LOGFUNCTION << " has been called with undefined exercise and/or phaseId";
    return false;
  }

  QVector<int> removeList;

  removeList.reserve(m_internal->m_planOrder.size());

  QMap<unsigned int, PlanOverlayModel::PlanItem>::const_iterator it;
  for (it = m_internal->m_planStore.constBegin(); it != m_internal->m_planStore.constEnd(); ++it)
  {
    int planExId = it.value().m_exerciseId;
    int planPhId = it.value().m_phaseId;

    DEBUG_LOG(m_logger) << "Plan name = " << it.value().m_fileName << " exercise = " << planExId << " phase = " << planPhId;

    if ((planExId < 1) || (planPhId < 1) || ((planExId == exerciseId) && (planPhId == phaseId)))
    {
      // nothing to do, exercise and phase did not change or it is a global or user plan
      continue;
    }

    bool removeFromModel(false);

    emit requestReloadPlanByName(it.value(), exerciseId, phaseId, &removeFromModel);

    if (removeFromModel) removeList << it.value().m_keyId;
  } // for m_planOder

  // remove all plans which doesn't exist any more from model
  for (auto id : qAsConst(removeList))  removeOverlay(id);

  emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
  emit layoutChanged();

  return true;
} // void PlanOverlayModel::reInitModel(int exerciseId, int phaseId)


void PlanOverlayModel::updateOrderOfPlans() const
{
  emit const_cast<PlanOverlayModel *>(this)->planOrderChanged(m_internal->m_planOrder);
} // void PlanOverlayModel::updateOrderOfPlans() const


} // namespace PlanOverlaysPlugin