/**
  * @RDE_HEADER@
  * Evaluations - Criterium Create / Edit Dialog
  * $Id$
  * $HeadURL$
  * $Author$
  *
  * Created by Hanna E. Rathje, SLSE, 2017-11-01
  */

#include "evl_edit_element_dialog.h"
#include "ui_evl_edit_element_dialog.h"

#include <LtsSession/lts_session.h>
#include <LtsSession/lts_session_data.h>
#include <LtsWidgets/lts_base_layout_widget.h>
#include <Evaluations/evl_translation.h>
#include <ngltools/ngltools_dtg.h>

#include <AudioVideoManagement/ava_state.h>
#include <AudioVideoManagement/stream_name_mapping.h>
#include <FilterManagement/flt_data_plugin_aes_display_filter.h>
#include <FilterManagement/flt_symbol_appearance_settings.h>
#include <FilterManagement/flt_building_cmpnt_settings.h>
#include <PluginInterfaces/gui_plugin_interface.h>
#include <SituationMapPlugin/situation_map_gui_plugin_interface.h>

#include <QDateTime>
#include <QJsonObject>
#include <QJsonDocument>


namespace Evaluations
{
ElementEditDialog::ElementEditDialog(QWidget *)
  : LtsWidgets::LtsDialog(nullptr, LtsWidgets::ButtonCombination::OkCancel)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_ui(new Ui::ElementEditDialog)
  , m_logger(getLogger("ElementEditDialog"))
{
  DEBUG_LOG(m_logger) << "ElementEditDialog ctor";

  m_ui->setupUi(this);

  connect(m_ui->cbSituation, &QCheckBox::clicked, this, &ElementEditDialog::onCheckBoxClicked);
  connect(m_ui->cbVideo, &QCheckBox::clicked, this, &ElementEditDialog::onCheckBoxClicked);
  connect(m_ui->cbAudio, &QCheckBox::clicked, this, &ElementEditDialog::onCheckBoxClicked);

  connect(m_ui->cbVideo, &QCheckBox::stateChanged, this, &ElementEditDialog::onVideoClicked);
  connect(m_ui->cbAudio, &QCheckBox::stateChanged, this, &ElementEditDialog::onAudioClicked);

  m_uiRequirements->addRequirement({m_ui->lblMedium, [this]() { return m_ui->cbSituation->isChecked() ||
                                                                (m_ui->cbAudio->isChecked() && !m_audioStreams.isEmpty()) ||
                                                                (m_ui->cbVideo->isChecked() && !m_videoStreams.isEmpty()); },
                                   tr("Select one or more media. If you have selected audio or video, make sure that a audio / video stream has been selected.") });
}


ElementEditDialog::~ElementEditDialog()
{
  delete m_ui;
}


void ElementEditDialog::retranslate()
{
  translate(m_ui, m_dtc->evaluationCriterium(m_criteriumId), tr("Criterium Element"));
}


bool ElementEditDialog::init(int elementId,
                             int criteriumId,
                             int exerciseId,
                             const std::shared_ptr<Interface::Dtc> &dtc,
                             const std::shared_ptr<Interface::Ftc> &ftc,
                             const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc,
                             const std::shared_ptr<AudioVideoManagement::ForeignDataInterface> &avmDataIfc,
                             const std::shared_ptr<FilterManagement::ForeignFltParticipantGuiInterface> &fltParticipantIfc,
                             const std::shared_ptr<FilterManagement::ForeignAesGuiInterface> &fltAesIfc,
                             const std::shared_ptr<FilterManagement::ForeignFltBuildingComponentGuiInterface> &fltBuildingComponentIfc,
                             LtsSession::LtsSession *session)
{
  DEBUG_LOG(m_logger) << "ElementEditDialog::init";
  m_elementId = elementId;
  m_criteriumId = criteriumId;
  m_exerciseId = exerciseId;
  m_dtc = dtc;
  m_ftc = ftc;
  m_exmDtc = exmDtc;
  m_avmDataIfc = avmDataIfc;
  m_fltParticipantIfc       = fltParticipantIfc;
  m_fltAesIfc               = fltAesIfc;
  m_fltBuildingComponentIfc = fltBuildingComponentIfc;
  m_session = session;

  for (int i = 1; i <= 10; ++i)
    m_ui->cbxRating->addItem(QString::number(i), i);

  fillPhasesComboBox();

  if (m_elementId > 0) //edit
  {
    Evaluations::EvaluationElement eval = m_dtc->evaluationElement(m_elementId);
    m_ui->cbxRating->setCurrentIndex(m_ui->cbxRating->findData(eval.rating()));
    m_ui->teDesc->setText(QString::fromStdString(eval.note()));
    m_ui->lblStartTime->setText(DTG::toStringMSec(eval.timestamp()));
    ERROR_LOG(m_logger) << "set start time label to " << m_ui->lblStartTime->text();
    m_startTime = eval.timestamp();

    m_ui->cbSituation->setChecked(eval.situation());
    m_ui->cbVideo->setChecked(eval.video());
    m_ui->cbAudio->setChecked(eval.audio());

    m_ui->cbxPhase->setCurrentIndex(m_ui->cbxPhase->findData(eval.phaseId()));
  }

  if (m_avmDataIfc && m_avmDataIfc->hasAvsSession())
  {
    onAudioClicked();
    onVideoClicked();
  }
  else
  {
    // Someone else has access to the AvaSession in a different exercise context -- or we don't even have the AVM-Plugin.
    // Disable all Video/Audio stuff
    m_ui->cbxVideoChannel->setEnabled(false);
    m_ui->cbxRadioCircuit->setEnabled(false);
  }

  if (m_avmDataIfc && m_avmDataIfc->hasAvsSession())
  {
    m_videoStreams = m_avmDataIfc->avaState()->currentLiveVideoStreams();

    if ( m_videoStreams.size() > 0 )
      m_ui->cbVideo->setEnabled( true );
    else
      m_ui->cbVideo->setEnabled( false );

    m_audioStreams = m_avmDataIfc->avaState()->getRtProfile();

    if ( m_audioStreams.size() > 0 )
      m_ui->cbAudio->setEnabled( true );
    else
      m_ui->cbAudio->setEnabled( false );
  }

  return true;
}


void ElementEditDialog::onReturnPressed()
{
//  if (m_ui->ltsDialogButtonBox->getButton(LtsWidgets::DialogButton::Add)->isEnabled())
//    m_ui->ltsDialogButtonBox->getButton(LtsWidgets::DialogButton::Add)->setFocus();
}


bool ElementEditDialog::apply()
{
  // prepare request
  EvlElementModifyRequest req;
  req.id(m_elementId);
  req.criteriumId(m_criteriumId);
  req.rating(m_ui->cbxRating->currentData().toInt());
  req.note(m_ui->teDesc->toPlainText().toStdString());
  req.timestamp(m_startTime);
  req.duration((QDateTime::currentMSecsSinceEpoch() - m_startTime) / 1000);
  req.phaseId(m_ui->cbxPhase->currentData().toInt());

  QJsonObject obj;
  if (m_ui->cbSituation->isChecked())
  {
    QJsonObject root;

    std::shared_ptr<SituationMap::ForeignGuiInterface> sitMapIfc;
    if (m_session->getForeignGuiInterface<SituationMap::ForeignGuiInterface>(sitMapIfc))
      root[QStringLiteral("settings")] = sitMapIfc->operatorMapSettings();
    else
      ERROR_LOG(m_logger) << "sit map ifc not available, can't save map settings :(";

    root[QStringLiteral("filters")] = getFilterSettings();

    req.situationContent().set(QJsonDocument(root).toJson().constData());
  }

  if (m_ui->cbVideo->isChecked() && m_ui->cbxVideoChannel->currentData().isValid())
  {
    obj[QStringLiteral("actualStream")] = QJsonValue(m_ui->cbxVideoChannel->currentData().toString());
    obj[QStringLiteral("allStreams")] = QJsonValue(QString(m_videoStreams.join(QStringLiteral(", "))));
    req.videoContent().set(QJsonDocument(obj).toJson().constData());
  }

  if (m_ui->cbAudio->isChecked() && !m_ui->cbxRadioCircuit->currentText().isNull())
  {
    obj[QStringLiteral("actualStream")] = QJsonValue(m_ui->cbxRadioCircuit->currentText());
    obj[QStringLiteral("allStreams")] = QJsonValue(QString(m_audioStreams.join(QStringLiteral(", "))));
    req.audioContent().set(QJsonDocument(obj).toJson().constData());
  }

  return m_requestHelper->startSingleRequest([this, req]()
  {
    return m_ftc->evlElementModifyRequest(req, this);
  });
}


void ElementEditDialog::fillPhasesComboBox()
{
  DEBUG_LOG(m_logger) << "fillPhasesComboBox";
  QSignalBlocker blocker(m_ui->cbxPhase);
  m_ui->cbxPhase->clear();
  m_ui->cbxPhase->addItem(tr("<not set>"), 0);

  auto cb = [this] (const ExerciseManagement::ExercisePhase &ph)
  {
    if (ph.exerciseId() == m_exerciseId)
      m_ui->cbxPhase->addItem(QString::fromStdString(ph.name()), ph.id());
  };
  m_exmDtc->exercisePhases(cb);

  if (m_session->exerciseData()->phId > 0)
    m_ui->cbxPhase->setCurrentIndex(m_ui->cbxPhase->findData(m_session->exerciseData()->phId));
}


void ElementEditDialog::onCheckBoxClicked()
{
  INFO_LOG(m_logger) << "onCheckBoxClicked";
  if (m_startTime > 0)
    return;

  m_startTime = QDateTime::currentMSecsSinceEpoch();
  m_ui->lblStartTime->setText(DTG::toStringMSec(m_startTime));
}


void ElementEditDialog::onAudioClicked()
{
  Q_ASSERT(m_avmDataIfc && m_avmDataIfc->hasAvsSession());
  if (!m_avmDataIfc)
    return;

  m_audioStreams = m_avmDataIfc->avaState()->getRtProfile();

  QString currentText;
  if (m_ui->cbxRadioCircuit->currentIndex() >= 0)
    currentText = m_ui->cbxRadioCircuit->currentText();

  m_ui->cbxRadioCircuit->clear();

  for (const QString &audioChannel : qAsConst(m_audioStreams))
    m_ui->cbxRadioCircuit->addItem(audioChannel);

  m_ui->cbxRadioCircuit->setCurrentIndex(0);

  int idx = m_ui->cbxRadioCircuit->findText(currentText);
  if (idx >= 0)
    m_ui->cbxRadioCircuit->setCurrentIndex(idx);

  if (m_ui->cbAudio->isChecked() && m_ui->cbxRadioCircuit->count() > 1)
    m_ui->cbxRadioCircuit->setEnabled(true);
  else
    m_ui->cbxRadioCircuit->setEnabled(false);
}


void ElementEditDialog::onVideoClicked()
{
  Q_ASSERT(m_avmDataIfc && m_avmDataIfc->hasAvsSession());
  if (!m_avmDataIfc)
    return;

  m_videoStreams = m_avmDataIfc->avaState()->currentLiveVideoStreams();

  QVariant   currentStream;
  if (m_ui->cbxVideoChannel->currentIndex() >= 0)
    currentStream = m_ui->cbxVideoChannel->currentData();

  m_ui->cbxVideoChannel->clear();

  for (const QString &streamName : qAsConst(m_videoStreams))
  {
    QString   displayName = m_avmDataIfc->streamNameMapping()->displayName(streamName);
    m_ui->cbxVideoChannel->addItem(displayName, streamName);
  }

  for (int i = 0; i < m_ui->cbxVideoChannel->count(); ++i)
  {
    if ( m_ui->cbxVideoChannel->itemData(i).toString() == currentStream)
    {
      m_ui->cbxVideoChannel->setCurrentIndex(i);
      break;
    }
  }

  if (m_ui->cbVideo->isChecked() && m_ui->cbxVideoChannel->count() > 1)
    m_ui->cbxVideoChannel->setEnabled(true);
  else
    m_ui->cbxVideoChannel->setEnabled(false);
}


QJsonObject ElementEditDialog::getFilterSettings()
{
  const int operatorId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
  QJsonObject jsonObj;

  {
    // AesFilter
    std::shared_ptr<FilterManagement::AesDisplayFilter> aesDisplayFilter =
      m_fltAesIfc->aesFilterForOperator(operatorId, QString());
    jsonObj[QStringLiteral("AesFilterJson")] = aesDisplayFilter->filterToJson();
  }

  {
    // SymbolAppearance
    std::shared_ptr<FilterManagement::SymbolAppearanceSettings> symbolAppearanceSettings =
      m_fltParticipantIfc->symbolAppearanceForOperator(operatorId, QString());
    jsonObj[QStringLiteral("SymbolAppearanceJson")] = symbolAppearanceSettings->settingsToJson();
  }

  // Nachtrag zu GUEZE-1769: since fltBuildingComponentIfc is optional:
  if (m_fltBuildingComponentIfc)
  {
    // BuildingComponentSettings
    std::shared_ptr<FilterManagement::BuildingComponentSettings> buildingComponentSettings =
      m_fltBuildingComponentIfc->buildingComponentSettingsForOperator(operatorId, QString());
    jsonObj[QStringLiteral("BuildingComponentSettingsJson")] = buildingComponentSettings->bldCmpSettingsToJson();
  }

//    qCritical() << " filter_param = " << filter_param.c_str();

  return jsonObj;
}
} // namespace Evaluations