#include <check.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>


#include "ttail.h"
#include "ttail_init.h"

ttail_t *ttail;
#define __Fname_sz 5
#define FNAME_NO_EXIST 0
#define FNAME_EXIST 1
char *fname[__Fname_sz];

void teardown_ttail(void)
{
	ttail_free(ttail);
}
/*
 * Empty argument parsing test case
 */
void setup_ttail_empty(void)
{
	ttail = ttail_init(1, (char**)&"foo");
}
START_TEST (test_argparse_empty_logfilename)
{
	ck_assert_msg(ttail->logfile_name == NULL,
		"ttail_t.logfile_name should be NULL");
}
END_TEST
START_TEST (test_argparse_empty_logfile)
{
	ck_assert_msg(ttail->logfile == NULL,
		"ttail_t.logfile should be NULL");
}
END_TEST
START_TEST (test_argparse_empty_logfilesz)
{
	ck_assert_msg(ttail->logfile_sz == 0,
		"ttail_t.logfile_sz should be 0");
}
END_TEST
START_TEST (test_argparse_empty_flag)
{
	ck_assert_msg(ttail->flag == 0,
		"ttail_t.flag should be 0");
}
END_TEST
START_TEST (test_argparse_empty_fmt)
{
	ck_assert_msg(ttail->fmt == NULL,
		"ttail_t.fmt should be NULL");
}
END_TEST
START_TEST (test_argparse_empty_verbose)
{
	ck_assert_msg(ttail->verbose == 0,
		"ttail_t.verbose should be 0");
}
END_TEST

/*
 * Bad arguments
 */

START_TEST (test_argparse_bad1)
{
	ttail_t *t;
	char *args[] = {"foo", "--sdfsdf"};
	t = ttail_init(2, args);
	ck_assert(t == NULL);
}
END_TEST

START_TEST (test_argparse_bad2)
{
	ttail_t *t;
	char *args[] = {"foo", "-x"};
	t = ttail_init(2, args);
	ck_assert(t == NULL);
}
END_TEST

START_TEST (test_argparse_bad3)
{
	ttail_t *t;
	char *args[] = {"foo", "-p"};
	t = ttail_init(2, args);
	ck_assert(t == NULL);
}
END_TEST

START_TEST (test_argparse_bad4)
{
	ttail_t *t;
	char *args[] = {"foo", "-f"};
	t = ttail_init(2, args);
	ck_assert(t == NULL);
}
END_TEST

START_TEST (test_argparse_bad5)
{
	ttail_t *t;
	char *args[] = {"foo", "-d"};
	t = ttail_init(2, args);
	ck_assert(t == NULL);
}
END_TEST

START_TEST (test_argparse_bad6)
{
	ttail_t *t;
	char *args[] = {"foo", "-m"};
	t = ttail_init(2, args);
	ck_assert(t == NULL);
}
END_TEST

START_TEST (test_argparse_bad7)
{
	ttail_t *t;
	char *args[] = {"foo", "-l"};
	t = ttail_init(2, args);
	ck_assert(t == NULL);
}
END_TEST


/*
 * file argument parsing
 */

void setup_fname(void)
{
	int i;
	FILE *fp;
	for(i=0;i<__Fname_sz;i++)
	{
		fname[i] = NULL;
	}

	for(i=0; i<__Fname_sz; i++)
	{
		fname[i] = tempnam(NULL, "ttail_check");
		if(i%2)
		{
			if((fp=fopen(fname[i], "w+")) == NULL)
			{
				perror("Unable to create file for testing");
				ck_abort_msg("Unable to create file for testing");
			}
			if(fclose(fp))
			{
				perror("Unable to close file for testing");
				ck_abort_msg("Unable to close file for testing");

			}
		}
	}
}

void teardown_fname(void)
{
	int i;
	for(i=0; i<__Fname_sz; i++)
	{
		unlink(fname[i]);
		if(fname[i] != NULL)
		{
			free(fname[i]);
		}
	}
}

START_TEST (test_argparse_file_non_exist)
{
	ttail_t *t;
	char *args[3] = {"foo", "-l", NULL};

	args[2] = fname[FNAME_NO_EXIST];
	t = ttail_init(3, args);
	ck_assert_msg(t != NULL, "init failed");

	ck_assert_msg(t->logfile_sz == 1,
		"ttail_t.logfile_sz should be 1");
	ck_assert_msg(strcmp(t->logfile_name[0], args[2]) == 0,
		"ttail_t.logfile_name[0] does not contain the filename");
	ck_assert_msg(t->logfile[0] == NULL,
		"ttail_t.logfile[0] should be NULL");
	
	ttail_free(t);

}
END_TEST

START_TEST (test_argparse_file_exist)
{
	ttail_t *t;
	char *args[3] = {"foo", "-l", NULL};

	args[2] = fname[FNAME_EXIST];

	t = ttail_init(3, args);
	ck_assert_msg(t != NULL, "init failed");

	ck_assert_msg(t->logfile_sz == 1,
		"ttail_t.logfile_sz should be 1");
	ck_assert_msg(strcmp(t->logfile_name[0], args[2]) == 0,
		"ttail_t.logfile_name[0] does not contain the filename");
	ck_assert_msg(t->logfile[0] != NULL,
		"ttail_t.logfile[0] shouldn't be NULL");
	
	ttail_free(t);

}
END_TEST

