/**
  * @RDE_HEADER@
  * HMI Plugin for EffectShowManagement - Effect Show Overview Dialog Model
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Patric Karwat, SLSE, 2016-10.05
  */

#include "esc_order_model.h"
#include <EffectShowManagement/esm_translation.h>
#include <LtsCoordTrans/lts_coord_trans.h>
#include <ngltools/ngltools_dtg.h>
#include <sstream>

namespace EffectShowClient
{
//---------------------------------
// Vehicle OrderModel
//---------------------------------
OrderModel::OrderModel(QObject *parent)
  : LtsWidgets::LtsAbstractTableModel<EffectShowClient::Order>(
{
  tr("Id"),
  tr("Type"),
  tr("Info"),
  tr("Status"),
  tr("Time"),
  tr("Duration"),
  tr("Distance [m]"),
  tr("Position"),
  tr("Area"),
  tr("Rotation"),
  tr("Volley"),
  tr("Shots In Total")
},
parent)
, m_logger(getLogger("OrderModel"))
{}

//=============================================================================
bool OrderModel::initModel(const std::shared_ptr<EffectShowClient::Interface::Dtc> &dtc,
                           const std::shared_ptr<TrainingAreaBaseOC::Interface::Dtc> &dtcTabOC,
                           bool isEffectShow)
{
  m_dtc    = dtc;
  m_dtcTabOC = dtcTabOC;
  m_isEffectShow = isEffectShow;
  connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::orderChanged,
          this, &OrderModel::onDataChanged);

  // insert Model
  const QMap<qint32, EffectShowClient::Order> &orderMap = m_dtc->orders();
  for (const auto &order : orderMap)
  {
    if (order.typeOfOrder() == m_isEffectShow) //
      insertRow(order);
  }

  //rename Info
  if (m_isEffectShow)
    m_vecColumns.replace(OrderModel::Info, tr("Effect Simulation"));

  if (m_dtcTabOC)
  {
    connect(m_dtcTabOC.get(), &TrainingAreaBaseOC::Interface::Dtc::ownPositionChanged,
            this, &OrderModel::onOwnPositionChanged);
    m_ownPosition = m_dtcTabOC->ownPosition(1);
  }

  return true;
}
//=============================================================================
QVariant OrderModel::data(const QModelIndex &index, int role) const
{
  if (role != Qt::DisplayRole || !indexIsValid(index))
    return QVariant();
  bool is_smoke = m_dtc.get()->operatingConditionEntity().vehicleFeature() == EffectShowManagement::Feature_e::Smoke;


  const EffectShowClient::Order &order = m_vecData.at(index.row());
  switch (index.column())
  {
  case Status:
    return EffectShowManagement::toString(order.orderConfirmation());
  case Id:
    return order.idOrder();
  case StartTime:
    return order.startTime().is_set() ? DTG::toStringMSec(order.startTime().get()) : tr("---");
  case Duration:
    return LtsWidgets::readableDuration(order.duration() * 1000);
  case Distance:
  {
    if (!m_dtcTabOC)
      return QVariant();

    int distance = qRound(LtsCoordTrans::distance(m_ownPosition.position().lon(), m_ownPosition.position().lat(),
                                                  order.position().lon(), order.position().lat()));
    return (distance / 10) * 10;
  }
  case Position:
  {
    const Core::GeoPosition2D &pos = order.position();
    return LtsCoordTrans::mgrsFromGeographic(pos.lon(), pos.lat());
  }
  case Area:
  {
    return tr("%1m x %2m", "Ausdehung: 5m x 6m").arg(order.areaWidth()).arg(order.areaDepth());
  }
  case Type:
  {
    if (order.typeOfOrder() == 0)
      return tr("Relocation Position");
    else if (is_smoke)
      return tr("Smoke");
    else
      return tr("Explosion");
  }
  case Rotation:
    if (is_smoke)
      return order.areaRotation();
    else
      return QStringLiteral("--");
  case Volley:
    if (is_smoke)
      return QStringLiteral("--");
    else
      return order.numOfVolley();
  case Info:
    return QString::fromStdString(order.info());
  case ShotsInTotal:
    if (is_smoke)
      return QStringLiteral("--");
    else
      return order.shotsPerVolley();

  }

  return QVariant();
}
//=============================================================================
QString OrderModel::timeOfDayString(int seconds)
{
  int hour = seconds / 3600;
  int hour_s = hour * 3600;
  int min  = (seconds - hour_s) / 60;
  int min_s = min * 60;
  int sec  = seconds - hour_s - min_s;

  std::stringstream sStrm;
  sStrm.fill('0');
  sStrm << std::setw(2) << hour << ':' << std::setw(2) << min << ':' << std::setw(2) << sec;
  return QString::fromStdString(sStrm.str());
}

bool OrderModel::onDataChanged(const Order &data, DataModification modType)
{
  if (modType == DataModification::eRemoved)
    return LtsAbstractTableModel::onDataChanged(data, modType);
  else if (data.typeOfOrder() == m_isEffectShow)
    return LtsAbstractTableModel::onDataChanged(data, modType);
  return false;
}

void OrderModel::onOwnPositionChanged(const TrainingAreaBaseOC::OwnPosition &data)
{
  if (m_ownPosition == data)
    return;
  m_ownPosition = data;
  for (int r = 0; r < m_vecData.size(); ++r)
  {
    const QModelIndex idx = index(r, Distance);
    emit dataChanged(idx, idx, {Qt::DisplayRole});
  }
}

//
// OrderProxyModel
//
void OrderProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
{
  m_sourceModel = qobject_cast<OrderModel *>(sourceModel);
  LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
}

bool OrderProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
{
  if (!m_sourceModel ||
      source_left.column() != source_right.column() ||
      !source_left.isValid() ||
      !source_right.isValid())
    return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
  const auto &dataLeft = m_sourceModel->m_vecData.at(source_left.row());
  const auto dataRight = m_sourceModel->m_vecData.at(source_right.row());
  switch (source_left.column())
  {
  case OrderModel::StartTime:
    if (dataLeft.startTime().is_set() && dataRight.startTime().is_set())
      return dataLeft.startTime().get() < dataRight.startTime().get();
    if (dataRight.startTime().is_set())
      return true;
    if (dataLeft.startTime().is_set())
      return false;
    return dataLeft.id() < dataRight.id();
  case OrderModel::Status:
  case OrderModel::Id:
  case OrderModel::Duration:
  case OrderModel::Distance:
  case OrderModel::Position:
  case OrderModel::Area:
  case OrderModel::Volley:
  case OrderModel::ShotsInTotal:
    break;
  }
  return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
}

} // namespace EffectShowClient