/**
  * Exercise object
  * $Id$
  * $HeadURL$
  * $Author$
  */
#pragma once

#include <QObject>
#include "dds_handler.h"
#include <DDS/Core/function_reply_object.h>

// Generated
#include <ExerciseManagement/exm_db.h>

namespace DBAdministration
{
class CopyExercise;
class ExerciseTableGenerator;
}
namespace ExerciseManagement
{
  class DatabaseInterface;
  class ExerciseStateMachine;
  class HandlerExercise;

  class ObjectExercise final : public QObject
  {
      Q_OBJECT
    public:
      explicit ObjectExercise(const std::shared_ptr<DdsHandler> &ddsHandler,
                              const std::shared_ptr<DatabaseInterface> &db,
                              const std::shared_ptr<DBAdministration::ExerciseTableGenerator> &exTblGen,
                              HandlerExercise *exHandler);
      ~ObjectExercise();

      Core::FunctionReplyObject createObject(const Database::ExmExercise &data, bool forceInsert = false);
      Core::FunctionReplyObject updateObject(const Database::ExmExercise &data);
      Core::FunctionReplyObject removeObject(bool force);
      bool setLinkedExerciseId(int newLinkedExerciseId);
      bool setSendToWms(bool bSend);
      void initStateMachine();

      qint32 id() const { return m_data.id; }
      ExerciseState exerciseState() const { return m_data.exerciseStateId; }
      int linkedExerciseId() const { return m_data.linkedExerciseId; }
      QString name() const { return m_data.name; }
      bool sendToWms() const { return m_data.sendToWms; }
      // for updating (when part of the data is changed)
      const Database::ExmExercise &data() const { return m_data; }

      // Used for Unittest (getting the signals)
      ExerciseStateMachine* getStateMachine() { return m_stateMachine; }

      // Used by ExerciseStateManager (only internal)
      bool setExerciseState(const ExerciseState &exerciseState);

      // Used by Client
      Core::FunctionReplyObject switchToState(const ExerciseState &newExerciseState, int operatorId, int workstationId);

      // TODO: implement
      bool isEditable() const{ return true; }
      bool isValid() const;
      bool isRunning() const;
      bool isStopped() const;

      bool sendStateToServiceManagement(ExerciseState state);
      bool transferExerciseToEvaluationDb();

  private:
      void onPublishData();
      void fixupTimeZone();
      void onErrorOccured();
      void onTransferDbFinished();

    private:
      std::shared_ptr<DdsHandler>    m_ddsHandler;
      std::shared_ptr<DatabaseInterface>      m_db;
      const std::shared_ptr<DBAdministration::ExerciseTableGenerator> m_exTblGen;
      Database::ExmExercise          m_data;
      ExerciseStateMachine          *m_stateMachine;
      HandlerExercise               *m_exerciseHandler;
      DBAdministration::CopyExercise *m_copyExercise;
      NGL::INGLLogger               &m_logger;

  };
}