/*
 * Copyright (C) 2010 Red Hat, Inc.
 *
 * Author: Angus Salkeld <asalkeld@redhat.com>
 *
 * This file is part of libqb.
 *
 * libqb is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * libqb is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libqb.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "os_base.h"
#include <pthread.h>

#include <qb/qbdefs.h>
#include <qb/qblist.h>
#include <qb/qbarray.h>
#include <qb/qbloop.h>
#include "loop_int.h"
#include "util_int.h"
#include "tlist.h"

struct qb_loop_timer {
	struct qb_loop_item item;
	qb_loop_timer_dispatch_fn dispatch_fn;
	enum qb_loop_priority p;
	timer_handle timerlist_handle;
	enum qb_poll_entry_state state;
	int32_t check;
	uint32_t install_pos;
};

struct qb_timer_source {
	struct qb_loop_source s;
	struct timerlist timerlist;
	qb_array_t *timers;
	size_t timer_entry_count;
	pthread_mutex_t lock;
};

static void
timer_dispatch(struct qb_loop_item *item, enum qb_loop_priority p)
{
	struct qb_loop_timer *timer = (struct qb_loop_timer *)item;

	assert(timer->state == QB_POLL_ENTRY_JOBLIST);
	timer->check = 0;
	timer->dispatch_fn(timer->item.user_data);
	timer->state = QB_POLL_ENTRY_EMPTY;
}

static int32_t expired_timers;
static void
make_job_from_tmo(void *data)
{
	struct qb_loop_timer *t = (struct qb_loop_timer *)data;
	struct qb_loop *l = t->item.source->l;

	assert(t->state == QB_POLL_ENTRY_ACTIVE);
	qb_loop_level_item_add(&l->level[t->p], &t->item);
	t->state = QB_POLL_ENTRY_JOBLIST;
	expired_timers++;
}

static int32_t
expire_the_timers(struct qb_loop_source *s, int32_t ms_timeout)
{
	struct qb_timer_source *ts = (struct qb_timer_source *)s;
	expired_timers = 0;
	if (timerlist_expire(&ts->timerlist) != 0) {
		qb_util_log(LOG_ERR, "timerlist_expire failed");
	}
	return expired_timers;
}

int32_t
qb_loop_timer_msec_duration_to_expire(struct qb_loop_source * timer_source)
{
	struct qb_timer_source *my_src = (struct qb_timer_source *)timer_source;
	uint64_t left = timerlist_msec_duration_to_expire(&my_src->timerlist);
	if (left != -1 && left > 0xFFFFFFFF) {
		left = 0xFFFFFFFE;
	}
	return left;
}

struct qb_loop_source *
qb_loop_timer_create(struct qb_loop *l)
{
	struct qb_timer_source *my_src = malloc(sizeof(struct qb_timer_source));
	if (my_src == NULL) {
		return NULL;
	}
	my_src->s.l = l;
	my_src->s.dispatch_and_take_back = timer_dispatch;
	my_src->s.poll = expire_the_timers;

	timerlist_init(&my_src->timerlist);
	my_src->timers = qb_array_create_2(16, sizeof(struct qb_loop_timer), 16);
	my_src->timer_entry_count = 0;
	pthread_mutex_init(&my_src->lock, NULL);

	return (struct qb_loop_source *)my_src;
}

void
qb_loop_timer_destroy(struct qb_loop *l)
{
	struct qb_timer_source *my_src =
	    (struct qb_timer_source *)l->timer_source;

	timerlist_destroy(&my_src->timerlist);
	qb_array_free(my_src->timers);
	free(l->timer_source);
}

static int32_t
_timer_from_handle_(struct qb_timer_source *s,
		    qb_loop_timer_handle handle_in,
		    struct qb_loop_timer **timer_pt)
{
	int32_t rc;
	int32_t check;
	uint32_t install_pos;
	struct qb_loop_timer *timer;

	if (handle_in == 0) {
		return -EINVAL;
	}

	check = handle_in >> 32;
	install_pos = handle_in & UINT32_MAX;

	rc = qb_array_index(s->timers, install_pos, (void **)&timer);
	if (rc != 0) {
		return rc;
	}
	if (timer->check != check) {
		return -EINVAL;
	}
	*timer_pt = timer;
	return 0;
}

static int32_t
_get_empty_array_position_(struct qb_timer_source *s)
{
	int32_t install_pos;
	int32_t res = 0;
	struct qb_loop_timer *timer;

	for (install_pos = 0; install_pos < s->timer_entry_count; install_pos++) {
		assert(qb_array_index(s->timers, install_pos, (void **)&timer)
		       == 0);
		if (timer->state == QB_POLL_ENTRY_EMPTY) {
			return install_pos;
		}
	}

	res = qb_array_grow(s->timers, s->timer_entry_count + 1);
	if (res != 0) {
		return res;
	}

	s->timer_entry_count++;
	install_pos = s->timer_entry_count - 1;
	return install_pos;
}

int32_t
qb_loop_timer_add(struct qb_loop * lp,
		  enum qb_loop_priority p,
		  uint64_t nsec_duration,
		  void *data,
		  qb_loop_timer_dispatch_fn timer_fn,
		  qb_loop_timer_handle * timer_handle_out)
{
	struct qb_loop_timer *t;
	struct qb_timer_source *my_src;
	int32_t i;
	int res;
	struct qb_loop *l = lp;

	if (l == NULL) {
		l = qb_loop_default_get();
	}

	if (l == NULL || timer_fn == NULL) {
		return -EINVAL;
	}
	my_src = (struct qb_timer_source *)l->timer_source;

	if ( (res=pthread_mutex_lock(&my_src->lock))) {
		return -res;
	}
	i = _get_empty_array_position_(my_src);
	assert(qb_array_index(my_src->timers, i, (void **)&t) >= 0);
	t->state = QB_POLL_ENTRY_ACTIVE;
	t->install_pos = i;
	t->item.user_data = data;
	t->item.source = (struct qb_loop_source *)my_src;
	t->dispatch_fn = timer_fn;
	t->p = p;
	qb_list_init(&t->item.list);

	/* Unlock here to stop anyone else changing the state while we're initializing */
	pthread_mutex_unlock(&my_src->lock);

	/*
	 * Make sure just positive integers are used for the integrity(?)
	 * checks within 2^32 address space, if we miss 200 times in a row
	 * (just 0 is concerned per specification of random), the PRNG may be
	 * broken -> the value is unspecified, subject of previous assignment.
	 */
	for (i = 0; i < 200; i++) {
		t->check = random();

		if (t->check > 0) {
			break;  /* covers also t->check == UINT32_MAX */
		}
	}

	if (timer_handle_out) {
		*timer_handle_out = (((uint64_t) (t->check)) << 32) | t->install_pos;
	}
	return timerlist_add_duration(&my_src->timerlist,
				      make_job_from_tmo, t,
				      nsec_duration, &t->timerlist_handle);
}

