#include <assert.h>
#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/inotify.h>
#include <sys/types.h>
#include <unistd.h>

#define BUFFER_LEN 4096

static void   handle_event(int inotify_instance, int *watched, char **filenames, int *counter, size_t watched_len);
static char** filenames_in_dir(char *path, size_t *return_len);
static char** filenames_in_path_envvar(size_t *return_len);
static void   free_null_terminated_pointer_array(char **ptr);
static void   print_event(uint32_t event);
static void   save_result(char **filenames, int* counter, size_t arr_len);


/* This code is a bit over-commented in general  */
int
main(int argc, char * const argv[])
{
    /* Get null terminated list of files to watch, create counter of same size */

	char **file_names;
	int *use_counter, *watched;
	size_t files_len;

	switch (argc) {
	case 1:
    	file_names = filenames_in_path_envvar(&files_len);
		break;
	case 2:
    	file_names = filenames_in_dir(argv[1], &files_len);
		break;
	default:
		errx(EXIT_FAILURE, "Usage: `%s <dir>`. If dir is empty, directories in PATH will be monitored", argv[0]);
	}

    if (file_names == NULL)
        err(EXIT_FAILURE, "Error when finding files");

	use_counter = calloc(files_len, sizeof(int));

	if( use_counter == NULL )
		err(EXIT_FAILURE, "Failed to allocate %zu bytes for use counter", files_len*sizeof(int));


	/* Create file descriptor for accessing the inotify API */

	int inotify_instance = inotify_init();
	
	if ( inotify_instance == -1 )
		err(EXIT_FAILURE, "Failed to initialize inotify instance");	


	/* Mark files for events */

	watched = calloc(files_len, sizeof(int));

	if( watched == NULL )
		err(EXIT_FAILURE, "Failed to allocate %zu bytes for watch descriptors", files_len*sizeof(int));

	for(size_t i=0; file_names[i] != NULL; i++) {
		watched[i] = inotify_add_watch(inotify_instance, file_names[i], IN_ACCESS);

		if(watched[i] == -1)
			err(EXIT_FAILURE, "Cannot watch %s", file_names[i]);
	}


	/* Prepare for polling */

	struct pollfd poll_fds[2];
	nfds_t fd_count = 2;

	poll_fds[0].fd = STDIN_FILENO;
	poll_fds[0].events = POLLIN;

	poll_fds[1].fd = inotify_instance;
	poll_fds[1].events = POLLIN;


	/* Wait for events and/or terminal input */

	int poll_num;

	fprintf(stderr, "Listening for events... (Press enter to end)\n");

	while (1) {
		poll_num = poll(poll_fds, fd_count, -1);
	
		if( poll_num == -1 && errno != EINTR)
			err(EXIT_FAILURE, "Failed to poll");

		if (poll_num == 0)
			continue;

		if (poll_fds[0].revents & POLLIN) {
			char c;
			while (read(STDIN_FILENO, &c, 1) > 0 && c != '\n')
				/* noop */;
			save_result(file_names, use_counter, files_len);
			break;
		}
		
		if( poll_fds[1].revents & POLLIN ) {
			handle_event(inotify_instance, watched, file_names, use_counter, files_len);
		}
	}


	close(inotify_instance);

	free_null_terminated_pointer_array(file_names);
	free(watched);
	free(use_counter);

    return EXIT_SUCCESS;
}


/* Free allocated memory pointed to by pointers 
   in 'ptr', then free 'ptr' itself */
static void
free_null_terminated_pointer_array(char **ptr)
{
	for(char **p = ptr; *p != NULL; p++ ){
		free(*p);
	}

	free(ptr);
}


/* Returns a null terminated array of strings
   for every file in PATH */
static char**
filenames_in_path_envvar(size_t *return_len) {
	size_t n_files, i, output_size;
	char **filenames, **output, *saveptr, *path, *token;
	void *tmp;
	
	path = strdup(getenv("PATH"));

	saveptr = NULL;
	output_size = 1024;
	output = malloc(output_size * sizeof(char*));

	if (output == NULL) {
		warn("Failed to allocate %zu bytes", output_size);
		return NULL;
	}

	token = strtok_r(path, ":", &saveptr);

	i = 0;
	while (token != NULL) {
		n_files = 0;
		filenames = filenames_in_dir(token, &n_files);
		n_files -= 1;

		if ( filenames == NULL ) {
			fprintf(stderr, "failed to get filenames in %s\n", token);
			token = strtok_r(NULL, ":", &saveptr);
			continue;
		}

		if (i + n_files > output_size) {
			while(i + n_files > output_size)
				output_size *= 2;

			tmp = realloc(output, output_size * sizeof(char*));

			if (tmp == NULL) {
				warn("failed to reallocate %zu bytes", output_size * sizeof(char*));
				return NULL;
			}

			output = (char**) tmp;
		}

		memcpy(output+i, filenames, n_files * sizeof(char*));
		i += n_files;

		free(filenames);

		token = strtok_r(NULL, ":", &saveptr);
	}
	output_size = i + 1;
	tmp = realloc(output, output_size * sizeof(char*));

	if (tmp != NULL){
		output = (char**)tmp;
	}

	output[i] = NULL;

	free(path);

	*return_len = output_size;

	return output;
}


