/*
 * Copyright (c) 2009, Rambler media
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *	 * Redistributions of source code must retain the above copyright
 *	   notice, this list of conditions and the following disclaimer.
 *	 * Redistributions in binary form must reproduce the above copyright
 *	   notice, this list of conditions and the following disclaimer in the
 *	   documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY Rambler media ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL Rambler BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "main.h"
#include "events.h"

#undef RSPAMD_EVENTS_DEBUG

static gboolean
rspamd_event_equal (gconstpointer a, gconstpointer b)
{
	const struct rspamd_async_event  *ev1 = a, *ev2 = b;

	if (ev1->fin == ev2->fin) {
		return ev1->user_data == ev2->user_data;
	}

	return FALSE;
}

static guint
rspamd_event_hash (gconstpointer a)
{
	const struct rspamd_async_event  *ev = a;

	return GPOINTER_TO_UINT (ev->user_data);
}

struct rspamd_async_session    *
new_async_session (memory_pool_t * pool, event_finalizer_t fin,
		event_finalizer_t restore, event_finalizer_t cleanup, void *user_data)
{
	struct rspamd_async_session    *new;

	new = memory_pool_alloc (pool, sizeof (struct rspamd_async_session));
	new->pool = pool;
	new->fin = fin;
	new->restore = restore;
	new->cleanup = cleanup;
	new->user_data = user_data;
	new->wanna_die = FALSE;
	new->events = g_hash_table_new (rspamd_event_hash, rspamd_event_equal);
	new->forced_events = g_queue_new ();

	memory_pool_add_destructor (pool, (pool_destruct_func) g_hash_table_destroy, new->events);
	memory_pool_add_destructor (pool, (pool_destruct_func) g_queue_free, new->forced_events);

	return new;
}

void
register_async_event (struct rspamd_async_session *session, event_finalizer_t fin, void *user_data, gboolean forced)
{
	struct rspamd_async_event      *new, *ev;
	GList                          *cur;

	if (session == NULL) {
		msg_info ("session is NULL");
		return;
	}

	if (forced) {
		/* For forced events try first to increase its reference */
		cur = session->forced_events->head;
		while (cur) {
			ev = cur->data;
			if (ev->forced && ev->fin == fin) {
				ev->ref++;
				return;
			}
			cur = g_list_next (cur);
		}
	}

	new = memory_pool_alloc (session->pool, sizeof (struct rspamd_async_event));
	new->fin = fin;
	new->user_data = user_data;
	new->forced = forced;
	new->ref = 1;
	g_hash_table_insert (session->events, new, new);
#ifdef RSPAMD_EVENTS_DEBUG
	msg_info ("added event: %p, pending %d events", user_data, g_hash_table_size (session->events));
#endif
}

void
remove_forced_event (struct rspamd_async_session *session, event_finalizer_t fin)
{
	struct rspamd_async_event      *ev;
	GList                          *cur;

	if (session == NULL) {
		msg_info ("session is NULL");
		return;
	}

	cur = session->forced_events->head;
	while (cur) {
		ev = cur->data;
		if (ev->forced && ev->fin == fin) {
			ev->ref--;
			if (ev->ref == 0) {
				g_queue_delete_link (session->forced_events, cur);
			}
			break;
		}
		cur = g_list_next (cur);
	}

	check_session_pending (session);

	if (session->wanna_die && session->fin != NULL && g_queue_get_length (session->forced_events) == 0) {
		/* Call session destroy after all forced events are ready */
		session->cleanup (session->user_data);
	}
}

void
remove_normal_event (struct rspamd_async_session *session, event_finalizer_t fin, void *ud)
{
	struct rspamd_async_event       search_ev;

	if (session == NULL) {
		msg_info ("session is NULL");
		return;
	}

	search_ev.fin = fin;
	search_ev.user_data = ud;
	if (g_hash_table_remove (session->events, &search_ev)) {
		fin (ud);
	}

#ifdef RSPAMD_EVENTS_DEBUG
	msg_info ("removed event: %p, pending %d events", ud, g_hash_table_size (session->events));
#endif

	check_session_pending (session);
}

static void
rspamd_session_destroy (gpointer k, gpointer v, gpointer unused)
{
	struct rspamd_async_event      *ev = v;

	/* Call event's finalizer */
	if (ev->fin != NULL) {
		ev->fin (ev->user_data);
	}
}

gboolean
destroy_session (struct rspamd_async_session *session)
{
	if (session == NULL) {
		msg_info ("session is NULL");
		return FALSE;
	}

	session->wanna_die = TRUE;

	g_hash_table_foreach (session->events, rspamd_session_destroy, session);

	if (g_queue_get_length (session->forced_events) == 0) {
		if (session->cleanup != NULL) {
			session->cleanup (session->user_data);
		}
		return TRUE;
	}

	return FALSE;
}

gboolean
check_session_pending (struct rspamd_async_session *session)
{
	if (g_queue_get_length (session->forced_events) == 0 && g_hash_table_size (session->events) == 0) {
		if (session->fin != NULL) {
			session->fin (session->user_data);
		}
		/* Check events count again */
		if (g_hash_table_size (session->events) != 0) {
			if (session->restore != NULL) {
				session->restore (session->user_data);
			}
			return TRUE;
		}
		return FALSE;
	}

	return TRUE;
}