#include <stdio.h>
#include "main.h"

struct test
{
	char * regex;
	struct match
	{
		char * s;
		int expect;
	} matches[0xff];
} test_suite[] = 
{
	// Basic
	{"abc", {{"a", 0},{"abc", 1}, {"abcd",0 }, {NULL}}},
	{"a.c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"aac", 1}, {NULL}}},
	{"ab+c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 0}, {NULL}}},
	{"ab*c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {NULL}}},
	{"ab?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 0}, {"ac", 1}, {NULL}}},

	// . Compose
	{"a..c", {{"a", 0},{"abc", 0}, {"abcd",0 }, {"acc", 0}, {"ac", 0}, {"abbc", 1}, {NULL}}},
	{"a.+c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"ac", 0}, {"abbc", 1}, {NULL}}},
	{"a.*c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"ac", 1}, {"abbc", 1}, {NULL}}},
	{"a.?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"acc", 1}, {"ac", 1}, {NULL}}},

	// TODO: Implement NFA to DFA to avoid loops

	// Equal to *
	{"ab+?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {NULL}}},
	{"ab*?c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {NULL}}},
	//{"ab?+c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"ababc", 1}, {"ac", 1}, {NULL}}},
	//{"ab?*c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"ababc", 1}, {"ac", 1}, {NULL}}},
	{"a+*", {{"aaaa", 1}, {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1}, {NULL}}},
	//{"a**", {{"aaaa", 1}, {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1}, {NULL}}},

	// Nilpotent
	{"ab??c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 0}, {"ac", 1}, {"c", 0}, {NULL}}},
	{"ab++c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 0}, {"c", 0}, {"ababc",0}, {NULL}}},
	//{"ab**c", {{"a", 0},{"abc", 1}, {"abcd",0 }, {"abbc", 1}, {"ac", 1}, {"c", 1}, {"ababc",1}, {NULL}}},

	// UNION
	{"a()", {{"a", 1},{"abc", 0}, {"b", 0 }, {"ba", 0}, {NULL}}},
	{"a(b)", {{"ab", 1},{"abc", 0}, {"b", 0 }, {"ba", 0}, {NULL}}},
	{"a(b)*", {{"ab", 1},{"abb", 1}, {"a", 1 }, {"ba", 0}, {NULL}}},
	{"a|b", {{"a", 1},{"abc", 0}, {"b", 1 }, {"ba", 0}, {NULL}}},
	{"(a|.)*", {{"a", 1},{"abc", 1}, {"b", 1 }, {"ba", 1}, {NULL}}},
	{"(.|a)*", {{"a", 1},{"abc", 1}, {"b", 1 }, {"ba", 1}, {NULL}}},
	{"(b|a)*", {{"a", 1},{"cab", 0}, {"b", 1 }, {"ab", 1}, {"cacb", 0}, {NULL}}},
	{"c(b|a)*", {{"ca", 1},{"cab", 1}, {"b", 0 }, {"bb", 0}, {"cacb", 0}, {NULL}}},
	{"ab|b", {{"ab", 1}, {"b", 1}, {"abb", 0}, {NULL}}},
	{"a|b|c", {{"a", 1}, {"b", 1}, {"c", 1},{"d",0},  {NULL}}},
	{"((a|b)|c)d", {{"ad", 1}, {"bd", 1}, {"cd", 1},{"a",0},  {NULL}}},

	// BLOCK
	{"(abb", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
	{"abb)", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
	{"a(bb", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
	{"ab)b", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
	{"(ab)b", {{"abb", 1}, {"ab", 0}, {"b", 0}, {NULL}}},
	{"(ab)+", {{"ab", 1}, {"abab", 1}, {"b", 0}, {NULL}}},
	{"(a(bc)*)", {{"a", 1}, {"abc", 1}, {"abb", 0}, {NULL}}},
	{"(ab|cd)", {{"ab", 1}, {"cd", 1}, {"abcd", 0}, {NULL}}},

	// REDOS
	{"a*b?a*", {{"aaa", 1}, {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaba", 1}, {NULL}}},
} ;


int main(void)
{
	int i=0, j=0;

	for(i =0; i<sizeof(test_suite)/sizeof(*test_suite); ++i)
	{
		struct test t = test_suite[i];
		struct rgx_nfa * nfa;

		printf("\n\t%s\n", t.regex);
		nfa = rgx_compile(NULL, t.regex, 1);

		if (!nfa ){
			printf("Malformed\n");
			continue;
		}

		for( struct match * m = t.matches; m->s; ++m)
		{
			int res;
			res = rgx_run(nfa, m->s); 
			printf("%s: %d %s\n", res == m->expect?"PASS":"FAIL", res, m->s);
		}
	}
}