/*
 * delay_manager.cpp
 *
 *  Created on: Sep 15, 2017
 *      Author: root
 */
#include "delay_manager.h"
#include "log.h"
#include "packet.h"

int delay_data_t::handle() {
    return my_send(dest, data, len) >= 0;
}

delay_manager_t::delay_manager_t() {
    capacity = 0;

    // if ((timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK)) < 0)
    //{
    //	mylog(log_fatal,"timer_fd create error");
    //	myexit(1);
    // }

    // itimerspec zero_its;
    // memset(&zero_its, 0, sizeof(zero_its));

    // timerfd_settime(timer_fd, TFD_TIMER_ABSTIME, &zero_its, 0);
}
delay_manager_t::~delay_manager_t() {
    // TODO ,we currently dont need to deconstruct it
}

/*
int delay_manager_t::get_timer_fd()
{
        return timer_fd;
}*/

// int add(my_time_t delay,const dest_t &dest,const char *data,int len);
int delay_manager_t::add(my_time_t delay, const dest_t &dest, char *data, int len) {
    delay_data_t delay_data;
    delay_data.dest = dest;
    // delay_data.data=data;
    delay_data.len = len;

    if (capacity != 0 && int(delay_mp.size()) >= capacity) {
        mylog(log_warn, "max pending packet reached,ignored\n");
        return -1;
    }
    if (delay == 0) {
        static char buf[buf_len];
        delay_data.data = buf;
        memcpy(buf, data, len);
        int ret = delay_data.handle();
        if (ret != 0) {
            mylog(log_trace, "handle() return %d\n", ret);
        }
        return 0;
    }

    delay_data_t tmp = delay_data;
    tmp.data = (char *)malloc(delay_data.len + 100);
    if (!tmp.data) {
        mylog(log_warn, "malloc() returned null in delay_manager_t::add()");
        return -1;
    }
    memcpy(tmp.data, data, delay_data.len);

    my_time_t tmp_time = get_current_time_us();
    tmp_time += delay;

    delay_mp.insert(make_pair(tmp_time, tmp));

    ////check();  check everytime when add, is it better ??

    return 0;
}

int delay_manager_t::check() {
    if (!delay_mp.empty()) {
        my_time_t current_time;

        multimap<my_time_t, delay_data_t>::iterator it;
        while (1) {
            int ret = 0;
            it = delay_mp.begin();
            if (it == delay_mp.end()) break;

            current_time = get_current_time_us();
            if (it->first <= current_time) {
                ret = it->second.handle();
                if (ret != 0) {
                    mylog(log_trace, "handle() return %d\n", ret);
                }
                free(it->second.data);
                delay_mp.erase(it);
            } else {
                break;
            }
        }
        if (!delay_mp.empty()) {
            const double m = 1000 * 1000;
            double timer_value = delay_mp.begin()->first / m - get_current_time_us() / m;  // be aware of negative value, and be aware of uint
            if (timer_value < 0) timer_value = 0;                                          // set it to 0 if negative, although libev support negative value
            ev_timer_stop(loop, &timer);
            ev_timer_set(&timer, timer_value, 0);
            ev_timer_start(loop, &timer);
        } else {
            ev_timer_stop(loop, &timer);  // not necessary
        }
    }
    return 0;
}