/*-
 * Copyright (c) 2015 Hans Petter Selasky. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD$
 */

#include <stdio.h>
#include <stdint.h>
#include <sys/queue.h>
#include <sysexits.h>
#include <err.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <signal.h>

extern char **environ;

static int opt_verbose;
static char *opt_diff_tool;

#define	BLOCK_SIZE	4096
#define	BLOCK_MASK	0x100
#define	BLOCK_ADD	0x200

struct block {
	TAILQ_ENTRY(block) entry;
	uint32_t length;
	uint32_t flags;
	uint8_t *data;
	uint8_t *mask;
};

typedef TAILQ_HEAD(, block) block_head_t;

static void
sigpipe(int sig)
{
}

static struct block *
alloc_block(void)
{
	struct block *pb;
	size_t size = sizeof(*pb) + (2 * BLOCK_SIZE);

	pb = malloc(size);
	if (pb == NULL)
		errx(EX_SOFTWARE, "Out of memory");
	memset(pb, 0, size);
	pb->data = (void *)(pb + 1);
	pb->mask = pb->data + BLOCK_SIZE;
	pb->length = BLOCK_SIZE;
	return (pb);
}

static int
write_block(int fd, block_head_t *ph)
{
	struct block *ptr;

	if (fd < 0)
		return (-1);

	TAILQ_FOREACH(ptr, ph, entry) {
		if (write(fd, ptr->data, ptr->length) != ptr->length)
			return (-1);
	}
	return (0);
}

static uint16_t
peek_block(block_head_t *pbh, uint64_t off)
{
	struct block *ptr;

	TAILQ_FOREACH(ptr, pbh, entry) {
		if (off < ptr->length)
			break;
		off -= ptr->length;
	}
	if (ptr == NULL)
		return (0);
	return (ptr->data[off] | (ptr->mask[off] << 8));
}

static void
set_block(block_head_t *pbh, uint64_t off, uint16_t ch)
{
	struct block *ptr;

	TAILQ_FOREACH(ptr, pbh, entry) {
		if (off < ptr->length)
			break;
		off -= ptr->length;
	}
	if (ptr == NULL)
		return;
	ptr->data[off] = ch & 0xFF;
	ptr->mask[off] = (ch >> 8) & 0xFF;
}

static uint64_t
size_block(block_head_t *pbh)
{
	struct block *ptr;
	uint64_t off = 0;

	TAILQ_FOREACH(ptr, pbh, entry)
	    off += ptr->length;
	return (off);
}

static int
diff_tool(block_head_t *pa, block_head_t *pb)
{
	char ca[] = {"/tmp/diff.orig.XXXXXX"};
	char cb[] = {"/tmp/diff.styled.XXXXXX"};
	char cc[256];
	uint64_t sa;
	uint64_t sb;
	uint64_t s;
	uint64_t x;
	int fa;
	int fb;

	sa = size_block(pa);
	sb = size_block(pb);
	s = (sa > sb) ? sa : sb;

	for (x = 0; x != s; x++) {
		char cha = peek_block(pa, x) & 0xFF;
		char chb = peek_block(pb, x) & 0xFF;

		if (cha != chb) {
			/* false positive */
			if (cha == '\n' && chb == 0 && x == sa - 1)
				return (0);
			break;
		}
	}
	if (x == s)
		return (0);		/* identical */

	fa = mkstemp(ca);
	fb = mkstemp(cb);

	if (write_block(fa, pa) < 0 || write_block(fb, pb) < 0) {
		close(fa);
		close(fb);
		unlink(ca);
		unlink(cb);
		err(EX_SOFTWARE, "Could not write data to temporary files");
	}
	close(fa);
	close(fb);

	snprintf(cc, sizeof(cc), "%s %s %s", opt_diff_tool, ca, cb);
	system(cc);

	unlink(ca);
	unlink(cb);
	return (-1);
}

