/* Copyright (c) 2002-2018 Pigeonhole authors, see the included COPYING file
 */

#include "lib.h"
#include "str.h"
#include "str-sanitize.h"
#include "mail-storage.h"
#include "imap-arg.h"

#include "sieve-common.h"
#include "sieve-commands.h"
#include "sieve-code.h"
#include "sieve-stringlist.h"
#include "sieve-actions.h"
#include "sieve-validator.h"
#include "sieve-generator.h"
#include "sieve-interpreter.h"
#include "sieve-result.h"
#include "sieve-dump.h"

#include "sieve-ext-variables.h"

#include "ext-imap4flags-common.h"

/*
 * Tagged arguments
 */

extern const struct sieve_argument_def tag_flags;
extern const struct sieve_argument_def tag_flags_implicit;

/*
 * Common command functions
 */

bool ext_imap4flags_command_validate(struct sieve_validator *valdtr,
				     struct sieve_command *cmd)
{
	const struct sieve_extension *ext = cmd->ext;
	struct ext_imap4flags_context *extctx = ext->context;
	const struct sieve_extension *var_ext = extctx->var_ext;
	struct sieve_ast_argument *arg = cmd->first_positional;
	struct sieve_ast_argument *arg2;

	/* Check arguments */

	if (arg == NULL) {
		sieve_command_validate_error(
			valdtr, cmd,
			"the %s %s expects at least one argument, "
			"but none was found",
			sieve_command_identifier(cmd),
			sieve_command_type_name(cmd));
		return FALSE;
	}

	if (sieve_ast_argument_type(arg) != SAAT_STRING &&
	    sieve_ast_argument_type(arg) != SAAT_STRING_LIST) {
		sieve_argument_validate_error(
			valdtr, arg,
			"the %s %s expects either a string (variable name) or "
			"a string-list (list of flags) as first argument, "
			"but %s was found",
			sieve_command_identifier(cmd),
			sieve_command_type_name(cmd),
			sieve_ast_argument_name(arg));
		return FALSE;
	}

	arg2 = sieve_ast_argument_next(arg);
	if (arg2 != NULL) {
		/* First, check syntax sanity */

		if (sieve_ast_argument_type(arg) != SAAT_STRING) {
			if (sieve_command_is(cmd, tst_hasflag)) {
				if (sieve_ast_argument_type(arg) != SAAT_STRING_LIST) {
					sieve_argument_validate_error(
						valdtr, arg,
						"if a second argument is specified for the hasflag, "
						"the first must be a string-list (variable-list), "
						"but %s was found",
						sieve_ast_argument_name(arg));
					return FALSE;
				}
			} else {
				sieve_argument_validate_error(
					valdtr, arg,
					"if a second argument is specified for the %s %s, "
					"the first must be a string (variable name), "
					"but %s was found",
					sieve_command_identifier(cmd),
					sieve_command_type_name(cmd),
					sieve_ast_argument_name(arg));
				return FALSE;
			}
		}

		/* Then, check whether the second argument is permitted */

		if (var_ext == NULL ||
		    !sieve_ext_variables_is_active(var_ext, valdtr)) {
			sieve_argument_validate_error(
				valdtr,arg,
				"the %s %s only allows for the specification of a "
				"variable name when the variables extension is active",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd));
			return FALSE;
		}

		if (!sieve_variable_argument_activate(
			var_ext, var_ext, valdtr, cmd, arg,
			!sieve_command_is(cmd, tst_hasflag)))
			return FALSE;

		if (sieve_ast_argument_type(arg2) != SAAT_STRING &&
		    sieve_ast_argument_type(arg2) != SAAT_STRING_LIST) {
			sieve_argument_validate_error(
				valdtr, arg2,
				"the %s %s expects a string list (list of flags) as "
				"second argument when two arguments are specified, "
				"but %s was found",
				sieve_command_identifier(cmd),
				sieve_command_type_name(cmd),
				sieve_ast_argument_name(arg2));
			return FALSE;
		}
	} else
		arg2 = arg;

	if (!sieve_validator_argument_activate(valdtr, cmd, arg2, FALSE))
		return FALSE;

	if (!sieve_command_is(cmd, tst_hasflag) &&
	    sieve_argument_is_string_literal(arg2)) {
		struct ext_imap4flags_iter fiter;
		const char *flag;

		/* Warn the user about validity of verifiable flags */
		ext_imap4flags_iter_init(&fiter, sieve_ast_argument_str(arg));

		while ((flag = ext_imap4flags_iter_get_flag(&fiter)) != NULL) {
			if (!sieve_ext_imap4flags_flag_is_valid(flag)) {
				sieve_argument_validate_warning(
					valdtr, arg,
					"IMAP flag '%s' specified for the %s command is invalid "
					"and will be ignored (only first invalid is reported)",
					str_sanitize(flag, 64),
					sieve_command_identifier(cmd));
				break;
			}
		}
	}

	return TRUE;
}