START_TEST (test_argparse_file_multiple)
{
	ttail_t *t;
	int i;
	char *args[11] = {"foo", "-l", NULL, "-l", NULL,
		"-l", NULL, "-l", NULL, "-l", NULL};
	
	for(i=0; i<__Fname_sz; i++)
	{
		args[(i*2)+2] = fname[i];
	}

	t = ttail_init(11, args);
	ck_assert_msg(t != NULL, "init failed");
	
	ck_assert_msg(t->logfile_sz == __Fname_sz,
		"ttail_t.logfile_sz doesn't have the good value");

	for(i=0;i<__Fname_sz; i++)
	{
		ck_assert_msg(strcmp(t->logfile_name[i], args[(i*2)+2]) == 0,
			"some filename corrupted in ttail_t.logfile_name");
		if(i%2)
		{
			ck_assert_msg(t->logfile[i] != NULL,
				"logfile not opened");
		} else {
			ck_assert_msg(t->logfile[i] == NULL,
				"logfile should be NULL");

		}
	}

	
}
END_TEST

START_TEST (test_argparse_prefix_short)
{
	ttail_t *t;
	char *args[] = {"foo", "-p", "^[^ ]+ "};
	t = ttail_init(3, args);
	ck_assert(t != NULL);
	ck_assert((t->flag & TTAIL_FLAG_PREFIX) == TTAIL_FLAG_PREFIX);
}
END_TEST

START_TEST (test_argparse_prefix_long)
{
	ttail_t *t;
	char *args[] = {"foo", "--re-prefix", "^[^ ]+ "};
	t = ttail_init(3, args);
	ck_assert(t != NULL);
	ck_assert((t->flag & TTAIL_FLAG_PREFIX) == TTAIL_FLAG_PREFIX);
}
END_TEST

START_TEST (test_argparse_prefix_multiple)
{
	ttail_t *t;
	char *args[] = {"foo", "--re-prefix", "^[^ ]+ ", "-p", "^[ -]+ "};
	t = ttail_init(5, args);
	ck_assert(t == NULL);
}
END_TEST

START_TEST (test_argparse_fmt_short)
{
	ttail_t *t;
	char *args[] = {"foo", "-f", "%m"};
	t = ttail_init(3, args);
	ck_assert(t != NULL);
}
END_TEST

START_TEST (test_argparse_fmt_long)
{
	ttail_t *t;
	char *args[] = {"foo", "--date-format", "%m"};
	t = ttail_init(3, args);
	ck_assert(t != NULL);
}
END_TEST

START_TEST (test_argparse_fmt_multiple)
{
	ttail_t *t;
	char *args[] = {"foo", "-f", "%m", "-f", "%d"};
	t = ttail_init(5, args);
	ck_assert(t == NULL);
}
END_TEST

Suite * ttail_init_suite(void)
{
	Suite *s;
	TCase *tc_argparse_empty;
	TCase *tc_argparse_badarg;
	TCase *tc_argparse_files;
	TCase *tc_argparse_prefix;
	TCase *tc_argparse_fmt;

	s = suite_create("ttail argument parsing checks");

	tc_argparse_empty = tcase_create("empty arguments parsing");
	tcase_add_checked_fixture(tc_argparse_empty,
		setup_ttail_empty, teardown_ttail);
	tcase_add_test(tc_argparse_empty, test_argparse_empty_logfilename);
	tcase_add_test(tc_argparse_empty, test_argparse_empty_logfile);
	tcase_add_test(tc_argparse_empty, test_argparse_empty_logfilesz);
	tcase_add_test(tc_argparse_empty, test_argparse_empty_flag);
	tcase_add_test(tc_argparse_empty, test_argparse_empty_fmt);
	tcase_add_test(tc_argparse_empty, test_argparse_empty_verbose);

	tc_argparse_badarg = tcase_create("bad arguments parsing");
	tcase_add_test(tc_argparse_badarg, test_argparse_bad1);
	tcase_add_test(tc_argparse_badarg, test_argparse_bad2);
	tcase_add_test(tc_argparse_badarg, test_argparse_bad3);
	tcase_add_test(tc_argparse_badarg, test_argparse_bad4);
	tcase_add_test(tc_argparse_badarg, test_argparse_bad5);
	tcase_add_test(tc_argparse_badarg, test_argparse_bad6);
	tcase_add_test(tc_argparse_badarg, test_argparse_bad7);

	tc_argparse_files = tcase_create("files options parse");
	tcase_add_checked_fixture(tc_argparse_files,
		setup_fname, teardown_fname);
	tcase_add_test(tc_argparse_files, test_argparse_file_non_exist);
	tcase_add_test(tc_argparse_files, test_argparse_file_exist);
	tcase_add_test(tc_argparse_files, test_argparse_file_multiple);

	tc_argparse_prefix = tcase_create("re-prefix arguments parsing");
	tcase_add_test(tc_argparse_prefix, test_argparse_prefix_short);
	tcase_add_test(tc_argparse_prefix, test_argparse_prefix_long);
	tcase_add_test(tc_argparse_prefix, test_argparse_prefix_multiple);

	tc_argparse_fmt = tcase_create("date format arguments parsing");
	tcase_add_test(tc_argparse_fmt, test_argparse_fmt_short);
	tcase_add_test(tc_argparse_fmt, test_argparse_fmt_long);
	tcase_add_test(tc_argparse_fmt, test_argparse_fmt_multiple);

	suite_add_tcase(s, tc_argparse_empty);
	suite_add_tcase(s, tc_argparse_badarg);
	suite_add_tcase(s, tc_argparse_files);
	suite_add_tcase(s, tc_argparse_prefix);
	suite_add_tcase(s, tc_argparse_fmt);
	return s;
}

int main(void)
{
	int number_failed = 0;
	SRunner *sr;

	sr = srunner_create(ttail_init_suite());
	srunner_set_fork_status(sr, CK_FORK);

	srunner_run_all(sr,CK_VERBOSE);
	number_failed = srunner_ntests_failed(sr);
	srunner_free(sr);
	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;

}