#include <sys/select.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>

#include <scot/inotify.h>
#include <scot/fs_watcher.h>
#include <scot/event_listener.h>
#include <scot/exception.h>
#include <scot/stream.h>
#include <scot/event.h>
#include <scot/memory.h>
#include <scot/thread.h>
#include <scot/scot_types.h>

#define GEN_LOCAL
# include <scot/list.h>
#undef  GEN_LOCAL

GEN_LIST_FUNC_PROTO (scot_fsw_info);
GEN_LIST_IMPL       (scot_fsw_info);

static
void
scot_fsw_info_free (scot_fsw_info * e)
{
	if (e != NULL)
	{
		if (e->path != NULL)
			SCOT_MEM_FREE (e->path);
		if (e->old_name != NULL)
			SCOT_MEM_FREE (e->old_name);

		SCOT_MEM_FREE (e);
	}
}

static
int 
scot_fsw_info_cmp_path (const scot_fsw_info * a, const scot_fsw_info * b)
{
	return strcmp (a->path, b->path);
}

static
int
scot_fsw_info_cmp_watch_d (const scot_fsw_info * a, const scot_fsw_info * b)
{
	return (a->watch_d == b->watch_d)?0:(a->watch_d < b->watch_d)?-1:1;
}


static
void 
thread_fini (void * arg)
{
	exc_end ();
}

static
unsigned short
default_cb (struct scot_event * _e)
{
	SSIZE_T                        n;
	char                           puffer[1024];
	struct scot_fs_watcher_event * e = (struct scot_fs_watcher_event *) _e;

	switch (_e->event)
	{
		case (SCOT_EVENT_FS_WATCHER_CREATE): 
			printf ("%s/%s created\n", e->path, e->name);
			break;
		case (SCOT_EVENT_FS_WATCHER_DELETE): 
			printf ("%s/%s deleted\n", e->path, e->name);
			break;
		case (SCOT_EVENT_FS_WATCHER_RENAME): 
			printf ("%s/%s renamed to %s/%s\n", 
					e->path, e->oldname, 
					e->path, e->name);
			break;
			
			/* more to come .... */

		default: break;
	}

	fflush (stdout);

	return SCOT_EVENT_END;
}


struct scot_fs_watcher *
scot_fs_watcher_new (void)
{
	struct scot_fs_watcher * fsw;

	fsw = SCOT_MEM_GET (sizeof (struct scot_fs_watcher));
	SCOT_MEM_ZERO (fsw, sizeof (struct scot_fs_watcher));

	fsw->w_list = list_scot_fsw_info_new (fsw->w_list);

	list_scot_fsw_info_set_elem_free (scot_fsw_info_free);

	SCOT_MEM_ZERO (&fsw->notify_d, sizeof (struct scot_stream));

	fsw->notify_d.handle.file = inotify_init ();
	if (fsw->notify_d.handle.file == -1)
		THROW (EXC (EXC_ERROR, errno, strerror (errno)));

	fsw->notify_d.s_type = SCOT_STREAM_TYPE_INOTIFY;
	scot_stream_set_nonblock (&fsw->notify_d);

	FD_SET (fsw->notify_d.handle.file, &fsw->rfds);

	scot_event_listener_init (
			(struct scot_event_listener *) fsw,
			                               SCOT_EG_FS_WATCHER,
			(scot_thread_entry_fptr)       scot_fs_watcher_main_loop);

	scot_event_listener_register_cb (
			(struct scot_event_listener *) fsw,
			SCOT_EVENT_FS_WATCHER_CREATE,
			default_cb, NULL);
	scot_event_listener_register_cb (
			(struct scot_event_listener *) fsw,
			SCOT_EVENT_FS_WATCHER_DELETE,
			default_cb, NULL);
	scot_event_listener_register_cb (
			(struct scot_event_listener *) fsw,
			SCOT_EVENT_FS_WATCHER_RENAME,
			default_cb, NULL);

	NEW_THREAD_MUTEX (&fsw->mutex);

	return fsw;
}

void
scot_fs_watcher_free (struct scot_fs_watcher * fsw)
{
	scot_event_listener_fini ((struct scot_event_listener *) fsw);

	list_scot_fsw_info_free (fsw->w_list);

	FREE_THREAD_MUTEX (&fsw->mutex);

	SCOT_MEM_FREE (fsw);
}

