#include "common.h"

#define is_digit(c) ((c) >= '0' && (c) <= '9')

static uint32_t parse_int(const char **sp)
{
	const char *s = *sp;
	uint32_t n = 0;
	
	while (is_digit(*s)) {
		n *= 10;
		n += *s++ - '0';
	}
	
	*sp = s;
	return n;
}

static const char *op_name(int op)
{
	switch (op) {
		case OP_COPY:
			return "copy";
		case OP_SKIP:
			return "skip";
		case OP_INSERT:
			return "insert";
		
		default:
			return "<invalid opcode>";
	}
}

static const char *verify_csi32(
	const unsigned char *patch_start, const unsigned char *patch_end,
	const char *expected)
{
	const unsigned char *p = patch_start;
	
	if (p >= patch_end)
		return "Patch type byte missing";
	if (*p++ != PT_CSI32)
		return "Patch type byte is not PT_CSI32";
	
	for (;;) {
		int patch_op;
		uint32_t patch_size;
		int expected_op;
		uint32_t expected_size;
		
		while (*expected == ' ')
			expected++;
		if (*expected == '\0')
			break;
		
		if (!csi32_parse_op(&p, patch_end, &patch_op, &patch_size)) {
			if (p == patch_end)
				return "Patch shorter than expected.";
			else
				return "Patch contains invalid CSI-32";
		}
		
		switch (*expected) {
			case 'c':
				expected_op = OP_COPY;
				break;
			case 's':
				expected_op = OP_SKIP;
				break;
			case 'i':
				expected_op = OP_INSERT;
				break;
			
			default:
				diag("verify_csi32: Unexpected character %c", *expected);
				return "Syntax error in expected difference";
		}
		expected++;
		
		while (*expected == ' ')
			expected++;
		
		if (patch_op != expected_op) {
			diag("verify_csi32: Expected %s, but next op is %s %lu",
			     op_name(expected_op), op_name(patch_op), (unsigned long)patch_size);
			return "Operation mismatch";
		}
		
		if (expected_op == OP_COPY || expected_op == OP_SKIP) {
			if (!is_digit(*expected)) {
				diag("verify_csi32: Expected size after %s instruction",
				     op_name(expected_op));
				return "Syntax error in expected difference";
			}
			expected_size = parse_int(&expected);
			
			if (patch_size != expected_size) {
				diag("verify_csi32: Expected %s %lu, but patch says %s %lu",
				     op_name(expected_op), (unsigned long)expected_size,
				     op_name(expected_op), (unsigned long)patch_size);
				return "Operation size mismatch";
			}
		} else {
			if (*expected++ != '\'') {
				diag("verify_csi32: Expected single-quoted string after insert instruction");
				return "Syntax error in expected difference";
			}
			
			for (expected_size = 0; ; expected_size++) {
				unsigned char c;
				
				if (*expected == '\'' && *(expected + 1) == '\'') {
					c = '\'';
					expected += 2;
				} else if (*expected == '\'') {
					expected++;
					break;
				} else if (*expected == '\0') {
					diag("verify_csi32: Missing end quote");
					return "Syntax error in expected difference";
				} else {
					c = *expected++;
				}
				
				if (!(p < patch_end && *p++ == c))
					return "Insertion string mismatch";
			}
			
			if (patch_size != expected_size)
				return "Insertion string mismatch";
		}
	}
	
	if (p != patch_end)
		return "Patch longer than expected.";
	
	return NULL;
}

static void test_myers(const char *old, const char *new_, const char *expected_difference)
{
	SB patch;
	BDELTAcode rc;
	const char *verify_msg;
	
	if (sb_init(&patch) != 0) {
		fail("Out of memory");
		return;
	}
	
	rc = diff_myers(old, strlen(old), new_, strlen(new_), &patch);
	if (rc != BDELTA_OK) {
		fail("test_myers(%s, %s, %s): diff_myers failed: %s", old, new_, expected_difference, bdelta_strerror(rc));
		sb_discard(&patch, NULL, NULL);
		return;
	}
	
	verify_msg = verify_csi32(patch.start, patch.cur, expected_difference);
	sb_discard(&patch, NULL, NULL);
	
	if (verify_msg != NULL) {
		fail("test_myers(%s, %s, %s): %s", old, new_, expected_difference, verify_msg);
		return;
	}
	
	pass("test_myers(%s, %s, %s)", old, new_, expected_difference);
}

int main(void)
{
	(void) random_string_pair;
	
	plan_tests(17);
	
	test_myers("abcabba", "cbabac",   "s2 c1 i'b' c2 s1 c1 i'c'");
	test_myers("abcdefg", "abcdefg",  "c7");
	test_myers("abcdefg", "abcde",    "c5");
	test_myers("abcdefg", "abcdefga", "c7 i'a'");
	test_myers("abbbbbb", "bbbbbb",   "s1 c6");
	test_myers("abbbbbb", "bbbbbbb",  "s1 c6 i'b'");
	test_myers("bbbbbb",  "abbbbbb",  "i'a' c6");
	test_myers("bbbbbbb", "abbbbbb",  "i'a' c6");
	test_myers("bbbbbb",  "abbbbbbb", "i'a' c6 i'b'");
	
	test_myers("ac",   "ba",   "i'b' c1");
	test_myers("ac",   "bc",   "s1 i'b' c1");
	test_myers("abcd", "cabd", "i'c' c2 s1 c1");
	test_myers("",     "abc",  "i'abc'");
	test_myers("abc",  "",     "");
	test_myers("abcd", "d",    "s3 c1");
	test_myers("", "", "");
	
	/*
	 * In the event the strings have no characters in common, diff_myers will
	 * emit a skip of all the characters in the old string.  Although it is
	 * unnecessary, it is tricky to get rid of.  bdelta_diff will discard the
	 * patch anyway, because it's bigger than a literal.
	 */
	test_myers("aaaaaaa", "bbbbbbb",  "s7 i'bbbbbbb'");
	
	return exit_status();
}