#include <stdlib.h>
#include <check.h>
#include <time.h>
#include <stdio.h>
#include "logger.h"

pyfcgi_conf_logger_t *conf = &PyFCGI_conf.logs;

START_TEST(test_logger_init)
{

	pyfcgi_logger_init();
	ck_assert_ptr_eq(conf->syslog_ident, NULL);
	ck_assert_ptr_eq(conf->ident, NULL);
	ck_assert_ptr_eq(conf->format, NULL);
	ck_assert_ptr_eq(conf->loggers, NULL);
	ck_assert_int_eq(conf->logger_sz, 0);
	ck_assert_int_eq(conf->format_sz, 0);
	ck_assert_int_eq(conf->flags, 0);

}
END_TEST

/*
START_TEST(test_logger_format_add)
{
	int ret;
	size_t s;
	pyfcgi_logger_init();

	ret = pyfcgi_logger_format_add("TEST", NULL);
	ck_assert_int_eq(conf->format_sz, 1);
	ck_assert_str_eq(conf->format[0], "TEST");
}
END_TEST
*/

START_TEST(test_logger_parse_field_dtfmt_default)
{
	int ret;
	char *ptr, *orig, *fmt;

	orig = "}";
	ptr = orig;
	fmt = NULL;

	ret = pyfcgi_logger_parse_field_dtfmt((const char**)&ptr, &fmt);
	ck_assert_int_eq(ret, 0);
	ck_assert_str_eq(fmt, PYFCGI_LOGGER_TIME_FMT_DEFAULT);
	ck_assert_ptr_eq(ptr, orig+1);
	free(fmt);
}
END_TEST

START_TEST(test_logger_parse_field_sz_default)
{
	int ret;
	size_t val;
	char *ptr, **orig;
	char *vals[] = {":%F}", ":}", "}", NULL};

	orig = vals;
	while(*orig)
	{
		ptr = *orig;

		ret = pyfcgi_logger_parse_field_sz((const char**)&ptr, &val);
		ck_assert_int_eq(val, 0);
		ck_assert_ptr_eq(ptr, (*orig)+1);
		orig++;
	}
}
END_TEST

START_TEST(test_logger_parse_field_datetime_default)
{
	int ret;
	char *ptr, **orig, err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
	pyfcgi_logger_fmt_field_t field;
	char *vals[] = {"datetime}", "datetime::}", "datetime:}", NULL};

	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));

	orig = vals;
	while(*orig)
	{
		ptr = *orig;

		ret = pyfcgi_logger_parse_field((const char**)&ptr,
		                                (const char*)ptr, &field,
						err);
		if(ret)
		{
			dprintf(2, "ERROR : '%s'\n", err);
		}
		ck_assert_int_eq(ret, 0);
		ck_assert_int_eq(field.type, pyfcgi_logger_field_datetime);
		ck_assert_int_ne(field.known_length, 0);
		ck_assert_int_eq(field.len, PYFCGI_LOG_DTM_LEN);
		ck_assert_ptr_eq(field.val, strftime);
		ck_assert_str_eq(field.args.datetime.format,
		                 PYFCGI_LOGGER_TIME_FMT_DEFAULT);
		ck_assert_ptr_eq(field.buf_ptr, NULL);
		orig++;
	}
}
END_TEST

START_TEST(test_logger_parse_field_sz)
{
	int ret, *res;
	size_t val;
	char *ptr, **orig;
	char *vals[] = {"42:%F}", "1337:}", "0}", NULL};
	int _res[] = {42,1337,0};

	orig = vals;
	res = _res;
	while(*orig)
	{
		ptr = *orig;

		ret = pyfcgi_logger_parse_field_sz((const char**)&ptr, &val);
		ck_assert_int_eq(val, *res);
		ck_assert_ptr_eq(ptr, (*orig)+snprintf(NULL, 0, "%d", *res));
		orig++;
		res++;
	}
}
END_TEST