/*
 * Flags tag registration
 */

void ext_imap4flags_attach_flags_tag(struct sieve_validator *valdtr,
				     const struct sieve_extension *ext,
				     const char *command)
{
	/* Register :flags tag with the command and we don't care whether it is
	   registered or even whether it will be registered at all. The
	   validator handles either situation gracefully.
	 */

	/* Tag specified by user */
	sieve_validator_register_external_tag(valdtr, command, ext, &tag_flags,
					      SIEVE_OPT_SIDE_EFFECT);
}

void sieve_ext_imap4flags_register_side_effect(
	struct sieve_validator *valdtr, const struct sieve_extension *flg_ext,
	const char *command)
{
	/* Implicit tag if none is specified */
	sieve_validator_register_persistent_tag(valdtr, command, flg_ext,
						&tag_flags_implicit);
}

/*
 * Result context
 */

struct ext_imap4flags_result_context {
    string_t *internal_flags;
};

static void _get_initial_flags(struct sieve_result *result, string_t *flags)
{
	const struct sieve_message_data *msgdata =
		sieve_result_get_message_data(result);
	enum mail_flags mail_flags;
	const char *const *mail_keywords;

	mail_flags = mail_get_flags(msgdata->mail);
	mail_keywords = mail_get_keywords(msgdata->mail);

	if ((mail_flags & MAIL_FLAGGED) > 0)
		str_printfa(flags, " \\flagged");
	if ((mail_flags & MAIL_ANSWERED) > 0)
		str_printfa(flags, " \\answered");
	if ((mail_flags & MAIL_DELETED) > 0)
		str_printfa(flags, " \\deleted");
	if ((mail_flags & MAIL_SEEN) > 0)
		str_printfa(flags, " \\seen");
	if ((mail_flags & MAIL_DRAFT) > 0)
		str_printfa(flags, " \\draft");

	while (*mail_keywords != NULL) {
		str_printfa(flags, " %s", *mail_keywords);
		mail_keywords++;
	}
}

static inline struct ext_imap4flags_result_context *
_get_result_context(const struct sieve_extension *this_ext,
		    struct sieve_result *result)
{
	struct ext_imap4flags_result_context *rctx =
		(struct ext_imap4flags_result_context *)
			sieve_result_extension_get_context(result, this_ext);

	if (rctx == NULL) {
		pool_t pool = sieve_result_pool(result);

		rctx = p_new(pool, struct ext_imap4flags_result_context, 1);
		rctx->internal_flags = str_new(pool, 32);
		_get_initial_flags(result, rctx->internal_flags);

		sieve_result_extension_set_context(result, this_ext, rctx);
	}
	return rctx;
}

static string_t *
_get_flags_string(const struct sieve_extension *this_ext,
		  struct sieve_result *result)
{
	struct ext_imap4flags_result_context *ctx =
		_get_result_context(this_ext, result);

	return ctx->internal_flags;
}

/*
 * Runtime initialization
 */

static int
ext_imap4flags_runtime_init(const struct sieve_extension *ext,
			    const struct sieve_runtime_env *renv,
			    void *context ATTR_UNUSED,
			    bool deferred ATTR_UNUSED)
{
	sieve_result_add_implicit_side_effect(renv->result, NULL, TRUE, ext,
					      &flags_side_effect, NULL);
	return SIEVE_EXEC_OK;
}

const struct sieve_interpreter_extension
imap4flags_interpreter_extension = {
	.ext_def = &imap4flags_extension,
	.run = ext_imap4flags_runtime_init,
};

/*
 * Flag handling
 */

/* FIXME: This currently accepts a potentially unlimited number of flags, making
          the internal or variable flag list indefinitely long.
 */

