#include <assert.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/param.h>
#include "csuite.h"
#include "ctest.h"
#include "misc.h"
#include "common.h"
#include "../daemond.h"

void
reset_getopt()
{
	optreset = optind = 1;
}

/*	Test Functions		*/
void
test_arg_m(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemond",
			  "-m", "tmpsock"};
	char *pparg2[] = {"daemond",
			  "-m", "/some/nonexistent/file321"};
	char *pparg3[] = {"daemond"};

	/* The saved path is the same as the given path */
	mksock("tmpsock");
	assert(system("test -S /var/run/log") == 0);
	bzero(&fl, sizeof fl);
	reset_getopt();
	ret = process_args(3, pparg1, &fl);
	ct_test(pt, strncmp(fl.di_sockpath, "tmpsock", MAXPATHLEN) == 0);
	ct_test(pt, ret == 0);
	rmsock("tmpsock");

	/* Returns an error if the file doesn't exist */
	assert(system("test -e /some/nonexistent/file321") != 0);
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg2, &fl)) == -1);

	/* Default value if the option is not overriden */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ret = process_args(1, pparg3, &fl);
	ct_test(pt, strncmp(fl.di_sockpath, DMD_SOCKPATH, sizeof DMD_SOCKPATH) == 0);
}

void
test_arg_p(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemond",
			  "-p", "/bin/echo"};
	char *pparg2[] = {"daemond",
			  "-p", "/some/nonexec/x321"};
	bzero(&fl, sizeof fl);

	/* The saved path is the same as the given path */
	assert(system("test -x /bin/echo") == 0);
	reset_getopt();
	ret = process_args(3, pparg1, &fl);
	ct_test(pt, strncmp(fl.di_cmdpath, "/bin/echo", MAXPATHLEN) == 0);
	ct_test(pt, ret == 0);

	/* Non-existant cmd gives an error */
	assert(system("test -e /some/nonexec/x321") != 0);
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg2, &fl)) == -1);
}

void
test_arg_s(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemond",
			  "-s", "/bin/echo"};
	char *pparg2[] = {"daemond",
			  "-s", "/some/nonexec/x321"};
	bzero(&fl, sizeof fl);

	/* The saved path is the same as the given path */
	assert(system("test -x /bin/echo") == 0);
	reset_getopt();
	ret = process_args(3, pparg1, &fl);
	ct_test(pt, strncmp(fl.di_scriptpath, "/bin/echo", MAXPATHLEN) == 0);
	ct_test(pt, ret == 0);

	/* Non-existant cmd gives an error */
	assert(system("test -e /some/nonexec/x321") != 0);
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg2, &fl)) == -1);
}

void
test_arg_r(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemond",
			  "-r", "10"};
	char *pparg2[] = {"daemond",
			  "-r", "-123"};
	char *pparg3[] = {"daemond",
			  "-r", "12c"};
	char *pparg4[] = {"daemond",
			  "-r", "10000000000000"};
	char *pparg5[] = {"daemond",
			  "-r", "-10000000000000"};
	char *pparg6[] = {"daemond"};

	/* Saved value is same as given */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg1, &fl)) == 0);
	ct_test(pt, fl.di_maxtries == 10);

	/* Error on negative numbers */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg2, &fl)) == -1);

	/* Error if number contains alphabets */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg3, &fl)) == -1);

	/* 
	 * Error if it overflows/underflows
	 * XXX - The struct values are supposed to be undefined on
	 *	 error. But I'm taking advantage of the way the code
	 *	 is implemented to make sure it failed for the right reason.
	 */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg4, &fl)) == -1);
	ct_test(pt, fl.di_maxtries == LONG_MAX);
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg5, &fl)) == -1);
	ct_test(pt, fl.di_maxtries == LONG_MIN);

	/* Test the default value when the option isn't overriden */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ret = process_args(1, pparg6, &fl);
	ct_test(pt, fl.di_maxtries == DMD_RESTARTINFINITE);
}

