/* Copyright (c) Pigeonhole authors, see top-level COPYING file */

#include "lib.h"
#include "ostream.h"
#include "str.h"

#include "sieve-common.h"
#include "sieve-error.h"
#include "sieve-stringlist.h"
#include "sieve-actions.h"
#include "sieve-interpreter.h"
#include "sieve-result.h"

#include "testsuite-common.h"
#include "testsuite-log.h"
#include "testsuite-message.h"
#include "testsuite-mailstore.h"

#include "testsuite-result.h"

struct sieve_execute_env testsuite_execute_env;

static pool_t testsuite_execute_pool = NULL;
static struct sieve_result *_testsuite_result = NULL;
static struct sieve_result_execution *_testsuite_rexec = NULL;

void testsuite_result_init(void)
{
	struct sieve_instance *svinst = testsuite_sieve_instance;

	testsuite_execute_pool = pool_alloconly_create("sieve execution", 4096);

	sieve_execute_init(&testsuite_execute_env, testsuite_sieve_instance,
			   testsuite_execute_pool, &testsuite_msgdata,
			   testsuite_scriptenv, 0);

	_testsuite_result = sieve_result_create(svinst, testsuite_execute_pool,
						&testsuite_execute_env);
}

void testsuite_result_deinit(void)
{
	sieve_result_execution_destroy(&_testsuite_rexec);
	sieve_result_unref(&_testsuite_result);
	sieve_execute_deinit(&testsuite_execute_env);
	pool_unref(&testsuite_execute_pool);
}

void testsuite_result_reset(const struct sieve_runtime_env *renv)
{
	struct sieve_instance *svinst = testsuite_sieve_instance;

	if (_testsuite_result != NULL) {
		sieve_result_execution_destroy(&_testsuite_rexec);
		sieve_result_unref(&_testsuite_result);
		pool_unref(&testsuite_execute_pool);
	}

	testsuite_message_flush();
	testsuite_mailstore_flush();
	i_zero(testsuite_execute_env.exec_status);

	testsuite_execute_pool = pool_alloconly_create("sieve execution", 4096);
	_testsuite_result = sieve_result_create(svinst, testsuite_execute_pool,
						&testsuite_execute_env);
	sieve_interpreter_set_result(renv->interp, _testsuite_result);
}

struct sieve_result *testsuite_result_get(void)
{
	return _testsuite_result;
}

struct sieve_result_iterate_context *testsuite_result_iterate_init(void)
{
	if (_testsuite_result == NULL)
		return NULL;

	return sieve_result_iterate_init(_testsuite_result);
}

bool testsuite_result_execute(const struct sieve_runtime_env *renv)
{
	int ret;

	if (_testsuite_result == NULL) {
		sieve_runtime_error(renv, NULL,	"testsuite: "
				    "trying to execute result, "
				    "but no result evaluated yet");
		return FALSE;
	}

	testsuite_log_clear_messages();

	if (_testsuite_rexec == NULL) {
		_testsuite_rexec = sieve_result_execution_create(
			_testsuite_result, testsuite_execute_pool);
	}

	/* Execute the result */
	ret = sieve_result_execute(_testsuite_rexec, SIEVE_EXEC_OK, TRUE,
				   testsuite_log_ehandler, NULL);

	return (ret > 0);
}

void testsuite_result_print(const struct sieve_runtime_env *renv)
{
	const struct sieve_execute_env *eenv = renv->exec_env;
	struct ostream *out;

	out = o_stream_create_fd(1, 0);
	o_stream_set_no_error_handling(out, TRUE);

	o_stream_nsend_str(out, "\n--");
	sieve_result_print(_testsuite_result, eenv->scriptenv, out, NULL);
	o_stream_nsend_str(out, "--\n\n");

	o_stream_destroy(&out);
}

/*
 * Result stringlist
 */

/* Forward declarations */

static int
testsuite_result_stringlist_next_item(struct sieve_stringlist *_strlist,
				      string_t **str_r);
static void
testsuite_result_stringlist_reset(struct sieve_stringlist *_strlist);

/* Stringlist object */

struct testsuite_result_stringlist {
	struct sieve_stringlist strlist;

	struct sieve_result_iterate_context *result_iter;
	int pos, index;
};

struct sieve_stringlist *
testsuite_result_stringlist_create(const struct sieve_runtime_env *renv,
				   int index)
{
	struct testsuite_result_stringlist *strlist;

	strlist = t_new(struct testsuite_result_stringlist, 1);
	strlist->strlist.runenv = renv;
	strlist->strlist.exec_status = SIEVE_EXEC_OK;
	strlist->strlist.next_item = testsuite_result_stringlist_next_item;
	strlist->strlist.reset = testsuite_result_stringlist_reset;

	strlist->result_iter = testsuite_result_iterate_init();
 	strlist->index = index;
	strlist->pos = 0;

	return &strlist->strlist;
}

static int
testsuite_result_stringlist_next_item(struct sieve_stringlist *_strlist,
				      string_t **str_r)
{
	struct testsuite_result_stringlist *strlist =
		(struct testsuite_result_stringlist *)_strlist;
	const struct sieve_action *action;
	const char *act_name;
	bool keep;

	*str_r = NULL;

	if (strlist->index > 0 && strlist->pos > 0)
		return 0;

	do {
		action = sieve_result_iterate_next(strlist->result_iter, &keep);
		if (action == NULL)
			return 0;

		strlist->pos++;
	} while (strlist->pos < strlist->index);

	if (keep)
		act_name = "keep";
	else {
		act_name = ((action == NULL || action->def == NULL ||
			     action->def->name == NULL) ?
			    "" : action->def->name);
	}

	*str_r = t_str_new_const(act_name, strlen(act_name));
	return 1;
}

static void testsuite_result_stringlist_reset(struct sieve_stringlist *_strlist)
{
	struct testsuite_result_stringlist *strlist =
		(struct testsuite_result_stringlist *)_strlist;

	strlist->result_iter = testsuite_result_iterate_init();
	strlist->pos = 0;
}