bool sieve_ext_imap4flags_flag_is_valid(const char *flag)
{
	if (*flag == '\0')
		return FALSE;

	if (*flag == '\\') {
		/* System flag */
		const char *atom = t_str_ucase(flag);

		if (strcmp(atom, "\\ANSWERED") != 0 &&
		    strcmp(atom, "\\FLAGGED") != 0 &&
		    strcmp(atom, "\\DELETED") != 0 &&
		    strcmp(atom, "\\SEEN") != 0 &&
		    strcmp(atom, "\\DRAFT") != 0)
		{
			return FALSE;
		}
	} else {
		const char *p;

		/* Custom keyword:

		   Syntax (IMAP4rev1, RFC 3501, Section 9. Formal Syntax) :
		    flag-keyword    = atom
		    atom            = 1*ATOM-CHAR
		 */
		p = flag;
		while (*p != '\0') {
			if (!IS_ATOM_CHAR(*p))
				return FALSE;
			p++;
		}
	}
	return TRUE;
}

/* Flag iterator */

static void ext_imap4flags_iter_clear(struct ext_imap4flags_iter *iter)
{
	i_zero(iter);
}

void ext_imap4flags_iter_init(struct ext_imap4flags_iter *iter,
			      string_t *flags_list)
{
	ext_imap4flags_iter_clear(iter);
	iter->flags_list = flags_list;
}

static string_t *
ext_imap4flags_iter_get_flag_str(struct ext_imap4flags_iter *iter)
{
	unsigned int len;
	const unsigned char *fp;
	const unsigned char *fbegin;
	const unsigned char *fstart;
	const unsigned char *fend;

	/* Return if not initialized */
	if (iter->flags_list == NULL)
		return NULL;

	/* Return if no more flags are available */
	len = str_len(iter->flags_list);
	if (iter->offset >= len)
		return NULL;

	/* Mark string boundries */
	fbegin = str_data(iter->flags_list);
	fend = fbegin + len;

	/* Start of this flag */
	fstart = fbegin + iter->offset;

	/* Scan for next flag */
	fp = fstart;
	for (;;) {
		/* Have we reached the end or a flag boundary? */
		if (fp >= fend || *fp == ' ') {
			/* Did we scan more than nothing ? */
			if (fp > fstart) {
				/* Return flag */
				string_t *flag = t_str_new(fp-fstart+1);
				str_append_data(flag, fstart, fp-fstart);

				iter->last = fstart - fbegin;
				iter->offset = fp - fbegin;

				return flag;
			}

			fstart = fp + 1;
		}

		if (fp >= fend)
			break;

		fp++;
	}

	iter->last = fstart - fbegin;
	iter->offset = fp - fbegin;
	return NULL;
}

const char *ext_imap4flags_iter_get_flag(struct ext_imap4flags_iter *iter)
{
	string_t *flag = ext_imap4flags_iter_get_flag_str(iter);

	if (flag == NULL)
		return NULL;

	return str_c(flag);
}

static void ext_imap4flags_iter_delete_last(struct ext_imap4flags_iter *iter)
{
	iter->offset++;
	if (iter->offset > str_len(iter->flags_list))
		iter->offset = str_len(iter->flags_list);
	if (iter->offset == str_len(iter->flags_list) && iter->last > 0)
		iter->last--;

	str_delete(iter->flags_list, iter->last, iter->offset - iter->last);

	iter->offset = iter->last;
}

/* Flag operations */

static string_t *
ext_imap4flags_get_flag_variable(const struct sieve_runtime_env *renv,
				 const struct sieve_extension *flg_ext,
				 struct sieve_variable_storage *storage,
				 unsigned int var_index) ATTR_NULL(2);

static bool flags_list_flag_exists(string_t *flags_list, const char *flag)
{
	const char *flg;
	struct ext_imap4flags_iter flit;

	ext_imap4flags_iter_init(&flit, flags_list);
	while ((flg = ext_imap4flags_iter_get_flag(&flit)) != NULL) {
		if (strcasecmp(flg, flag) == 0)
			return TRUE;
	}
	return FALSE;
}

static void flags_list_flag_delete(string_t *flags_list, const char *flag)
{
	const char *flg;
	struct ext_imap4flags_iter flit;

	ext_imap4flags_iter_init(&flit, flags_list);

	while ((flg = ext_imap4flags_iter_get_flag(&flit)) != NULL) {
		if (strcasecmp(flg, flag) == 0)
			ext_imap4flags_iter_delete_last(&flit);
	}
}

static void flags_list_add_flags(string_t *flags_list, string_t *flags)
{
	const char *flg;
	struct ext_imap4flags_iter flit;

	ext_imap4flags_iter_init(&flit, flags);

	while ((flg = ext_imap4flags_iter_get_flag(&flit)) != NULL) {
		if (sieve_ext_imap4flags_flag_is_valid(flg) &&
		    !flags_list_flag_exists(flags_list, flg)) {
			if (str_len(flags_list) != 0)
				str_append_c(flags_list, ' ');
			str_append(flags_list, flg);
		}
	}
}