void
scot_fs_watcher_add (
		struct scot_fs_watcher * fsw, 
		const char *             path,
		uint32_t                 mask)
{
	struct scot_event_listener * l = (struct scot_event_listener *) fsw;
	struct scot_fsw_info *       fswi;

	/*
	 * soweit ich das in erinnerung habe sind meine listen nicht per se
	 * thread save. Daher sollte hier unbedingt noch ein mutex her,
	 * damit nicht gleichzeitig in die liste geschriebe (hier)
	 * und gelöscht wird (in remove)
	 */
	LOCK_THREAD_MUTEX (&fsw->mutex);

	fswi = SCOT_MEM_GET (sizeof (struct scot_fsw_info));
	SCOT_MEM_ZERO (fswi, sizeof (struct scot_fsw_info));
	fswi->path = SCOT_MEM_GET (SCOT_STR_LENGTH (path) + 1);
	SCOT_STR_COPY (fswi->path, path);

	if ((mask & SCOT_EVENT_FS_WATCHER_CREATE) == SCOT_EVENT_FS_WATCHER_CREATE)
		fswi->mask |= IN_CREATE;
	if ((mask & SCOT_EVENT_FS_WATCHER_DELETE) == SCOT_EVENT_FS_WATCHER_DELETE)
		fswi->mask |= IN_DELETE;
	if ((mask & SCOT_EVENT_FS_WATCHER_RENAME) == SCOT_EVENT_FS_WATCHER_RENAME)
		fswi->mask |= IN_MOVED_FROM | IN_MOVED_TO;
	
	fswi->watch_d = inotify_add_watch (fsw->notify_d.handle.file, path, fswi->mask);
	if (fswi->watch_d == -1)
	{
		SCOT_MEM_FREE (fswi->path);
		SCOT_MEM_FREE (fswi);

		THROW (EXC (EXC_ERROR, errno, strerror (errno)));
	}

	list_scot_fsw_info_set_cmp (scot_fsw_info_cmp_path);

	if (list_scot_fsw_info_find (fsw->w_list, fswi) == NULL)
		list_scot_fsw_info_insert (fsw->w_list, fswi);

	list_scot_fsw_info_set_cmp (list_scot_fsw_info_default_cmp);

	/* restart thread if running. */
	if (scot_event_listener_is_running (l) != 0 && l->thread_handle != THREAD_ID)
	{
		scot_event_listener_stop (l);
		scot_event_listener_start (l);
	}

	UNLOCK_THREAD_MUTEX (&fsw->mutex);
}

void
scot_fs_watcher_remove (
		struct scot_fs_watcher * fsw,
		const char *             path,
		uint32_t                 mask)
{
	struct scot_event_listener * l = (struct scot_event_listener *) fsw;
	int was_running = scot_event_listener_is_running (l);
	list_scot_fsw_info_node_t * node;
	struct scot_fsw_info   search_fswi = {0, (char *)path, 0, 0, NULL};
	struct scot_fsw_info * fswi;

	LOCK_THREAD_MUTEX (&fsw->mutex);

	if (was_running != 0 && l->thread_handle != THREAD_ID)
		scot_event_listener_stop (l);

	list_scot_fsw_info_set_cmp (scot_fsw_info_cmp_path);

	node = list_scot_fsw_info_find (fsw->w_list, &search_fswi);
	fswi = list_scot_fsw_info_retrive (node);

	list_scot_fsw_info_set_cmp (list_scot_fsw_info_default_cmp);

	if ((mask & SCOT_EVENT_FS_WATCHER_CREATE) == SCOT_EVENT_FS_WATCHER_CREATE)
		fswi->mask &= ~IN_CREATE;
	if ((mask & SCOT_EVENT_FS_WATCHER_DELETE) == SCOT_EVENT_FS_WATCHER_DELETE)
		fswi->mask &= ~IN_DELETE;
	if ((mask & SCOT_EVENT_FS_WATCHER_RENAME) == SCOT_EVENT_FS_WATCHER_RENAME)
		fswi->mask &= ~IN_MOVED_FROM & ~IN_MOVED_TO;
	
	if (fswi->mask == 0)
	{
		inotify_rm_watch (fsw->notify_d.handle.file, fswi->watch_d);
		node = list_scot_fsw_info_delete (node);
	}
	else
	{
		inotify_add_watch (fsw->notify_d.handle.file, fswi->path, fswi->mask);
		node = list_scot_fsw_info_next (node);
	}

	if (was_running != 0 && l->thread_handle != THREAD_ID)
		scot_event_listener_start (l);

	UNLOCK_THREAD_MUTEX (&fsw->mutex);
}


