/*
 * UNG's Not GNU
 *
 * Copyright (c) 2011,2022, Jakob Kaivo <jkk@ung.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#define _POSIX_C_SOURCE 200809L

#include <errno.h>
#include <locale.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

struct grep_list {
	struct grep_list *next;
	char *string;
	regex_t re;
};

#define NORMAL	0
#define COUNT	1
#define LIST	2
#define QUIET	3

#define IGNORECASE	1 << 0
#define LINENUMBERS	1 << 1
#define SUPPRESS	1 << 2
#define INVERT		1 << 3
#define WHOLELINE	1 << 4
#define FILENAMES	1 << 5

static int grep_match(struct grep_list *head, const char *buf)
{
	for (struct grep_list *c = head; c != NULL; c = c->next) {
		if (c->string) {
			if (strstr(buf, c->string)) {
				return 1;
			}
			continue;
		}

		if (regexec(&(c->re), buf, 0, NULL, 0) == 0) {
			return 1;
		}
	}

	return 0;
}

static int grep(struct grep_list *head, const char *path, int flags)
{
	(void)flags;

	FILE *f = stdin;
	if (path && strcmp(path, "-")) {
		f = fopen(path, "r");
		if (f == NULL) {
			if (/*!suppress ||*/ (errno != ENOENT && errno != EPERM)) {
				fprintf(stderr, "grep: %s: %s\n", path, strerror(errno));
			}
			return 0;
		}
	}

	int found = 0;
	char *buf = NULL;
	size_t len = 0;
	while (getline(&buf, &len, f) != -1) {
		char *nl = strrchr(buf, '\n');
		if (nl) {
			*nl = '\0';
		}
		if (grep_match(head, buf)) {
			printf("%s\n", buf);
			found++;
		}
	}

	fclose(f);

	return found;
}

static struct grep_list * grep_add_list(struct grep_list *head, char *s)
{
	char *pattern = strtok(s, "\n");
	while (pattern) {
		struct grep_list *node = calloc(1, sizeof(*node));
		if (node == NULL) {
			perror("grep");
			exit(2);
		}

		if (head == NULL) {
			head = node;
		} else {
			struct grep_list *tmp = head;
			while (tmp->next != NULL) {
				tmp = tmp->next;
			}
			tmp->next = node;
		}

		node->string = strdup(pattern);

		pattern = strtok(NULL, "\n");
	}
	return head;
}

static struct grep_list * grep_add_file(struct grep_list *head, char *path)
{
	FILE *f = fopen(path, "r");
	if (f == NULL) {
		fprintf(stderr, "grep: %s: %s\n", path, strerror(errno));
		exit(2);
	}

	char *buf = NULL;
	size_t len = 0;
	while (getline(&buf, &len, f) != -1) {
		head = grep_add_list(head, buf);
	}
	free(buf);

	fclose(f);

	return head;
}

int main(int argc, char *argv[])
{
	setlocale(LC_ALL, "");

	int flags = REG_NOSUB;
	struct grep_list *head = NULL;
	enum {REGEX, FIXED } type = REGEX;

	int c;
	while ((c = getopt(argc, argv, "EFce:f:ilnqsvx")) != -1) {
		switch (c) {
		case 'E':
			flags |= REG_EXTENDED;
			break;

		case 'F':
			type = FIXED;
			break;

		case 'c':
			//display = COUNT;
			break;

		case 'e':
			head = grep_add_list(head, optarg);
			break;

		case 'f':
			head = grep_add_file(head, optarg);
			break;

		case 'i':
			flags |= REG_ICASE;
			break;

		case 'l':
			//display = LIST;
			break;

		case 'n':
			//flags |= LINENUMBERS;
			break;

		case 'q':
			//display = QUIET;
			break;

		case 's':
			//flags |= SUPPRESS;
			break;

		case 'v':
			//flags |= INVERT;
			break;

		case 'x':
			//flags |= WHOLELINE;
			break;

		default:
			return 2;
		}
	}

	if (head == NULL) {
		if (optind > argc - 1) {
			perror("grep: missing operands\n");	
			return 2;
		}
		head = grep_add_list(head, argv[optind++]);
	}

	if (type != FIXED) {
		for (struct grep_list *c = head; c != NULL; c = c->next) {
			int e = regcomp(&(c->re), c->string, flags);
			if (e == 0) {
				free(c->string);
				c->string = NULL;
				continue;
			}

			char err[512];
			regerror(e, &(c->re), err, sizeof(err));
			fprintf(stderr, "grep: %s: %s\n", c->string, err);
			return 2;
		}
	}
	
	int found = 0;
	do {
		found += grep(head, argv[optind++], flags);
	} while (optind < argc);

	if (found) {
		return 0;
	}

	return 1;
}