/**
  * @RDE_HEADER@
  * State Machine handler for Exercise Control
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "schedule_status_state_machine.h"
#include "schedule_status_manager.h"
#include "schedule_status_base.h"

#include "object_main_schedule.h"
#include "settings.h"
#include "logger.h"

namespace InfrastructureManagement
{

ScheduleStatusMachine::ScheduleStatusMachine(ObjectMainSchedule* objSchedule, QObject *parent)
  : QObject(parent)
  , m_stateManager(new ScheduleStatusManager(objSchedule, this))
  , m_stateMachine(new QStateMachine(this))
  , m_schedule(objSchedule)
  , m_logger(getLogger("ScheduleStatusMachine"))
{
  qRegisterMetaType<InfrastructureManagement::ScheduleStatus>("InfrastructureManagement::ScheduleStatus");

  m_ScheduleStatuses.insert(ScheduleStatus::Unknown,   new Unknown(m_schedule));
  m_ScheduleStatuses.insert(ScheduleStatus::Created,   new Creation(m_schedule));
  m_ScheduleStatuses.insert(ScheduleStatus::Prepared,  new Preparation(m_schedule));
  m_ScheduleStatuses.insert(ScheduleStatus::Activated, new Activation(m_schedule));
  m_ScheduleStatuses.insert(ScheduleStatus::Expired,   new Expiration(m_schedule));
  m_ScheduleStatuses.insert(ScheduleStatus::Removed,   new Removing(m_schedule));

  // Define transitions from one state to the other
  // ----------------------------------------------------------------------------------------------------------
  // ** Unknown
  // => Created
  m_ScheduleStatuses[ScheduleStatus::Unknown]->addTransition(m_stateManager, &ScheduleStatusManager::stateCreated,
                                                          m_ScheduleStatuses[ScheduleStatus::Created]);
  // ** Created
  // => Prepared
  m_ScheduleStatuses[ScheduleStatus::Created]->addTransition(m_stateManager, &ScheduleStatusManager::statePrepared,
                                                          m_ScheduleStatuses[ScheduleStatus::Prepared]);
  // ** Created
  // => Removed
  m_ScheduleStatuses[ScheduleStatus::Created]->addTransition(m_stateManager, &ScheduleStatusManager::stateRemoved,
                                                          m_ScheduleStatuses[ScheduleStatus::Removed]);
  // ** Prepared
  // => Created
  m_ScheduleStatuses[ScheduleStatus::Prepared]->addTransition(m_stateManager, &ScheduleStatusManager::stateCreated,
                                                          m_ScheduleStatuses[ScheduleStatus::Created]);
  // ** Prepared
  // => Activated
  m_ScheduleStatuses[ScheduleStatus::Prepared]->addTransition(m_stateManager, &ScheduleStatusManager::stateActivated,
                                                          m_ScheduleStatuses[ScheduleStatus::Activated]);
  // ** Activated
  // => Expired
  m_ScheduleStatuses[ScheduleStatus::Activated]->addTransition(m_stateManager, &ScheduleStatusManager::stateExpired,
                                                         m_ScheduleStatuses[ScheduleStatus::Expired]);
  // ** Activated
  // => Prepared
  m_ScheduleStatuses[ScheduleStatus::Activated]->addTransition(m_stateManager, &ScheduleStatusManager::statePrepared,
                                                         m_ScheduleStatuses[ScheduleStatus::Prepared]);
  // ** Expired
  // => Activated
  m_ScheduleStatuses[ScheduleStatus::Expired]->addTransition(m_stateManager,  &ScheduleStatusManager::stateActivated,
                                                          m_ScheduleStatuses[ScheduleStatus::Activated]);
  // ** Expired
  // => Removed
  m_ScheduleStatuses[ScheduleStatus::Expired]->addTransition(m_stateManager,  &ScheduleStatusManager::stateRemoved,
                                                          m_ScheduleStatuses[ScheduleStatus::Removed]);
  // ----------------------------------------------------------------------------------------------------------

  //States zur StateMachine hinzufügen
  for (ScheduleStatusBase *state : qAsConst(m_ScheduleStatuses))
  {
    DEBUG_LOG(m_logger) << "Schedule " << scheduleId() << ": state: " << state->scheduleStatus();
    m_stateMachine->addState(state);
    connect(state, &ScheduleStatusBase::entered, this, &ScheduleStatusMachine::onEnteredState);
  }

  DEBUG_LOG(m_logger) << "Schedule " << scheduleId() << ": Constructor ScheduleStatusMachine: size m_ScheduleStatuses = " << m_ScheduleStatuses.size();
}

ScheduleStatusMachine::~ScheduleStatusMachine()
{
  qDeleteAll(m_ScheduleStatuses);
  delete m_stateManager;
  delete m_stateMachine;
}

bool ScheduleStatusMachine::init()
{
  if (m_stateMachine->isRunning())
    return false;

  DEBUG_LOG(m_logger) << "Schedule " << scheduleId() << ": Init ScheduleStatusMachine ";
  // initialise current ScheduleStatus
  ScheduleStatusBase *currentScheduleStatus = getStateFromId(m_schedule->scheduleStatus());

  DEBUG_LOG(m_logger) << "Schedule " << scheduleId() << ": State = "
                      << ScheduleStatusManager::toString(m_schedule->scheduleStatus());

  m_stateMachine->setInitialState(currentScheduleStatus);
  m_stateMachine->start();

  m_stateManager->setInitial(m_schedule->scheduleStatus());

  DEBUG_LOG(m_logger) << "Schedule " << scheduleId() << ": ==> Done Init ScheduleStatusMachine ";

  return true;
}

InfrastructureManagement::ScheduleStatus ScheduleStatusMachine::getCurrentState()
{
  return m_schedule->scheduleStatus();
}

bool ScheduleStatusMachine::switchToState(ScheduleStatus newScheduleStatus)
{
  return m_stateManager->triggerSwitchState(newScheduleStatus);
}

void ScheduleStatusMachine::onEnteredState()
{
  DEBUG_LOG(m_logger) << "Schedule " << scheduleId() << ": ScheduleStatusMachine - onEnteredState";

  ScheduleStatusBase *s = qobject_cast<ScheduleStatusBase*>(sender());
  if (!s)
    return;

  DEBUG_LOG(m_logger) << "Schedule " << scheduleId() << ": ScheduleStatusBase : " << s->scheduleStatus();

  m_stateManager->setCurrent(s->scheduleStatus());

  emit ScheduleStatusChanged(s->scheduleStatus());
}

//----------------------------------------
ScheduleStatusBase* ScheduleStatusMachine::getStateFromId(ScheduleStatus ScheduleStatus)
{
  ScheduleStatusBase *s = m_ScheduleStatuses.value(ScheduleStatus);
  if (!s)
    s = m_ScheduleStatuses.value(ScheduleStatus::Unknown);
  return s;
}

//----------------------------------------
int ScheduleStatusMachine::scheduleId() const
{
  return m_schedule ? m_schedule->getId() : -1;
}

} // namespace InfrastructureManagement