START_TEST(test_logger_parse_field_dtfmt)
{
	int ret;
	size_t len;
	char **val, **ptr, *fmt;
	char *_vals[] = {"%fdc}", "123}", "4}}foo}", NULL};

	val = _vals;
	while(*val)
	{
		ptr = val;
		len = strlen(*val);

		ret = pyfcgi_logger_parse_field_dtfmt((const char**)&ptr, &fmt);
		*val[len-1] = '\0'; //deleting leading '}' to get expected result
		ck_assert_int_eq(ret, 0);
		ck_assert_ptr_ne(fmt, *val);
		ck_assert_str_eq(fmt, *val);
		ck_assert_ptr_eq(ptr, *val+len-1);
		free(fmt);
		val++;
	}

}
END_TEST

START_TEST(test_logger_parse_field_datetime)
{
	int ret, *len;
	char *ptr, **orig, **fmt, err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
	pyfcgi_logger_fmt_field_t field;
	char *vals[] = {"datetime:42}", "datetime::%s%F}",
	                "datetime:42:COUCOU}",
			"dat:32:FOO}", "d::BAR}", NULL};
	int _len[] = {42, PYFCGI_LOG_DTM_LEN, 42, 32, PYFCGI_LOG_DTM_LEN};
	char *_fmt[] = {PYFCGI_LOGGER_TIME_FMT_DEFAULT, "%s%F", "COUCOU", "FOO",
	                "BAR"};

	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));
	
	len = _len;
	fmt = _fmt;
	orig = vals;
	while(*orig)
	{
		ptr = *orig;

		ret = pyfcgi_logger_parse_field((const char**)&ptr,
		                                (const char*)ptr, &field,
						err);
		if(ret)
		{
			dprintf(2, "ERROR : '%s'\n", err);
		}
		ck_assert_int_eq(ret, 0);
		ck_assert_int_eq(field.type, pyfcgi_logger_field_datetime);
		ck_assert_int_ne(field.known_length, 0);
		ck_assert_int_eq(field.len, *len);
		ck_assert_ptr_eq(field.val, strftime);
		ck_assert_str_eq(field.args.datetime.format, *fmt);
		ck_assert_ptr_eq(field.buf_ptr, NULL);
		orig++;
		len++;
		fmt++;
	}
}
END_TEST

START_TEST(test_logger_parse_field_level)
{
	int ret;
	char **val, **ptr;
	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
	char *vals[] = {"level}", "l}", "leve}", NULL};
	pyfcgi_logger_fmt_field_t field;

	val = vals;
	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));

	while(*val)
	{
		ptr = val;
		ret = pyfcgi_logger_parse_field((const char**)ptr,
		                                (const char*)*ptr, &field,
						err);
		if(ret)
		{
			dprintf(2, "ERROR : '%s'\n", err);
		}
		ck_assert_int_eq(ret, 0);
		ck_assert_int_eq(field.type, pyfcgi_logger_field_level);
		ck_assert_int_ne(field.known_length, 0);
		ck_assert_int_eq(field.len, PYFCGI_LOG_LVL_LEN);
		ck_assert_ptr_eq(field.val, pyfcgi_logger_value_level);
		val++;
	}
}
END_TEST

START_TEST(test_logger_parse_field_facility)
{
	int ret;
	char **val, **ptr;
	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
	char *vals[] = {"facility}", "f}", "fac}", NULL};
	pyfcgi_logger_fmt_field_t field;

	val = vals;
	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));

	while(*val)
	{
		ptr = val;
		ret = pyfcgi_logger_parse_field((const char**)ptr,
		                                (const char*)*ptr, &field,
						err);
		if(ret)
		{
			dprintf(2, "ERROR : '%s'\n", err);
		}
		ck_assert_int_eq(ret, 0);
		ck_assert_int_eq(field.type, pyfcgi_logger_field_facility);
		ck_assert_int_ne(field.known_length, 0);
		ck_assert_int_eq(field.len, PYFCGI_LOG_TYP_LEN);
		ck_assert_ptr_eq(field.val, pyfcgi_logger_value_facility);
		val++;
	}
}
END_TEST

START_TEST(test_logger_parse_field_pid)
{
	int ret;
	char **val, **ptr;
	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
	char *vals[] = {"pid}", "p}", "pi}", NULL};
	pyfcgi_logger_fmt_field_t field;

	val = vals;
	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));

	while(*val)
	{
		ptr = val;
		ret = pyfcgi_logger_parse_field((const char**)ptr,
		                                (const char*)*ptr, &field,
						err);
		if(ret)
		{
			dprintf(2, "ERROR : '%s'\n", err);
		}
		ck_assert_int_eq(ret, 0);
		ck_assert_int_eq(field.type, pyfcgi_logger_field_pid);
		ck_assert_int_ne(field.known_length, 0);
		ck_assert_int_eq(field.len, PYFCGI_LOG_PID_LEN);
		ck_assert_ptr_eq(field.val, (&PyFCGI_conf.context.pid));
		val++;
	}
}
END_TEST