void
test_arg_i(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemond",
			  "-i", "10"};
	char *pparg2[] = {"daemond",
			  "-i", "-123"};
	char *pparg3[] = {"daemond",
			  "-i", "12c"};
	char *pparg4[] = {"daemond",
			  "-i", "1000000000000"};
	char *pparg5[] = {"daemond",
			  "-i", "-100000000000"};
	char *pparg6[] = {"daemon"};

	/* Saved value is same as given */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg1, &fl)) == 0);
	ct_test(pt, fl.di_interval == 10);

	/* Error on negative numbers */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg2, &fl)) == -1);

	/* Error if number contains alphabets */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg3, &fl)) == -1);

	/* 
	 * Error if it overflows/underflows
	 * XXX - The struct values are supposed to be undefined on
	 *	 error. But I'm taking advantage of the way the code
	 *	 is implemented to make sure it failed for the right reason.
	 */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg4, &fl)) == -1);
	ct_test(pt, fl.di_interval == LONG_MAX);
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg5, &fl)) == -1);
	ct_test(pt, fl.di_interval == LONG_MIN);

	/* Test default restart interval when not overriddent from cmdline */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ret = process_args(1, pparg6, &fl);
	ct_test(pt, fl.di_interval == DMD_NOINTERVAL);
}

void test_arg_n(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg[] = {"daemond",
			  "-n", "Subjective Nameaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbb"};
	bzero(&fl, sizeof fl);
	reset_getopt();
	/* Only the first DMD_MAXNAME characters mater */
	ct_test(pt, (ret = process_args(3, pparg, &fl)) == 0);
	ct_test(pt, strcmp(fl.di_name, "Subjective Nameaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") == 0);
}

void
test_arg_P(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemond",
			 "-P", "9999"};
	char *pparg2[] = {"daemond",
			 "-P", "1"};
	char *pparg3[] = {"daemond",
			 "-P", "10g"};

	/* saved same value as given value */
	bzero(&fl, sizeof fl);
	reset_getopt();
	ct_test(pt, (ret = process_args(3, pparg1, &fl)) == 0);
	ct_test(pt, fl.di_pid == 9999);

	/* must not be less than 2 */
	bzero(&fl, sizeof fl);
	reset_getopt();
	ct_test(pt, (ret = process_args(3, pparg2, &fl)) == -1);

	/* must be all numeric */
	bzero(&fl, sizeof fl);
	reset_getopt();
	ct_test(pt, (ret = process_args(3, pparg3, &fl)) == -1);
}

void
test_arg_a(Test* pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemond",
			  "-a", "foo"};
	char *pparg2[] = {"daemond",
			  "-a", "-a some arg"};
	char *pparg3[] = {"daemond",
			  "-a", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbb"};

	/* saved string is same as given */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ret = process_args(3, pparg2, &fl);
	ct_test(pt, strcmp(fl.di_cmdarg, "-a some arg") == 0);

	/* make sure it doesn't write past the end of the char array */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ret = process_args(3, pparg3, &fl);
	ct_test(pt, strcmp(fl.di_cmdarg, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") == 0);

	/* it must be used in conjunction with a command argument */
	reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(3, pparg1, &fl)) == -1);
}

void
test_arg_general(Test *pt)
{
	int ret;
	struct dmninfo fl;
	char *pparg1[] = {"daemon"};

	/* No command line arguments is illegal */
	/*reset_getopt();
	bzero(&fl, sizeof fl);
	ct_test(pt, (ret = process_args(1, pparg1, &fl)) == -1);
	*/
}

void
args_addTests(Suite *ps)
{
	Test  *pt;
	bool rc;

	pt = ct_create("Argument Processing", NULL);
	rc = ct_addTestFun(pt, test_arg_m);
	rc = ct_addTestFun(pt, test_arg_p);
	rc = ct_addTestFun(pt, test_arg_i);
	rc = ct_addTestFun(pt, test_arg_r);
	rc = ct_addTestFun(pt, test_arg_n);
	rc = ct_addTestFun(pt, test_arg_s);
	rc = ct_addTestFun(pt, test_arg_P);
	rc = ct_addTestFun(pt, test_arg_a);
	rc = ct_addTestFun(pt, test_arg_general);

	rc = cs_addTest(ps, pt);
	assert(rc);
}