#include "MoversightTimer.h"

#include "Moversight.h"
#include "MoversightService.h"
#include "Dispatcher.h"

namespace ubeeme {
    namespace moversight {

        /**
         * @brief Constructor
         */
#if OMNETPP

        MoversightTimer::MoversightTimer(MoversightService & aService) : cMessage("UNDEFINED_TIMER", 1), service(aService) {
#else

        MoversightTimer::MoversightTimer(MoversightService & aService) : service(aService) {
#endif
            setNumberOfRetries(NUMBER_OF_MAX_RETRIES);
        }

        /**
         * @brief Destructor
         */
        MoversightTimer::~MoversightTimer() {
        }

        /**
         * @brief Copy Constructor
         * @param other The Instance to be copied
         */
        MoversightTimer::MoversightTimer(const MoversightTimer& other) : service(other.service) {
            operator =(other);
        }

        /**
         * @brief Fire this timer.
         *
         * This method ensures that a proper event processing takes place after
         * the timeout is processed.
         */
        void
        MoversightTimer::fire() {
            timeout();
        }

        /**
         * @brief Restarts the timer by calling first stop and afterwards start
         */
        void
        MoversightTimer::restart() {
            stop();
            start();
        }

        /**
         * @brief Starts the Moversight timer. Note, the timer is also started,
         * has the retries counter reaches zero.
         */
        void
        MoversightTimer::start() {

            if (numberOfRetries > 0) {
                numberOfRetries--;
            }//End if

#if OMNETPP
            service.module.scheduleAt(simTime() + getTimeout().dbl(), this);
#else
            setInterval(getTimeout().toMSecs());
            AbstractTimer::start();
#endif
        }

        /**
         * @brief Stops the timer
         */
        void
        MoversightTimer::stop() {

            if (isRunning()) {
#if OMNETPP
                service.module.cancelEvent(this);
#else
                AbstractTimer::stop();
#endif
            }//End if


        }

        /**
         * @brief Assignment operator
         * @param other The instance to assign
         * @return a reference to this instance
         */
        MoversightTimer&
                MoversightTimer::operator=(const MoversightTimer& other) {

            if (this == &other) return *this;
#if OMNETPP
            cMessage::operator=(other);
#else
            ubeeme::AbstractTimer::operator=(other);
#endif
            storage = other.storage;

            setNumberOfRetries(other.getNumberOfRetries());
            numberOfRetriesStartValue = other.numberOfRetriesStartValue;

            return *this;
        }

        /**
         * @brief Determines, if the timer is running.
         * @return True, if the timer is running, false otherwise.
         */
        bool
        MoversightTimer::isRunning() {
#if OMNETPP
            return cMessage::isScheduled();
#else
            return ubeeme::AbstractTimer::isActive();
#endif
        }

        /**
         * @brief Returns the current timeout time
         * @return GenericTime timeout
         */
        GenericTime
        MoversightTimer::getTimeout() {
            return storage.get<GenericTime>("timeout");
        }

        /**
         * @brief Sets the timeout
         * @param t The timeout to set
         */
        void
        MoversightTimer::setTimeout(GenericTime t) {
            storage.set<GenericTime>("timeout", t);
#if UBEEME
            setInterval(t.toMSecs());
#endif
        }

        /**
         * @brief Returns the current number of retries
         * @return number of retries
         */
        size_t
        MoversightTimer::getNumberOfRetries() const {
            return numberOfRetries;
        }

        /**
         * @brief Sets the number of retries. The number of retries is also
         * stored as start value for reseting the number of retries.
         * @see resetNumberOfRetries
         * @param nOR The number to be set
         */
        void
        MoversightTimer::setNumberOfRetries(size_t nOR) {
            numberOfRetries = nOR;
            numberOfRetriesStartValue = nOR;
        }

        /**
         * @brief Resets the number of retries to the user defined start value or
         * the default one. The start value is set to the default value within
         * within the constructor or set by the user via the setNumberOfRetries
         * method
         * @see setNumberOfRetries
         */
        void
        MoversightTimer::resetNumberOfRetries() {
            numberOfRetries = numberOfRetriesStartValue;
        }
    }
}