START_TEST(test_logger_parse_field_ident)
{
	int ret;
	char **val, **ptr;
	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
	char *vals[] = {"ident}", "i}", "id}", NULL};
	pyfcgi_logger_fmt_field_t field;

	val = vals;
	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));

	while(*val)
	{
		ptr = val;
		ret = pyfcgi_logger_parse_field((const char**)ptr,
		                                (const char*)*ptr, &field,
						err);
		if(ret)
		{
			dprintf(2, "ERROR : '%s'\n", err);
		}
		ck_assert_int_eq(ret, 0);
		ck_assert_int_eq(field.type, pyfcgi_logger_field_ident);
		ck_assert_int_ne(field.known_length, 0);
		ck_assert_int_eq(field.len, 0);
		ck_assert_ptr_eq(field.val, (&PyFCGI_conf.logs.ident));
		val++;
	}
}
END_TEST


START_TEST(test_logger_parse_field_msg)
{
	int ret;
	char **val, **ptr;
	char err[PYFCGI_LOGGER_FMT_PARSE_ERRSZ];
	char *vals[] = {"msg}", "m}", "ms}", NULL};
	pyfcgi_logger_fmt_field_t field;

	val = vals;
	memset(&field, 0, sizeof(pyfcgi_logger_fmt_field_t));

	while(*val)
	{
		ptr = val;
		ret = pyfcgi_logger_parse_field((const char**)ptr,
		                                (const char*)*ptr, &field,
						err);
		if(ret)
		{
			dprintf(2, "ERROR : '%s'\n", err);
		}
		ck_assert_int_eq(ret, 0);
		ck_assert_int_eq(field.type, pyfcgi_logger_field_msg);
		ck_assert_int_eq(field.known_length, 0);
		ck_assert_int_eq(field.len, 0);
		ck_assert_ptr_eq(field.val, NULL);
		val++;
	}
}
END_TEST

Suite * logger_suite(void)
{
	Suite *s;
	TCase *tc_init, *tc_fmt, *tc_fmt_default;

	s = suite_create("Logger");

	tc_init = tcase_create("Initialisation");
	tcase_add_test(tc_init, test_logger_init);
	//tcase_add_test(tc_init, test_logger_format_add);
	suite_add_tcase(s, tc_init);

	tc_fmt_default = tcase_create("Logger format parsing default values");
	tcase_add_test(tc_fmt_default, test_logger_parse_field_dtfmt_default);
	tcase_add_test(tc_fmt_default, test_logger_parse_field_sz_default);
	tcase_add_test(tc_fmt_default, test_logger_parse_field_datetime_default);
	suite_add_tcase(s, tc_fmt_default);

	tc_fmt = tcase_create("Logger format parsing");
	tcase_add_test(tc_fmt, test_logger_parse_field_sz);
	tcase_add_test(tc_fmt, test_logger_parse_field_datetime);
	tcase_add_test(tc_fmt, test_logger_parse_field_level);
	tcase_add_test(tc_fmt, test_logger_parse_field_facility);
	tcase_add_test(tc_fmt, test_logger_parse_field_pid);
	tcase_add_test(tc_fmt, test_logger_parse_field_ident);
	tcase_add_test(tc_fmt, test_logger_parse_field_msg);
	suite_add_tcase(s, tc_fmt);

	return s;
}

int main(void)
{
	int nfailed;
	Suite *s;
	SRunner *sr;

	s = logger_suite();
	sr = srunner_create(s);
	
	//srunner_set_fork_status(sr, CK_NOFORK);
	//srunner_run_all(sr, CK_NORMAL);
	//srunner_run_all(sr, CK_ENV);
	srunner_run_all(sr, CK_VERBOSE);
	nfailed = srunner_ntests_failed(sr);
	srunner_free(sr);
	return (!nfailed)?EXIT_SUCCESS:EXIT_FAILURE;
}