static void flags_list_remove_flags(string_t *flags_list, string_t *flags)
{
	const char *flg;
	struct ext_imap4flags_iter flit;

	ext_imap4flags_iter_init(&flit, flags);

	while ((flg = ext_imap4flags_iter_get_flag(&flit)) != NULL)
		flags_list_flag_delete(flags_list, flg);
}

static void flags_list_set_flags(string_t *flags_list, string_t *flags)
{
	str_truncate(flags_list, 0);
	flags_list_add_flags(flags_list, flags);
}

static void flags_list_clear_flags(string_t *flags_list)
{
	str_truncate(flags_list, 0);
}

static string_t *
ext_imap4flags_get_flag_variable(const struct sieve_runtime_env *renv,
				 const struct sieve_extension *flg_ext,
				 struct sieve_variable_storage *storage,
				 unsigned int var_index)
{
	string_t *flags;

	if (storage != NULL) {
		if (sieve_runtime_trace_active(renv, SIEVE_TRLVL_COMMANDS)) {
			const char *var_name, *var_id;

			(void)sieve_variable_get_identifier(storage, var_index,
							    &var_name);
			var_id = sieve_variable_get_varid(storage, var_index);

			sieve_runtime_trace(renv, 0,
					    "update variable '%s' [%s]",
					    var_name, var_id);
		}

		if (!sieve_variable_get_modifiable(storage, var_index, &flags))
			return NULL;
	} else {
		i_assert(sieve_extension_is(flg_ext, imap4flags_extension));
		flags = _get_flags_string(flg_ext, renv->result);
	}
	return flags;
}

int sieve_ext_imap4flags_set_flags(const struct sieve_runtime_env *renv,
				   const struct sieve_extension *flg_ext,
				   struct sieve_variable_storage *storage,
				   unsigned int var_index,
				   struct sieve_stringlist *flags)
{
	string_t *cur_flags = ext_imap4flags_get_flag_variable(
		renv, flg_ext, storage, var_index);

	if (cur_flags != NULL) {
		string_t *flags_item;
		int ret;

		flags_list_clear_flags(cur_flags);
		while ((ret = sieve_stringlist_next_item(
			flags, &flags_item)) > 0) {
			sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS,
					    "set flags '%s'",
					    str_c(flags_item));

			flags_list_add_flags(cur_flags, flags_item);
		}

		if (ret < 0)
			return SIEVE_EXEC_BIN_CORRUPT;
		return SIEVE_EXEC_OK;
	}
	return SIEVE_EXEC_BIN_CORRUPT;
}

int sieve_ext_imap4flags_add_flags(const struct sieve_runtime_env *renv,
				   const struct sieve_extension *flg_ext,
				   struct sieve_variable_storage *storage,
				   unsigned int var_index,
				   struct sieve_stringlist *flags)
{
	string_t *cur_flags = ext_imap4flags_get_flag_variable(
		renv, flg_ext, storage, var_index);

	if (cur_flags != NULL) {
		string_t *flags_item;
		int ret;

		while ((ret = sieve_stringlist_next_item(
			flags, &flags_item)) > 0) {
			sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS,
					    "add flags '%s'",
					    str_c(flags_item));

			flags_list_add_flags(cur_flags, flags_item);
		}

		if (ret < 0)
			return SIEVE_EXEC_BIN_CORRUPT;
		return SIEVE_EXEC_OK;
	}

	return SIEVE_EXEC_BIN_CORRUPT;
}

int sieve_ext_imap4flags_remove_flags(const struct sieve_runtime_env *renv,
				      const struct sieve_extension *flg_ext,
				      struct sieve_variable_storage *storage,
				      unsigned int var_index,
				      struct sieve_stringlist *flags)
{
	string_t *cur_flags = ext_imap4flags_get_flag_variable(
		renv, flg_ext, storage, var_index);

	if (cur_flags != NULL) {
		string_t *flags_item;
		int ret;

		while ((ret = sieve_stringlist_next_item(
			flags, &flags_item)) > 0) {
			sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS,
					    "remove flags '%s'",
					    str_c(flags_item));

			flags_list_remove_flags(cur_flags, flags_item);
		}

		if (ret < 0) return
			SIEVE_EXEC_BIN_CORRUPT;
		return SIEVE_EXEC_OK;
	}
	return SIEVE_EXEC_BIN_CORRUPT;
}