static
struct inotify_event *
scot_fs_watcher_get_event (struct scot_fs_watcher * fsw) 
{
	static int             size   = 0;
	static int             got    = 0;
	static char *          buffer = NULL;
	struct inotify_event * e      = NULL;

	if (size == 0)
	{
		got  = 0;
		size = 16;
		size = sizeof (struct inotify_event);
		buffer = SCOT_MEM_GET (size);
	}

	got += scot_stream_read (&fsw->notify_d, buffer+got, size-got);

	if (size == got)
	{
		if (size == sizeof (struct inotify_event))
		{
			char * tmp_buf = buffer;

			size += ((struct inotify_event *)buffer)->len;
			buffer = SCOT_MEM_GET (size);
			SCOT_MEM_COPY (buffer, tmp_buf, sizeof (struct inotify_event));
			SCOT_MEM_FREE (tmp_buf);
			got += scot_stream_read (&fsw->notify_d, buffer+got, size-got);
		}

		if (size == got)
		{
			e = SCOT_MEM_GET (size);
			SCOT_MEM_COPY (e, buffer, size);
			SCOT_MEM_FREE (buffer);
			size = 0;
		}
	}

	return e;
}

/*
 * entry point für einen stream-pool event-source thread.
 */
void
scot_fs_watcher_main_loop (struct scot_fs_watcher * fsw)
{
	fd_set run_rfds;
	excenv_t * ee;

	THREAD_CANCEL_ENABLE;
	THREAD_CANCEL_DEFER;


	TRY
	{
		THREAD_ATEXIT_BEGIN (thread_fini, NULL);

		while (1)
		{
			struct inotify_event * ie = NULL;

			run_rfds = fsw->rfds;

			/* evtl. sollte man hier noch timeout support einbauen, sprich
			 * das letzte NULL mit einer time austauschen. */
			if (select (fsw->notify_d.handle.file+1, &run_rfds, NULL, NULL, NULL) == -1)
				THROW (EXC (EXC_ERROR, errno, strerror (errno)));

			while ((ie = scot_fs_watcher_get_event (fsw)) != NULL)
			{
				struct scot_fsw_info         sfswi = {ie->wd, NULL, 0, 0, NULL};
				struct scot_fsw_info *         fswi;
				struct scot_fs_watcher_event * e = NULL;
				list_scot_fsw_info_node_t *  w_node;

				SCOT_MEM_ZERO (&e, sizeof (struct scot_fs_watcher_event));

				list_scot_fsw_info_set_cmp (scot_fsw_info_cmp_watch_d);

				w_node = list_scot_fsw_info_find (fsw->w_list, &sfswi);
				fswi = list_scot_fsw_info_retrive (w_node);

				list_scot_fsw_info_set_cmp (list_scot_fsw_info_default_cmp);

				/*
				 * Ok, jetzt muß code folgen, der die got_events maske
				 * analysiert und je nachdem wie diese gesetzt ist
				 * ein scot event erzeugt oder nicht...soll heißen einen
				 * callback aufruft oder nicht.
				 */
				if (ie->mask == IN_MOVED_FROM)
				{
					struct inotify_event * _ie = scot_fs_watcher_get_event (fsw);

					if (_ie != NULL && 
					    _ie->mask == IN_MOVED_TO &&
					    ie->wd == _ie->wd)
					{
						e = scot_fs_watcher_event_new (
								e, SCOT_EVENT_FS_WATCHER_RENAME, NULL, 0,
								fswi->path, _ie->name, ie->name);

						if (_ie != NULL)
							SCOT_MEM_FREE (_ie);
					}
					else
					{
						e = scot_fs_watcher_event_new (
								e, SCOT_EVENT_FS_WATCHER_DELETE, NULL, 0,
								fswi->path, ie->name, NULL);

						scot_event_listener_call_cb (
								(struct scot_event_listener *) fsw, 
								(struct scot_event *) e);

						scot_event_free ((struct scot_event *) e);
						e = NULL;

						SCOT_MEM_FREE (ie);
						ie = _ie;
					}
				}

				if (ie != NULL && (ie->mask & (IN_MOVED_TO | IN_CREATE)) != 0)
					e = scot_fs_watcher_event_new (
							e, SCOT_EVENT_FS_WATCHER_CREATE, NULL, 0, 
							fswi->path, ie->name, NULL);

				if (ie != NULL && ie->mask ==IN_DELETE)
					e = scot_fs_watcher_event_new (
							e, SCOT_EVENT_FS_WATCHER_DELETE, NULL, 0, 
							fswi->path, ie->name, NULL);

				if (e != NULL)
				{
					/* call callback... */
					scot_event_listener_call_cb (
							(struct scot_event_listener *) fsw, 
							(struct scot_event *) e);

					/* free e after callback */
					scot_event_free ((struct scot_event *) e);
					e = NULL;
				}

				if (ie != NULL)
					SCOT_MEM_FREE (ie);
			}
		}

		THREAD_ATEXIT_END (1);
	}
	CATCH (ee)
	{
		print_all_exceptions (ee);
		exit (EXIT_FAILURE);
	}
}