int32_t
qb_loop_timer_del(struct qb_loop * lp, qb_loop_timer_handle th)
{
	struct qb_timer_source *s;
	struct qb_loop_timer *t;
	int32_t res;
	struct qb_loop *l = lp;

	if (l == NULL) {
		l = qb_loop_default_get();
	}
	s = (struct qb_timer_source *)l->timer_source;

	res = _timer_from_handle_(s, th, &t);
	if (res != 0) {
		return res;
	}

	if (t->state == QB_POLL_ENTRY_DELETED) {
		qb_util_log(LOG_WARNING, "timer already deleted");
		return 0;
	}
	if (t->state != QB_POLL_ENTRY_ACTIVE &&
	    t->state != QB_POLL_ENTRY_JOBLIST) {
		return -EINVAL;
	}
	if (t->state == QB_POLL_ENTRY_JOBLIST) {
		qb_loop_level_item_del(&l->level[t->p], &t->item);
	}

	if (t->timerlist_handle) {
		if (timerlist_del(&s->timerlist, t->timerlist_handle) != 0) {
			qb_util_log(LOG_ERR, "Could not delete timer from timerlist");
		}
	}
	t->state = QB_POLL_ENTRY_EMPTY;
	return 0;
}

uint64_t
qb_loop_timer_expire_time_get(struct qb_loop * lp, qb_loop_timer_handle th)
{
	struct qb_timer_source *s;
	struct qb_loop_timer *t;
	int32_t res;
	struct qb_loop *l = lp;

	if (l == NULL) {
		l = qb_loop_default_get();
	}
	s = (struct qb_timer_source *)l->timer_source;

	res = _timer_from_handle_(s, th, &t);
	if (res != 0) {
		return 0;
	}

	if (t->state != QB_POLL_ENTRY_ACTIVE) {
		return 0;
	}

	return timerlist_expire_time(&s->timerlist, t->timerlist_handle);
}

uint64_t
qb_loop_timer_expire_time_remaining(struct qb_loop * lp, qb_loop_timer_handle th)
{

	uint64_t current_ns;
	/* NOTE: while it does not appear that absolute timers are used anywhere,
	 * we may as well respect this pattern in case that changes.
	 * Unfortunately, that means we do need to repeat timer fetch code from qb_loop_timer_expire_time_get
	 * rather than just a simple call to qb_loop_timer_expire_time_get and qb_util_nano_current_get.
	 */

	struct qb_timer_source *s;
	struct qb_loop_timer *t;
	int32_t res;
	struct qb_loop *l = lp;

	if (l == NULL) {
		l = qb_loop_default_get();
	}
	s = (struct qb_timer_source *)l->timer_source;

	res = _timer_from_handle_(s, th, &t);
	if (res != 0) {
		return 0;
	}
	if (t->state != QB_POLL_ENTRY_ACTIVE) {
		return 0;
	}

	struct timerlist_timer *timer = (struct timerlist_timer *)t->timerlist_handle;
	if (timer->is_absolute_timer) {
		current_ns = qb_util_nano_from_epoch_get();
	}
	else {
		current_ns = qb_util_nano_current_get();
	}
	uint64_t timer_ns = timerlist_expire_time(&s->timerlist, t->timerlist_handle);
	if (timer_ns < current_ns) {
		return 0; // respect the "expired" contract
	}
	return timer_ns - current_ns;


}

int32_t
qb_loop_timer_is_running(qb_loop_t *l, qb_loop_timer_handle th)
{
	return (qb_loop_timer_expire_time_get(l, th) > 0);
}