/* SPDX-License-Identifier: MPL-2.0 */

#include "precompiled.hpp"

#include "timers.hpp"

#include "err.hpp"

#include <algorithm>

zmq::timers_t::timers_t () : _tag (0xCAFEDADA), _next_timer_id (0)

{

}

zmq::timers_t::~timers_t ()

{

    //  Mark the timers as dead

    _tag = 0xdeadbeef;

}

bool zmq::timers_t::check_tag () const

{

    return _tag == 0xCAFEDADA;

}

int zmq::timers_t::add (size_t interval_, timers_timer_fn handler_, void *arg_)

{

    if (handler_ == NULL) {

        errno = EFAULT;

        return -1;

    }

    uint64_t when = _clock.now_ms () + interval_;

    timer_t timer = {++_next_timer_id, interval_, handler_, arg_};

    _timers.insert (timersmap_t::value_type (when, timer));

    return timer.timer_id;

}

struct zmq::timers_t::match_by_id

{

    match_by_id (int timer_id_) : _timer_id (timer_id_) {}

    bool operator() (timersmap_t::value_type const &entry_) const

    {

        return entry_.second.timer_id == _timer_id;

    }

  private:

    int _timer_id;

};

int zmq::timers_t::cancel (int timer_id_)

{

    // check first if timer exists at all

    if (_timers.end ()

        == std::find_if (_timers.begin (), _timers.end (),

                         match_by_id (timer_id_))) {

        errno = EINVAL;

        return -1;

    }

    // check if timer was already canceled

    if (_cancelled_timers.count (timer_id_)) {

        errno = EINVAL;

        return -1;

    }

    _cancelled_timers.insert (timer_id_);

    return 0;

}

int zmq::timers_t::set_interval (int timer_id_, size_t interval_)

{

    const timersmap_t::iterator end = _timers.end ();

    const timersmap_t::iterator it =

      std::find_if (_timers.begin (), end, match_by_id (timer_id_));

    if (it != end) {

        timer_t timer = it->second;

        timer.interval = interval_;

        uint64_t when = _clock.now_ms () + interval_;

        _timers.erase (it);

        _timers.insert (timersmap_t::value_type (when, timer));

        return 0;

    }

    errno = EINVAL;

    return -1;

}

int zmq::timers_t::reset (int timer_id_)

{

    const timersmap_t::iterator end = _timers.end ();

    const timersmap_t::iterator it =

      std::find_if (_timers.begin (), end, match_by_id (timer_id_));

    if (it != end) {

        timer_t timer = it->second;

        uint64_t when = _clock.now_ms () + timer.interval;

        _timers.erase (it);

        _timers.insert (timersmap_t::value_type (when, timer));

        return 0;

    }

    errno = EINVAL;

    return -1;

}

long zmq::timers_t::timeout ()

{

    const uint64_t now = _clock.now_ms ();

    long res = -1;

    const timersmap_t::iterator begin = _timers.begin ();

    const timersmap_t::iterator end = _timers.end ();

    timersmap_t::iterator it = begin;

    for (; it != end; ++it) {

        if (0 == _cancelled_timers.erase (it->second.timer_id)) {

            //  Live timer, lets return the timeout

            res = std::max (static_cast<long> (it->first - now), 0l);

            break;

        }

    }

    //  Remove timed-out timers

    _timers.erase (begin, it);

    return res;

}

int zmq::timers_t::execute ()

{

    const uint64_t now = _clock.now_ms ();

    const timersmap_t::iterator begin = _timers.begin ();

    const timersmap_t::iterator end = _timers.end ();

    timersmap_t::iterator it = _timers.begin ();

    for (; it != end; ++it) {

        if (0 == _cancelled_timers.erase (it->second.timer_id)) {

            //  Timer is not cancelled

            //  Map is ordered, if we have to wait for current timer we can stop.

            if (it->first > now)

                break;

            const timer_t &timer = it->second;

            timer.handler (timer.timer_id, timer.arg);

            _timers.insert (

              timersmap_t::value_type (now + timer.interval, timer));

        }

    }

    _timers.erase (begin, it);

    return 0;

}