static int
diff_block(block_head_t *pa, block_head_t *pb)
{
	uint64_t sa = size_block(pa);
	uint64_t sb = size_block(pb);
	uint64_t s;
	uint64_t x;
	uint64_t y;
	uint64_t n;

	s = (sa > sb) ? sa : sb;

	for (y = x = 0; x != s; x++) {
		char cha = peek_block(pa, x) & 0xFF;
		char chb = peek_block(pb, x) & 0xFF;

		if (cha != chb) {
			int nonspace;

			/* false positive */
			if (cha == '\n' && chb == 0 && x == sa - 1)
				return (0);

			n = x - y;
			printf("Style error:\n");
			nonspace = 0;
			for (n = y; n < sa; n++) {
				char ch = peek_block(pa, n) & 0xFF;

				if (nonspace && ch == '\n')
					break;
				printf("%c", ch);
				if (!isspace(ch))
					nonspace = 1;
			}
			printf("\n");
			printf("Style corrected:\n");
			nonspace = 0;
			for (n = y; n < sb; n++) {
				char ch = peek_block(pb, n) & 0xFF;

				if (nonspace && ch == '\n')
					break;
				printf("%c", ch);
				if (!isspace(ch))
					nonspace = 1;
			}
			printf("\n");
			for (n = y; n != x; n++) {
				if ((peek_block(pa, n) & 0xFF) == '\t')
					printf("\t");
				else
					printf(" ");
			}
			printf("^ %sdifference%s\n",
			    (isspace(cha) || isspace(chb)) ? "whitespace " : "",
			    (x >= sa || x >= sb) ? " in the end of a block" : "");
			return (1);
		} else if (cha == '\n') {
			y = x + 1;
		}
	}
	return (0);
}

static void
free_block(block_head_t *pbh)
{
	struct block *ptr;

	while ((ptr = TAILQ_FIRST(pbh))) {
		TAILQ_REMOVE(pbh, ptr, entry);
		free(ptr);
	}
}

static void
cmd_popen(char *command, FILE **iop)
{
	char *argv[4];
	int pdes[4];
	int pid;

	if (pipe(pdes) < 0)
		goto error;

	if (pipe(pdes + 2) < 0) {
		close(pdes[0]);
		close(pdes[1]);
		goto error;
	}
	argv[0] = "sh";
	argv[1] = "-c";
	argv[2] = command;
	argv[3] = NULL;

	switch ((pid = vfork())) {
	case -1:			/* Error. */
		close(pdes[0]);
		close(pdes[1]);
		close(pdes[2]);
		close(pdes[3]);
		goto error;
	case 0:			/* Child. */
		dup2(pdes[1], STDOUT_FILENO);
		dup2(pdes[2], STDIN_FILENO);
		close(pdes[0]);
		close(pdes[3]);
		execve("/bin/sh", argv, environ);
		exit(127);
	default:
		break;
	}
	iop[0] = fdopen(pdes[3], "w");
	iop[1] = fdopen(pdes[0], "r");
	close(pdes[1]);
	close(pdes[2]);
	return;
error:
	iop[0] = iop[1] = NULL;
}

static void
cmd_block_process(block_head_t *pbh_in, block_head_t *pbh_out, char *cmd_str)
{
	FILE *pfd[2];
	struct block *ptr;

	TAILQ_INIT(pbh_out);

	cmd_popen(cmd_str, pfd);

	if (pfd[0] == NULL || pfd[1] == NULL)
		errx(EX_SOFTWARE, "Cannot invoke command '%s'", cmd_str);

	if (pbh_in != NULL) {
		TAILQ_FOREACH(ptr, pbh_in, entry) {
			if (fwrite(ptr->data, 1, ptr->length, pfd[0]) != ptr->length)
				err(EX_SOFTWARE, "Cannot write all data to command '%s'", cmd_str);
		}
		fflush(pfd[0]);
	}
	fclose(pfd[0]);

	while (1) {
		int len;

		ptr = alloc_block();
		len = fread(ptr->data, 1, BLOCK_SIZE, pfd[1]);
		if (len <= 0) {
			free(ptr);
			break;
		}
		ptr->length = len;
		TAILQ_INSERT_TAIL(pbh_out, ptr, entry);
	}
	fclose(pfd[1]);
}

static void
usage(void)
{
	fprintf(stderr,
	    "indent_wrapper [-v] [-d] [-D] [-g <githash>]\n"
	    "\t" "[-s <svnrevision> ] [ -t <tool> ] [ -c <command> ]\n"
	    "\t" "-v        Increase verbosity\n"
	    "\t" "-d        Check output from git diff\n"
	    "\t" "-D        Check output from svn diff\n"
	    "\t" "-c <cmd>  Set custom command to produce diff\n"
	    "\t" "-g <hash> Check output from git hash\n"
	    "\t" "-s <rev>  Check output from svn revision\n"
	    "\t" "-t <tool> Launch external diff tool\n"
	    "\n"
	    "Examples:\n"
	    "\t" "indent_wrapper -D\n"
	    "\t" "indent_wrapper -D -t meld\n"
	    "\t" "indent_wrapper -D -t \"diff -u\"\n");
	exit(EX_SOFTWARE);
}

