#define _BSD_SOURCE
#define _DEFAULT_SOURCE

#include <dirent.h>
#include <errno.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include "config.h"

#define NAME "rf"
#define VERSION "0.0.1"

struct switches {
	int basename;
	int invert;
	int limit;
	int count;
};

static int version(char *error)
{
	fprintf(stderr, "%s version %s\n", NAME, VERSION);
	return error == NULL ? 0 : 1;
}

static int usage(char *error)
{
	if (error != NULL) {
		fprintf(stderr, "Error: %s\n\n", error);
	}

	fprintf(stderr, "Usage: %s [OPTIONS]\n", NAME);
	fprintf(stderr, "\nOptions:\n");
	fprintf(stderr, "  --basename, -b   only show basename in results\n");
	fprintf(stderr, "  --invert, -v     invert matching\n");
	fprintf(stderr,
		"  --limit=n        limit to [n] results, all if 0 [default=0]\n");

	fprintf(stderr, "\n  --help, -h       show help\n");
	fprintf(stderr, "  --version, -V    show version\n");
	fprintf(stderr, "\n");

	return version(error);
}

static int is_child(char *dirname)
{
	if (strcmp("..", dirname) == 0 || strcmp(".", dirname) == 0) {
		return 0;
	}

	return 1;
}

static int not_in_array(char **arr, char *dirname, size_t size)
{
	int i = 0;

	for (; i < size; i++) {
		if (strstr(dirname, arr[i])) {
			return 0;
		}
	}

	return 1;
}

static int at_side(int beginning, char *filename, char *str)
{
	int c = 0;
	int matched = 1;

	if (beginning) {
		for (; c < strlen(str); c++) {
			if (str[c] != filename[c]) {
				matched = 0;
				break;
			}
		}
	} else {
		int d = 0;

		for (c = strlen(str), d = strlen(filename); c >= 0; c--, d--) {
			if (str[c] != filename[d]) {
				matched = 0;
				break;
			}
		}
	}

	return matched;
}

static int excluded_extension(char *filename)
{
	int i = 0;

	for (; i < ignored_extensions_size; i++) {
		int res = at_side(0, filename, ignored_extensions[i]);

		if (res) {
			return res;
		}
	}

	return 0;
}

static void print_result(char *path, struct switches *switches,
			 struct dirent *entry)
{
	if (switches->basename) {
		printf("%s\n", entry->d_name);
	} else {
		char full_path[MAXPATHLEN];
		full_path[0] = '\0';
		strcat(full_path, path);
		strcat(full_path, "/");
		strcat(full_path, entry->d_name);
		printf("%s\n", full_path);
	}
}

static char *strslice(char *source, int start, int end)
{
	int i = 0;
	int diff = start + end;
	int len = strlen(source) - diff;
	char *output = malloc(sizeof(char *) * len);
	memset(output, '\0', len);

	for (; i < len; i++) {
		output[i] = source[i + start];
	}

	return output;
}

/* return 1 if breaking early (e.g. reaching limit) otherwise return 0 */
static int recurse_find(char **patterns, int *pattern_count, char *dirname,
			struct switches *switches)
{
	DIR *dir;

	char path[MAXPATHLEN] = { '\0' };
	int break_early = 0;
	strcat(path, dirname);
	dir = opendir(path);

