/**
  * @RDE_HEADER@
  * HMI Plugin for AlarmManagement - AlarmManagement Model
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Patric Karwat, SLSE, 2016-10.05
  */

#include "alm_config_alarm_model.h"
#include <AlarmManagement/alm_translation.h>
#include <LtsSession/lts_session_data.h>
#include <ProjectDataManagement/pdm_to_string.h>

namespace AlarmManagement
{
//---------------------------------
// AlarmManagementModel
//---------------------------------
ConfigAlarmModel::ConfigAlarmModel(QObject *parent)
  : LtsWidgets::LtsAbstractTableModel<AlarmManagement::AlarmConfig>(
{
  tr("Id"),
  tr("Equip. No."),
  tr("Designator"),
  tr("Tact. Identifier"),
  tr("Vulnerability State"),
  tr("Event Type"),
  tr("Message Window"),
  tr("Set Marker")
},
parent)
  , m_dtc(nullptr)
  , m_ppmDtc(nullptr)
  , m_alarmHistoryModel(nullptr)
  , m_global(false)
  , m_logger(getLogger("ConfigAlarmModel"))
{}


bool ConfigAlarmModel::initModel(const std::shared_ptr<AlarmManagement::Interface::Dtc> &dtc,
                                 const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
                                 AlarmHistoryModel *alarmHistoryModel,
                                 bool global)
{
  m_dtc = dtc;
  m_ppmDtc = ppmDtc;
  m_alarmHistoryModel = alarmHistoryModel;
  m_global = global;

  // insert Model
  const QMap<qint32, AlarmManagement::AlarmConfig> alarmConfigs = m_dtc->alarmConfigs();
  INFO_LOG(m_logger) << "initModel - #AlarmConfig: " << alarmConfigs.size();

  connect(m_dtc.get(), &Interface::Dtc::alarmConfigChanged,
          this, &ConfigAlarmModel::onAlarmConfigChanged);

  m_dtc->enableAlarmConfig();
  auto cb = [this] (const AlarmManagement::AlarmConfig &d)
  {
    onAlarmConfigChanged(d, DataModification::eAdded);
  };
  m_dtc->alarmConfigs(cb);
  return true;
}

QVariant ConfigAlarmModel::data(const QModelIndex &index, int role) const
{
  DEBUG_LOG(m_logger) << "AlarmManagementModel::data";

  if (role != Qt::DisplayRole || !indexIsValid(index))
    return QVariant();

  const AlarmManagement::AlarmConfig &alarmConfig = m_vecData.at(index.row());
  if (alarmConfig.global() != m_global)
    return QVariant();

  switch (index.column())
  {
  case Id:
    return alarmConfig.id();
  case EquipmentNumber:
  {
    const int equipmentNumber = m_alarmHistoryModel->participantId2EquipNo(alarmConfig.participantId());
    if (equipmentNumber == 0)
      return tr("All");
    return equipmentNumber;
  }
  case Designator:
    return m_alarmHistoryModel->getDesignator(alarmConfig.participantId());
  case TactIdentifier:
    return m_alarmHistoryModel->getTactIdentifier(alarmConfig.participantId());
  case VulnerabilityState:
  {
    QString vulnerabilityState = tr("All Types");
    if (alarmConfig.vulnerabilityState()>=0){
      ParticipantManagement::TypeClass typeClass =
          m_ppmDtc->type(m_ppmDtc->participant(alarmConfig.participantId()).typeId()).typeClass();

      const ProjectDataManagement::VulnerabilityClass vc = typeClass == ParticipantManagement::TypeClass::Human ?
            ProjectDataManagement::VulnerabilityClass_def::SoldierInjuries :
            ProjectDataManagement::VulnerabilityClass_def::VehicleDamages;
      ProjectDataManagement::VulnerabilityState vs = static_cast<ProjectDataManagement::VulnerabilityState_def::type>(alarmConfig.vulnerabilityState());
      vulnerabilityState = ProjectDataManagement::toString(vs, vc);
    }
    return vulnerabilityState;
  }

  case EventType:
    return ProjectDataManagement::toString(alarmConfig.eventTypeId());
  case MessageWindow:
    return alarmConfig.messageWindow() ? tr("Yes") : tr("No");
  case SetMarker:
    return alarmConfig.setMarker() ? tr("Yes") : tr("No");
  }

  return QVariant();
}


void ConfigAlarmModel::onAlarmConfigChanged(const AlarmManagement::AlarmConfig &data,
                                            const DataModification modType)
{
  const int id = data.id();
  if (data.global() != m_global)
    return;

  int row = findRowForId(id);

  const int eventTypeId = data.eventTypeId().underlying();
  const bool messageWindow = data.messageWindow();
  const bool setMarker = data.setMarker();
  DEBUG_LOG(m_logger) << "onAlarmConfigChanged: " << eventTypeId << " messageWindow=" << messageWindow
                      << "setMarker"<<setMarker;

  switch (modType)
  {
  case DataModification::eRemoved:
  {
    // removed
    DEBUG_LOG(m_logger) << "AlarmConfig was removed: " << id;
    AlarmManagement::AlarmConfig data1 = data;
    data1.messageWindow(false);
    data1.setMarker(false);
    setRowData(row, data1);
    removeRow(row);
    return;
  }
  case DataModification::eModified:
  {
    DEBUG_LOG(m_logger) << "DataModification::eModified: ";
    if (row < 0)
    {
      // created
      return;
    }
    if (m_alarmHistoryModel->participantId2EquipNo(data.participantId()) > 0)
      setRowData(row, data);
    break;
  }
  case DataModification::eAdded:
  {
    DEBUG_LOG(m_logger) << "DataModification::eAdded";
    insertRow(data);
  }
  break;
  }

}

} // namespace AlarmManagement