int
main(int argc, char **argv)
{
	block_head_t diff_head;
	block_head_t diff_a_head;
	block_head_t diff_b_head;
	block_head_t indent_in_head;
	block_head_t indent_out_head;
	struct block *p1 = NULL;
	struct block *p2 = NULL;
	uint64_t size;
	uint64_t x;
	uint64_t y1 = 0;
	uint64_t y2 = 0;
	int recurse = 0;
	int inside_string = 0;
	int escape_char = 0;
	int do_parse = 0;
	char cmdbuf[256];
	uint16_t ch;
	uint16_t chn;
	int c;
	int retval = 0;

	signal(SIGPIPE, &sigpipe);

	cmdbuf[0] = 0;

	while ((c = getopt(argc, argv, "dDvg:s:c:ht:")) != -1) {
		switch (c) {
		case 'v':
			opt_verbose++;
			break;
		case 't':
			opt_diff_tool = optarg;
			break;
		case 'g':
			snprintf(cmdbuf, sizeof(cmdbuf), "git show -U1000000 %s", optarg);
			break;
		case 'd':
			snprintf(cmdbuf, sizeof(cmdbuf), "git diff -U1000000");
			break;
		case 'D':
			snprintf(cmdbuf, sizeof(cmdbuf), "svn diff --diff-cmd=diff -x -U1000000");
			break;
		case 's':
			snprintf(cmdbuf, sizeof(cmdbuf), "svn diff --diff-cmd=diff -x -U1000000 -r %s", optarg);
			break;
		case 'c':
			snprintf(cmdbuf, sizeof(cmdbuf), "%s", optarg);
			break;
		default:
			usage();
		}
	}
	if (cmdbuf[0] == 0)
		usage();

	cmd_block_process(NULL, &diff_head, cmdbuf);

	TAILQ_INIT(&diff_a_head);
	TAILQ_INIT(&diff_b_head);

	size = size_block(&diff_head);
	p1 = alloc_block();
	y1 = 0;
	p2 = alloc_block();
	y2 = 0;

	for (x = 0; x < size;) {
		ch = peek_block(&diff_head, x);
		switch (ch & 0xFF) {
		case '+':
			if (ch == peek_block(&diff_head, x + 1) &&
			    ch == peek_block(&diff_head, x + 2) &&
			    ' ' == (peek_block(&diff_head, x + 3) & 0xFF))
				goto parse_filename;
			if (do_parse == 0)
				break;
			for (x++; x != size; x++) {
				ch = peek_block(&diff_head, x);
				p1->mask[y1] = BLOCK_ADD >> 8;
				p1->data[y1++] = ch;
				if (y1 == BLOCK_SIZE) {
					TAILQ_INSERT_TAIL(&diff_a_head, p1, entry);
					p1 = alloc_block();
					y1 = 0;
				}
				if ((ch & 0xFF) == '\n')
					break;
			}
			break;
		case '-':
			if (ch == peek_block(&diff_head, x + 1) &&
			    ch == peek_block(&diff_head, x + 2) &&
			    ' ' == (peek_block(&diff_head, x + 3) & 0xFF))
				goto parse_filename;
			if (do_parse == 0)
				break;
			for (x++; x != size; x++) {
				ch = peek_block(&diff_head, x);
				p2->data[y2++] = ch;
				if (y2 == BLOCK_SIZE) {
					TAILQ_INSERT_TAIL(&diff_b_head, p2, entry);
					p2 = alloc_block();
					y2 = 0;
				}
				if ((ch & 0xFF) == '\n')
					break;
			}
			break;
		case ' ':
			if (do_parse == 0)
				break;
			for (x++; x != size; x++) {
				ch = peek_block(&diff_head, x);
				p1->data[y1++] = ch;
				if (y1 == BLOCK_SIZE) {
					TAILQ_INSERT_TAIL(&diff_a_head, p1, entry);
					p1 = alloc_block();
					y1 = 0;
				}
				p2->data[y2++] = ch;
				if (y2 == BLOCK_SIZE) {
					TAILQ_INSERT_TAIL(&diff_b_head, p2, entry);
					p2 = alloc_block();
					y2 = 0;
				}
				if ((ch & 0xFF) == '\n')
					break;
			}
			break;
	parse_filename:
			for (x += 3; x != size; x++) {
				ch = peek_block(&diff_head, x);
				chn = peek_block(&diff_head, x + 1);
				if ((ch & 0xFF) == '.') {
					/* only accept .c and .h files */
					do_parse = ((chn & 0xFF) == 'c' || (chn & 0xFF) == 'h');
				}
				if ((ch & 0xFF) == '\n')
					break;
			}
		default:
			break;
		}
		/* skip till end of line */
		for (; x < size; x++) {
			ch = peek_block(&diff_head, x);
			if ((ch & 0xFF) == '\n') {
				x++;
				break;
			}
		}
	}
	p1->length = y1;
	p2->length = y2;
	TAILQ_INSERT_TAIL(&diff_a_head, p1, entry);
	TAILQ_INSERT_TAIL(&diff_b_head, p2, entry);

	/* first pass - verify input */
	size = size_block(&diff_a_head);
	for (x = 0; x != size; x++) {
		ch = peek_block(&diff_a_head, x) & 0xFF;
		if (!(ch & 0x80) && ch != '\t' && ch != '\r' && ch != '\n' &&
		    ch != ' ' && !isprint(ch))
			errx(EX_SOFTWARE, "Non printable characters are not allowed: '%c'", ch);
		else if (ch & 0x80) {
			set_block(&diff_a_head, x, ch | BLOCK_MASK);
		}
	}

	/* second pass - identify all comments */
	for (x = 0; x < size; x++) {
		ch = peek_block(&diff_a_head, x);
		chn = peek_block(&diff_a_head, x + 1);
		if ((ch & 0xFF) == '/' && (chn & 0xFF) == '/') {
			set_block(&diff_a_head, x, ch | BLOCK_MASK);
			set_block(&diff_a_head, x + 1, chn | BLOCK_MASK);
			for (x += 2; x < size; x++) {
				ch = peek_block(&diff_a_head, x);
				if ((ch & 0xFF) == '\n')
					break;
				set_block(&diff_a_head, x, ch | BLOCK_MASK);
			}
		} else if ((ch & 0xFF) == '/' && (chn & 0xFF) == '*') {
			set_block(&diff_a_head, x, ch | BLOCK_MASK);
			set_block(&diff_a_head, x + 1, chn | BLOCK_MASK);
			for (x += 2; x < size; x++) {
				ch = peek_block(&diff_a_head, x);
				chn = peek_block(&diff_a_head, x + 1);
				if ((ch & 0xFF) == '*' && (chn & 0xFF) == '/') {
					set_block(&diff_a_head, x, ch | BLOCK_MASK);
					set_block(&diff_a_head, x + 1, chn | BLOCK_MASK);
					x++;
					break;
				}
				set_block(&diff_a_head, x, ch | BLOCK_MASK);
			}
		}
	}

	/* third pass - identify preprocessor tokens and strings */
	for (x = 0; x < size; x++) {
		ch = peek_block(&diff_a_head, x);
		if (ch & BLOCK_MASK)
			continue;
		if (inside_string == 0 && (ch & 0xFF) == '#') {
			int skip_newline = 0;

			set_block(&diff_a_head, x, ch | BLOCK_MASK);
			for (x++; x < size; x++) {
				ch = peek_block(&diff_a_head, x);
				if ((ch & 0xFF) == '\n') {
					if (!skip_newline)
						break;
					skip_newline = 0;
				}
				if (ch & BLOCK_MASK)
					continue;
				if ((ch & 0xFF) == '\\')
					skip_newline = 1;
				set_block(&diff_a_head, x, ch | BLOCK_MASK);
			}
		}
		if ((ch & 0xFF) == '"' || (ch & 0xFF) == '\'') {
			if (inside_string == 0) {
				inside_string = (ch & 0xFF);
			} else {
				if (escape_char == 0 && inside_string == (ch & 0xFF))
					inside_string = 0;
			}
			escape_char = 0;
			set_block(&diff_a_head, x, ch | BLOCK_MASK);
		} else if (inside_string != 0) {
			if ((ch & 0xFF) == '\\')
				escape_char = !escape_char;
			else
				escape_char = 0;
			set_block(&diff_a_head, x, ch | BLOCK_MASK);
		}
	}

	/* fourth pass - identify function blocks */
	if (opt_verbose > 0) {
		chn = peek_block(&diff_a_head, x);
		printf("L%02d%c|", recurse,
		    (chn & BLOCK_ADD) ? '+' : ' ');
	}
	for (x = 0; x < size; x++) {
		ch = peek_block(&diff_a_head, x);
		if (opt_verbose > 0) {
			printf("%c", ch & 0xFF);
			if ((ch & 0xFF) == '\n') {
				chn = peek_block(&diff_a_head, x + 1);
				printf("L%02d%c|", recurse,
				    (chn & BLOCK_ADD) ? '+' : ' ');
			}
		}
		if (ch & BLOCK_MASK)
			continue;
		switch (ch & 0xFF) {
		case '{':
		case '(':
			recurse++;
			break;
		default:
			break;
		}
		if (recurse != 0)
			set_block(&diff_a_head, x, ch | BLOCK_MASK);
		switch (ch & 0xFF) {
		case '}':
		case ')':
			recurse--;
			break;
		default:
			break;
		}
	}
	if (opt_verbose > 0)
		printf("\n");
	if (recurse != 0)
		errx(EX_SOFTWARE, "Unbalanced parenthesis");
	if (inside_string != 0)
		errx(EX_SOFTWARE, "String without end");

	/* fifth pass - on the same line statements */
	for (x = 0; x < size; x++) {
		ch = peek_block(&diff_a_head, x);
		if (ch & BLOCK_MASK)
			continue;
		switch (ch & 0xFF) {
		case '\n':
			break;
		default:
			set_block(&diff_a_head, x, ch | BLOCK_MASK);
			break;
		}
	}

	/* sixth pass - output relevant blocks to indent */
	for (y1 = x = 0; x < size; x++) {
		ch = peek_block(&diff_a_head, x);
		if (ch & BLOCK_ADD) {
			TAILQ_INIT(&indent_in_head);

			p2 = alloc_block();
			y2 = 0;
			for (; y1 < size; y1++) {
				ch = peek_block(&diff_a_head, y1);
				if (y1 > x && !(ch & (BLOCK_MASK | BLOCK_ADD)))
					break;
				p2->data[y2++] = ch & 0xFF;
				if (y2 == BLOCK_SIZE) {
					TAILQ_INSERT_TAIL(&indent_in_head, p2, entry);
					p2 = alloc_block();
					y2 = 0;
				}
			}
			if (p2->data[y2] != '\n')
				p2->data[y2++] = '\n';
			p2->length = y2;
			TAILQ_INSERT_TAIL(&indent_in_head, p2, entry);

			cmd_block_process(&indent_in_head, &indent_out_head,
			    "indent "
			    "-Tbool "
			    "-Tclass "
			    "-TFILE "
			    "-TLIST_ENTRY "
			    "-TLIST_HEAD "
			    "-TSLIST_ENTRY "
			    "-TSLIST_HEAD "
			    "-TSTAILQ_ENTRY "
			    "-TSTAILQ_HEAD "
			    "-TTAILQ_ENTRY "
			    "-TTAILQ_HEAD "
			    "-T__aligned "
			    "-T__packed "
			    "-T__unused "
			    "-T__used "
			    "-Tfd_set "
			    "-Toss_mixerinfo "
			    "-Tu_char "
			    "-Tu_int "
			    "-Tu_long "
			    "-Tu_short "
			    "-ta -st -bad -bap -nbbb -nbc -br -nbs "
			    "-c41 -cd41 -cdb -ce -ci4 -cli0 -d0 -di8 -ndj -ei -nfc1 "
			    "-nfcb -i8 -ip8 -l79 -lc77 -ldi0 -nlp -npcs -psl -sc "
			    "-nsob -nv "
			    " | "
			    "sed "
			    "-e 's/_HEAD [(]/_HEAD(/g' "
			    "-e 's/_ENTRY [(]/_ENTRY(/g' "
			    "-e 's/\t__aligned/ __aligned/g' "
			    "-e 's/\t__packed/ __packed/g' "
			    "-e 's/\t__unused/ __unused/g' "
			    "-e 's/\t__used/ __used/g' "
			    "-e 's/^#define /#define\t/g'");

			if (opt_diff_tool != NULL) {
				if (diff_tool(&indent_in_head, &indent_out_head))
					retval = 1;
			} else {
				if (diff_block(&indent_in_head, &indent_out_head))
					retval = 1;
			}
			free_block(&indent_in_head);
			free_block(&indent_out_head);
			x = y1;
		} else if (!(ch & BLOCK_MASK)) {
			y1 = x + 1;
		}
	}
	return (retval);
}