
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <poll.h>

#include <unistd.h>
#include <pthread.h>
#include <glib.h>


#define CONNMAN_API_SUBJECT_TO_CHANGE
#include <connman/plugin.h>
#include <connman/device.h>
#include <connman/network.h>
#include <connman/inet.h>
#include <connman/dbus.h>
#include <connman/notifier.h>
#include <connman/log.h>
#include <connman/technology.h>
#include <connman/service.h>
#include <connman/ipconfig.h>


#undef DBG
#define DBG(fmt, arg...) \
    connman_debug("%s:%s() " fmt, \
            __FILE__, __FUNCTION__ , ## arg);


static GList *sleep_queue;
static GList *wake_queue;

typedef struct event_s{
	void *owner;
	GList *q;
	time_t valid_until;
}event_t;

gboolean process_queues(gpointer user_data);

gint owner_equals(gconstpointer a, gconstpointer b)
{
	event_t *e = (event_t*) a;
	if (e->owner == b){
		return 0;
	}
	return -1;
}

gint event_compare(gconstpointer aEvent, gconstpointer bEvent)
{
	event_t* a = (event_t*) aEvent;
	event_t* b = (event_t*) bEvent;
	return a->valid_until < b->valid_until;
}

void sleep_event(void *identifier, int cansleep, time_t valid_until)
{

	DBG("Sleep event: can%s sleep until %d\n",cansleep ? "" : "'t" , valid_until);
	//remove any previous entries owned by current identifier
	GList* entry = g_list_find_custom(wake_queue, identifier, &owner_equals);

	if (entry)
	{
		DBG("Found entry in wake queue");
		free(entry->data);
		wake_queue = g_list_delete_link(wake_queue, entry);
	}
	else
	{
		entry = g_list_find_custom(sleep_queue, identifier, &owner_equals);
		if (entry){
			DBG("Found entry in sleep queue");
			free(entry->data);
			sleep_queue = g_list_delete_link(sleep_queue, entry);
		}
	}

	DBG("pruned previous requests\n");

	//make a new event
	event_t *new_event = (event_t *)malloc(sizeof (event_t));
	if (new_event == NULL){
		return;
	}

	new_event->owner = identifier;
	new_event->valid_until = valid_until;

	DBG("inserting new request\n");
	if(cansleep)
	{
		//insert entry into sleep queue
		new_event->q = sleep_queue;
		sleep_queue = g_list_insert(sleep_queue, new_event, -1);

	}
	else
	{
		//insert entry into wake queue
		new_event->q = wake_queue;
		wake_queue = g_list_insert(wake_queue, new_event, -1);
	}
	DBG("added new request\n");

	process_queues(NULL);
}


gint is_expired(gconstpointer data, gconstpointer user_data)
{


	event_t *e = (event_t*) data;
	if ( e  && ( e->valid_until <= time(NULL))){
		return 0;
	}
	return -1;
}


gboolean process_queues(gpointer user_data)
{

	//sort queues
	DBG("sorting queues\n");
	sleep_queue = g_list_sort(sleep_queue, &event_compare);
	wake_queue = g_list_sort(wake_queue, &event_compare);
	//go through each queue and dump anything that has expired.

	DBG("sleep q len: %d, wake q len: %d\n", g_list_length(sleep_queue), g_list_length(wake_queue));

	DBG("cleaning out queues");
	GList* entry;
	while (NULL != (entry = g_list_find_custom(sleep_queue, NULL , &is_expired)))
	{
		DBG("Passed sleep point%d", ((event_t*) (entry->data))->valid_until);
		free(entry->data);
		sleep_queue = g_list_delete_link(sleep_queue, entry);
	}
	while (NULL != (entry = g_list_find_custom(wake_queue, NULL, &is_expired)))
	{
		DBG("Passed wake point %d", ((event_t *) (entry->data))->valid_until);
		free(entry->data);
		wake_queue = g_list_delete_link(wake_queue, entry);
	}

	DBG("sleep q len: %d, wake q len: %d\n", g_list_length(sleep_queue), g_list_length(wake_queue));

	DBG("checking wake queue\n");
	//check wake queue for ANYTHING.
	if (wake_queue)
	{
		event_t *e = wake_queue->data;
		//we can't sleep until at least e->valid_until
		//Stay awake and reschedule for then.
		DBG("staying awake for %d seconds", e->valid_until-time(NULL));
		g_timeout_add_seconds(e->valid_until, process_queues, NULL);
	}
	else
	{
		//nothing is holding us awake-- maybe we can sleep
		DBG("checking sleep queue\n");
		if (sleep_queue)
		{
			event_t *e = sleep_queue->data;
			//There is a valid wake time! We can sleep til then
			DBG("Sleeping for %d seconds", e->valid_until-time(NULL));
			//system_sleep_until(e->valid_until);
		}
		//else: indeterminiate. Probably shouldn't sleep.
	}

	return FALSE;
}

static struct connman_notifier notifier = {
	.name                   = "sleepplugin",
	.priority               = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
	.default_changed        = NULL,
	.service_add            = NULL,
	.service_remove         = NULL,
	.service_enabled        = NULL,
	.offline_mode           = NULL,
	.proxy_changed          = NULL,
	.service_state_changed  = NULL,
	.ipconfig_changed       = NULL,
	.sleep_event 			= &sleep_event,
	.idle_state             = NULL,
};

static int sleepplugin_init(void)
{

	DBG("");

	sleep_queue = NULL;
	wake_queue = NULL;

	connman_notifier_register(&notifier);

	return 0;
}

static void sleepplugin_exit(void)
{
	g_list_free_full(sleep_queue, free);
	g_list_free_full(wake_queue, free);
	DBG("");

}

CONNMAN_PLUGIN_DEFINE(sleepplugin, "connman sleep plugin", CONNMAN_VERSION,
		CONNMAN_PLUGIN_PRIORITY_DEFAULT, sleepplugin_init, sleepplugin_exit)