/* Flag stringlist */

static int
ext_imap4flags_stringlist_next_item(struct sieve_stringlist *_strlist,
				    string_t **str_r);
static void
ext_imap4flags_stringlist_reset(struct sieve_stringlist *_strlist);

struct ext_imap4flags_stringlist {
	struct sieve_stringlist strlist;

	struct sieve_stringlist *flags_list;
	string_t *flags_string;
	struct ext_imap4flags_iter flit;

	bool normalize:1;
};

static struct sieve_stringlist *
ext_imap4flags_stringlist_create(const struct sieve_runtime_env *renv,
				 struct sieve_stringlist *flags_list,
				 bool normalize)
{
	struct ext_imap4flags_stringlist *strlist;

	strlist = t_new(struct ext_imap4flags_stringlist, 1);
	strlist->strlist.exec_status = SIEVE_EXEC_OK;
	strlist->strlist.runenv = renv;
	strlist->strlist.next_item = ext_imap4flags_stringlist_next_item;
	strlist->strlist.reset = ext_imap4flags_stringlist_reset;
	strlist->normalize = normalize;

	strlist->flags_list = flags_list;

	return &strlist->strlist;
}

static struct sieve_stringlist *
ext_imap4flags_stringlist_create_single(const struct sieve_runtime_env *renv,
					string_t *flags_string, bool normalize)
{
	struct ext_imap4flags_stringlist *strlist;

	strlist = t_new(struct ext_imap4flags_stringlist, 1);
	strlist->strlist.exec_status = SIEVE_EXEC_OK;
	strlist->strlist.runenv = renv;
	strlist->strlist.next_item = ext_imap4flags_stringlist_next_item;
	strlist->strlist.reset = ext_imap4flags_stringlist_reset;
	strlist->normalize = normalize;

	if (normalize) {
		strlist->flags_string = t_str_new(256);
		flags_list_set_flags(strlist->flags_string, flags_string);
	} else {
		strlist->flags_string = flags_string;
	}

	ext_imap4flags_iter_init(&strlist->flit, strlist->flags_string);
	return &strlist->strlist;
}

static int
ext_imap4flags_stringlist_next_item(struct sieve_stringlist *_strlist,
				    string_t **str_r)
{
	struct ext_imap4flags_stringlist *strlist =
		(struct ext_imap4flags_stringlist *)_strlist;

	while ((*str_r = ext_imap4flags_iter_get_flag_str(
		&strlist->flit)) == NULL) {
		int ret;

		if (strlist->flags_list == NULL)
			return 0;

		ret = sieve_stringlist_next_item(strlist->flags_list,
						 &strlist->flags_string);
		if (ret <= 0)
			return ret;
		if (strlist->flags_string == NULL)
			return -1;

		if (strlist->normalize) {
			string_t *flags_string = t_str_new(256);

			flags_list_set_flags(flags_string,
					     strlist->flags_string);
			strlist->flags_string = flags_string;
		}

		ext_imap4flags_iter_init(&strlist->flit, strlist->flags_string);
	}
	return 1;
}

static void ext_imap4flags_stringlist_reset(struct sieve_stringlist *_strlist)
{
	struct ext_imap4flags_stringlist *strlist =
		(struct ext_imap4flags_stringlist *)_strlist;

	if (strlist->flags_list != NULL) {
		sieve_stringlist_reset(strlist->flags_list);
		ext_imap4flags_iter_clear(&strlist->flit);
	} else {
		ext_imap4flags_iter_init(&strlist->flit, strlist->flags_string);
	}
}

/* Flag access */

struct sieve_stringlist *
sieve_ext_imap4flags_get_flags(const struct sieve_runtime_env *renv,
			       const struct sieve_extension *flg_ext,
			       struct sieve_stringlist *flags_list)
{
	if (flags_list == NULL) {
		i_assert(sieve_extension_is(flg_ext, imap4flags_extension));
		return ext_imap4flags_stringlist_create_single(
			renv, _get_flags_string(flg_ext, renv->result), FALSE);
	}
	return ext_imap4flags_stringlist_create(renv, flags_list, TRUE);
}

void ext_imap4flags_get_implicit_flags_init(
	struct ext_imap4flags_iter *iter,
	const struct sieve_extension *this_ext, struct sieve_result *result)
{
	string_t *cur_flags = _get_flags_string(this_ext, result);

	ext_imap4flags_iter_init(iter, cur_flags);
}
