/**
  * @RDE_HEADER@
  * Handler for all request journal objects
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Hanna E. Rathje, SLSE, 2015-01-13
  */

#include "handler_situation_replay_sqlite.h"
#include "object_situation_replay.h"
#include "db_reader.h"

namespace SituationReplay
{

HandlerSituationReplaySqlite::HandlerSituationReplaySqlite(const std::shared_ptr<DdsHandler> &ddsHandler,
                                                           const std::shared_ptr<DbReader> &dbReader)
  : m_objSrp(nullptr)
  , m_ddsHandler(ddsHandler)
  , m_dbReader(dbReader)
  , m_exerciseId(0)
  , m_partitionId(0)
  , m_beginTime(0)
  , m_endTime(0)
  , m_logger(getLogger("HandlerSituationReplaySqlite"))
{}

HandlerSituationReplaySqlite::~HandlerSituationReplaySqlite()
{
  delete m_objSrp;
}

bool HandlerSituationReplaySqlite::init(int exerciseId, int partitionId, qint64 beginTime, qint64 endTime)
{
  m_exerciseId  = exerciseId;
  m_partitionId = partitionId;
  m_beginTime = beginTime;
  m_endTime = endTime;

  Database::SrpSituationReplay newData;
  newData.srpStateId        = SrpState::Stopped;
  newData.replayPartitionId = m_partitionId;
  newData.beginTime         = m_beginTime;
  newData.endTime           = m_beginTime;  // for init
  newData.pace              = 0.0;

  createObject(newData);
  return true;
}

bool HandlerSituationReplaySqlite::createObject(const Database::SrpSituationReplay &newData)
{
  delete m_objSrp;
  m_objSrp = new ObjectSituationReplay(m_ddsHandler, nullptr, m_dbReader, m_exerciseId);
  Core::FunctionReplyObject ret = m_objSrp->createObject(newData);
  if (ret.error())
  {
    delete m_objSrp;
    m_objSrp = nullptr;
    ERROR_LOG(m_logger) << ret();
    return false;
  }
  connect(m_objSrp, &ObjectSituationReplay::replayTimeChanged, this, &HandlerSituationReplaySqlite::replayTimeChanged);
  connect(m_objSrp, &ObjectSituationReplay::started, this, &HandlerSituationReplaySqlite::started);
  connect(m_objSrp, &ObjectSituationReplay::paused, this, &HandlerSituationReplaySqlite::paused);
  connect(m_objSrp, &ObjectSituationReplay::resumed, this, &HandlerSituationReplaySqlite::resumed);
  connect(m_objSrp, &ObjectSituationReplay::stopped, this, &HandlerSituationReplaySqlite::stopped);
  return true;
}

bool HandlerSituationReplaySqlite::onStartReplayRequest(qint64 begin, qint64 end, double pace)
{
  DEBUG_LOG(m_logger) << "onStartReplayRequest: " << begin << ", " << end << ", " << pace;

  Database::SrpSituationReplay newData;
  newData.srpStateId        = SrpState::Started;
  newData.replayPartitionId = m_partitionId;
  newData.beginTime         = begin;
  newData.endTime           = end;
  newData.pace              = pace;

  if (!m_objSrp && !createObject(newData))
    return false;
  return m_objSrp->setSrpData(newData);
}

bool HandlerSituationReplaySqlite::onStopReplayRequest()
{
  DEBUG_LOG(m_logger) << "onStopReplayRequest";

  if (m_objSrp == nullptr)
  {
    ERROR_LOG(m_logger) << "onStopReplayRequest - internal error";
    return false;
  }

  Core::FunctionReplyObject ret = m_objSrp->switchToState(SrpState::Stopped);
  if (!ret.error())
    ret = m_objSrp->removeObject();

  if (ret.error())
    WARNING_LOG(m_logger) << ret();

  // remove all old data from DDS-Bus & clear maps
  m_dbReader->clearData();

  return true;
}

bool HandlerSituationReplaySqlite::onPauseReplayRequest()
{
  if (m_objSrp == nullptr)
  {
    ERROR_LOG(m_logger) << "onChangeReplayStateRequest - internal error";
    return false;
  }
  return onChangeReplayStateRequest(SrpState::Paused, m_objSrp->pace());
}

bool HandlerSituationReplaySqlite::onResumeReplayRequest()
{
  if (m_objSrp == nullptr)
  {
    ERROR_LOG(m_logger) << "onChangeReplayStateRequest - internal error";
    return false;
  }
  return onChangeReplayStateRequest(SrpState::Resumed, m_objSrp->pace());
}


bool HandlerSituationReplaySqlite::onChangeReplayStateRequest(const SituationReplay::SrpState &newState, double newPace)
{
  DEBUG_LOG(m_logger) << "onChangeReplayStateRequest: " << newState << ", " << newPace;

  if (m_objSrp == nullptr)
  {
    ERROR_LOG(m_logger) << "onChangeReplayStateRequest - internal error";
    return false;
  }

  if (newState != SrpState::Resumed && newState != SrpState::Paused)
  {
    ERROR_LOG(m_logger) << "onChangeReplayStateRequest: SrpStateChange not possible, only resumed & paused allowed";
    return false;
  }

  m_objSrp->setPace(newPace);
  const Core::FunctionReplyObject ret = m_objSrp->switchToState(newState);

  if (ret.error())
    WARNING_LOG(m_logger) << ret();

  return !ret.error();
}

bool HandlerSituationReplaySqlite::onPaceChangeRequest(double newPace)
{
  if (m_objSrp == nullptr)
  {
    ERROR_LOG(m_logger) << "onChangeReplayStateRequest - internal error";
    return false;
  }

  m_objSrp->setPace(newPace);
  return false;
}


} // Namespace SituationReplay