/* Returns null terminated array
   of filepaths in directory */
static char**
filenames_in_dir(char *path, size_t *return_len)
{
	size_t result_size, n_items=0;
	char **result;
	void *tmp;
    struct dirent *dir_entity;
	DIR *directory_stream;
	
	result_size = 64;
	result = malloc(result_size * sizeof(char*));

	if( result == NULL ){
		warn("Failed to malloc %zu bytes", result_size);
		return NULL;
	}

    directory_stream = opendir(path);

    if (directory_stream == NULL) {
        warn("Failed to open directory %s", path);
		goto fail;
    }

	n_items = 0;
    errno = 0; // To distinguish end of stream from an error, 
               // set errno to zero before calling readdir()
    while ((dir_entity = readdir(directory_stream)) != NULL) {
		if(n_items >= result_size){
			result_size *= 2;
			result = realloc(result, result_size * sizeof(char*));
		}

		if (dir_entity->d_type == DT_REG ) {
			result[n_items] = calloc(strlen(path) + strlen(dir_entity->d_name) + 2, sizeof(char));
			result[n_items] = strcat(result[n_items], path);
			result[n_items] = strcat(result[n_items], "/");
			result[n_items] = strcat(result[n_items], dir_entity->d_name);
			n_items += 1;
		}

		// dirent *dir_entity is statically allocated, dont free()!
    }
	result_size = n_items+1;
	tmp = realloc(result, result_size * sizeof(char*));

	if ( tmp == NULL ) {
		warn("Failed to realloc %zu bytes", result_size);
		return NULL;
	}

	result = (char**)tmp;

	result[n_items] = NULL;

    if ( errno != 0 ){
        warn("Error when reading directory %s", path);
		goto fail;
    }
    
	if ( closedir(directory_stream) == -1 )
        warn("Failed to close directory");

	*return_len = result_size;

    return result;

fail:
	for(size_t i=0; i<n_items; i++){
		free(result[i]);
	}
	free(result);

    if ( closedir(directory_stream) == -1 )
        warn("Failed to close directory");

	*return_len = 0;
    
	return NULL;
}


/* Read all available inotify events from 
   file descriptor 'inotify_instance' */
static void
handle_event(int inotify_instance, int *watched, char **filenames, int *counter, size_t watched_len)
{
	ssize_t length;
	const struct inotify_event *event;
	char buffer[BUFFER_LEN]
			__attribute__ ((aligned(__alignof__(struct inotify_event))));

	length = read(inotify_instance, buffer, BUFFER_LEN);

	if( length == -1 && errno != EAGAIN) {
		warn("Failed to read inotify event");
		return;
	}

	if (length == 0){
		return;
	}

	for (char *p = buffer; p < buffer+length; p += sizeof(struct inotify_event) + event->len) {
		event = (struct inotify_event *) p;

		for (int i=0; i < watched_len; i++) {
			if( watched[i] == event->wd ) {
				fprintf(stderr, "%s ", filenames[i]);
				counter[i] += 1;
				break;
			}
		}
	}
}


/* Prints event mask values in a human-readable format */
static void
print_event(uint32_t event)
{
	if(event & IN_ACCESS){
		fprintf(stderr,"IN_ACCESS ");
	}
	if(event & IN_ATTRIB){
		fprintf(stderr,"IN_ATTRIB ");
	}
	if(event & IN_CLOSE_WRITE){
		fprintf(stderr,"IN_CLOSE_WRITE ");
	}
	if(event & IN_CLOSE_NOWRITE){
		fprintf(stderr,"IN_CLOSE_NOWRITE ");
	}
	if(event & IN_CREATE){
		fprintf(stderr,"IN_CREATE ");
	}
	if(event & IN_DELETE){
		fprintf(stderr,"IN_DELETE ");
	}
	if(event & IN_DELETE_SELF){
		fprintf(stderr,"IN_DELETE_SELF ");
	}
	if(event & IN_MODIFY){
		fprintf(stderr,"IN_MODIFY ");
	}
	if(event & IN_MOVE_SELF){
		fprintf(stderr,"IN_MOVE_SELF ");
	}
	if(event & IN_MOVED_FROM){
		fprintf(stderr,"IN_MOVED_FROM ");
	}
	if(event & IN_OPEN){
		fprintf(stderr,"IN_OPEN ");
	}
}


/* Saves number of recorded events for each 
   executable t 'uses.log' */
static void
save_result(char **filenames, int* counter, size_t arr_len)
{
	FILE *savefile;

	savefile = fopen("uses.log", "w");

	if (savefile == NULL) {
		warn("Failed to save to file");
		return;
	}

	for (size_t i=0; i<arr_len; i++) {
		if (counter[i] == 0)
			continue;

		fprintf(stdout, "%d %s\n", counter[i], filenames[i]);
	}


	fclose(savefile);
}