	if (dir != NULL &&
	    not_in_array(ignored_dirs, dirname, ignored_dirs_size)) {
		struct dirent *entry;

		while ((entry = readdir(dir)) != NULL) {
			int matched = 0;
			int p = 0;

			switch (entry->d_type) {
			case DT_DIR:
				if (is_child(entry->d_name) &&
				    not_in_array(ignored_dirs, entry->d_name,
						 ignored_dirs_size)) {
					char child_path[MAXPATHLEN] = { '\0' };
					strcat(child_path, path);
					strcat(child_path, "/");
					strcat(child_path, entry->d_name);
					if (recurse_find(
						    patterns, pattern_count,
						    child_path, switches)) {
						break_early = 1;
						break;
					};
				}

				break;
			case DT_REG:
				if (excluded_extension(entry->d_name)) {
					break;
				}

				for (; p < *pattern_count; p++) {
					char *pattern = patterns[p];
					char first = pattern[0];
					char last =
						pattern[strlen(pattern) - 1];
					char *parsed = NULL;

					if (last == '$' && first == '^') {
						/* show everything */
						if (strlen(pattern) == 2) {
							matched = 1;
						} else {
							/* match whole string */
							parsed = strslice(
								pattern, 1, 1);

							if (strcmp(entry->d_name,
								   parsed) ==
							    0) {
								matched = 1;
							}
						}
					} else if (last == '$') {
						/* match at end */
						parsed =
							strslice(pattern, 0, 1);

						if (at_side(0, entry->d_name,
							    parsed)) {
							matched = 1;
						}
					} else if (first == '^') {
						/* match at beginning */
						parsed =
							strslice(pattern, 1, 0);

						if (at_side(1, entry->d_name,
							    parsed)) {
							matched = 1;
						}
					} else {
						/* substring match */
						if (strstr(entry->d_name,
							   pattern) != NULL) {
							matched = 1;
						}
					}

					if (parsed != NULL) {
						free(parsed);
					}
				}

				break;
			default:
				break;
			} /* switch */

			if (break_early) {
				closedir(dir);
				return 1;
			}

			if ((matched && (switches->invert == 0)) ||
			    (matched == 0 && (switches->invert == 1))) {
				print_result(path, switches, entry);

				if (switches->limit > 0 &&
				    ++switches->count == switches->limit) {
					closedir(dir);
					return 1;
				}
			}
		} /* while */

		closedir(dir);
	} /* if */

	return 0;
}

int main(int argc, char **argv)
{
	static struct option options[] = { { "basename", no_argument, 0, 0 },
					   { "invert", no_argument, 0, 0 },
					   { "limit", required_argument, 0, 0 },
					   { "version", no_argument, 0, 0 },
					   { "help", no_argument, 0, 0 },
					   { 0, 0, 0, 0 } };

	int basename = 0;
	int invert = 0;
	int limit = 0;
	int index = 0;
	int res;
	int count = 0; /* used to count how matches we find */

	char *remainder;

	while ((res = getopt_long(argc, argv, "hvVb", options, &index)) > -1) {
		switch (res) {
		case 0:
			if (strcmp("version", options[index].name) == 0) {
				return version(NULL);
			} else if (strcmp("help", options[index].name) == 0) {
				return usage(NULL);
			} else if (strcmp("basename", options[index].name) ==
				   0) {
				basename = 1;
			} else if (strcmp("invert", options[index].name) == 0) {
				invert = 1;
			} else if (strcmp("limit", options[index].name) == 0) {
				limit = strtol(optarg, &remainder, 10);

				if (limit < 0) {
					return usage("Invalid limit.");
				}
			}

			break;

		case 'V':
			return version(NULL);

		case 'h':
			return usage(NULL);

		case 'b':
			basename = 1;
			break;

		case 'v':
			invert = 1;
			break;
		}
	}

	if (optind < argc) {
		while (optind < argc) {
			optind++;
		}
	}

	if (optind > 0) {
		int i = 0;
		struct switches switches;
		int pattern_count = optind - 1;
		char **patterns = malloc(sizeof(char *) * optind);

		memset(patterns, '\0', optind);

		for (; i < optind; i++) {
			patterns[i] = argv[i + 1];
		}

		switches.basename = basename;
		switches.invert = invert;
		switches.limit = limit;
		switches.count = count;

		if (recurse_find(patterns, &pattern_count, ".", &switches)) {
			/* finished early because we reached the limit */
		};

		free(patterns);
	}

	return 0;
}