/**
  * @RDE_HEADER@
  * OperatorSettingsObserver
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Fröbel, NLSE, 2018-04-10
  */

#include "operator_settings_observer.h"
#include <LtsUtilsCore/data_modification_enum.h>
#include <LtsUtilsSettings/settings.h>
#include <ExerciseManagement/exm_dtc.h>
#include <ExerciseManagement/exm.hpp>
#include <OperatorManagement/opm_dtc.h>
#include <OperatorManagement/opm.hpp>
#include <QtGlobal>

namespace AudioVideoManagement
{

/**
 * Small helper class that calculates the timezone for the current operator
 * based on the operator's settings and the default timezone for the exercise.
 */
class OperatorSettingsObserver::TimezoneCalculator : public QObject
{
  Q_OBJECT

public:
  void setDefaultTimezone(QChar timezone)
  {
    Q_ASSERT(!timezone.isNull());
    if (timezone == m_defaultTimezone)
      return;
    m_defaultTimezone = timezone;
    calculateTimezone();
  }

  void setOperatorTimezone(QChar timezone)
  {
    Q_ASSERT(!timezone.isNull());
    if (timezone == m_operatorTimezone)
      return;
    m_operatorTimezone = timezone;
    calculateTimezone();
  }

  void unsetOperatorTimezone()
  {
    if (!m_operatorTimezone)
      return;
    m_operatorTimezone.reset();
    calculateTimezone();
  }

  QChar timezone() const { return m_calculatedTimezone; }

signals:
  void timezoneChanged(QChar newTimezone);

private:
  void calculateTimezone()
  {
    QChar   calculated = m_operatorTimezone.get_value_or(m_defaultTimezone);
    if (calculated == m_calculatedTimezone)
      return;
    m_calculatedTimezone = calculated;
    emit timezoneChanged(calculated);
  }

  QChar                    m_defaultTimezone = QLatin1Char('Z');
  boost::optional<QChar>   m_operatorTimezone;
  QChar                    m_calculatedTimezone = m_defaultTimezone;
};


OperatorSettingsObserver::OperatorSettingsObserver(int exerciseId, int operatorId, OperatorManagement::Interface::Dtc *opmDtc, ExerciseManagement::Interface::Dtc *exmDtc)
  : m_exerciseId(exerciseId)
  , m_operatorId(operatorId)
  , m_opmDtc(opmDtc)
  , m_exmDtc(exmDtc)
  , m_operatorSettings(LtsUtils::OperatorSettings::getInstance())
  , m_timezoneCalculator(new TimezoneCalculator)
{
  Q_ASSERT(operatorId > 0);
  Q_ASSERT(opmDtc);
  Q_ASSERT(exmDtc);
  
  OperatorManagement::User   operator_ = m_opmDtc->user(operatorId);
  if (operator_.id() == operatorId)
    m_currentPrio = operator_.audioChannelPriority();

  ExerciseManagement::Exercise   exercise = m_exmDtc->exercise(exerciseId);
  if (exercise.id() == exerciseId)
    m_timezoneCalculator->setDefaultTimezone(QChar::fromLatin1(exercise.defaultTimeZone()));
  
  connect(opmDtc, &OperatorManagement::Interface::Dtc::userChanged, this, &OperatorSettingsObserver::onOperatorChanged);
  connect(exmDtc, &ExerciseManagement::Interface::Dtc::exerciseChanged, this, &OperatorSettingsObserver::onExerciseChanged);
  connect(m_operatorSettings, &LtsUtils::OperatorSettings::valueChanged, this, &OperatorSettingsObserver::onSettingsValueChanged);
  connect(m_timezoneCalculator.get(), &TimezoneCalculator::timezoneChanged, this, &OperatorSettingsObserver::timezoneChanged); // signal -> signal
}

QChar OperatorSettingsObserver::timezone() const
{
  return m_timezoneCalculator->timezone();
}

OperatorSettingsObserver::~OperatorSettingsObserver() = default;

void OperatorSettingsObserver::onOperatorChanged(const OperatorManagement::User &operator_, DataModification modType)
{
  switch (modType)
  {
  case DataModification::eAdded:
    return;

  case DataModification::eModified:
  {
    if (operator_.id() != m_operatorId)
      return;
    
    AvaAudioPrio   prio = operator_.audioChannelPriority();
    if (prio == m_currentPrio)
      return;
    
    m_currentPrio = prio;
    emit audioPrioChanged(prio);
    return;
  }
  
  case DataModification::eRemoved:
    return;
  
  default:
    Q_ASSERT(false);
  }
}

void OperatorSettingsObserver::onExerciseChanged(const ExerciseManagement::Exercise &exercise, DataModification modType)
{
  if (exercise.id() != m_exerciseId)
    return;

  switch (modType)
  {
  case DataModification::eModified:
    m_timezoneCalculator->setDefaultTimezone(QChar::fromLatin1(exercise.defaultTimeZone()));
    break;

  default:
    break;
  }
}

void OperatorSettingsObserver::onSettingsValueChanged(const QString &group, const QString &identifier, const QVariant &value)
{
  static const QString   timeSettingsGroup = QStringLiteral("TimeSettings");
  static const QString   timezoneId        = QStringLiteral("TimeZone");

  if (group != timeSettingsGroup)
    return;
  if (identifier != timezoneId)
    return;

  QChar   timezone = value.toChar();
  if (timezone.isNull())
    m_timezoneCalculator->unsetOperatorTimezone();
  else
    m_timezoneCalculator->setOperatorTimezone(timezone);
}

} // namespace AudioVideoManagement

#include "operator_settings_observer.moc"