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

#include "lib.h"

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

#include "ext-imap4flags-common.h"

/*
 * Commands
 */

/* Forward declarations */

static bool cmd_flag_generate
	(const struct sieve_codegen_env *cgenv, struct sieve_command *ctx);

/* Setflag command
 *
 * Syntax:
 *   setflag [<variablename: string>] <list-of-flags: string-list>
 */

const struct sieve_command_def cmd_setflag = {
	.identifier = "setflag",
	.type = SCT_COMMAND,
	.positional_args = -1, /* We check positional arguments ourselves */
	.subtests = 0,
	.block_allowed = FALSE,
	.block_required = FALSE,
	.validate = ext_imap4flags_command_validate,
	.generate = cmd_flag_generate
};

/* Addflag command
 *
 * Syntax:
 *   addflag [<variablename: string>] <list-of-flags: string-list>
 */

const struct sieve_command_def cmd_addflag = {
	.identifier = "addflag",
	.type = SCT_COMMAND,
	.positional_args = -1, /* We check positional arguments ourselves */
	.subtests = 0,
	.block_allowed = FALSE,
	.block_required = FALSE,
	.validate = ext_imap4flags_command_validate,
	.generate = cmd_flag_generate
};


/* Removeflag command
 *
 * Syntax:
 *   removeflag [<variablename: string>] <list-of-flags: string-list>
 */

const struct sieve_command_def cmd_removeflag = {
	.identifier = "removeflag",
	.type = SCT_COMMAND,
	.positional_args = -1, /* We check positional arguments ourselves */
	.subtests = 0,
	.block_allowed = FALSE,
	.block_required = FALSE,
	.validate = ext_imap4flags_command_validate,
	.generate = cmd_flag_generate
};

/*
 * Operations
 */

/* Forward declarations */

bool cmd_flag_operation_dump
	(const struct sieve_dumptime_env *denv, sieve_size_t *address);
static int cmd_flag_operation_execute
	(const struct sieve_runtime_env *renv, sieve_size_t *address);

/* Setflag operation */

const struct sieve_operation_def setflag_operation = {
	.mnemonic = "SETFLAG",
	.ext_def = &imap4flags_extension,
	.code = EXT_IMAP4FLAGS_OPERATION_SETFLAG,
	.dump = cmd_flag_operation_dump,
	.execute = cmd_flag_operation_execute
};

/* Addflag operation */

const struct sieve_operation_def addflag_operation = {
	.mnemonic = "ADDFLAG",
	.ext_def = &imap4flags_extension,
	.code = EXT_IMAP4FLAGS_OPERATION_ADDFLAG,
	.dump = cmd_flag_operation_dump,
	.execute = cmd_flag_operation_execute
};

/* Removeflag operation */

const struct sieve_operation_def removeflag_operation = {
	.mnemonic = "REMOVEFLAG",
	.ext_def = &imap4flags_extension,
	.code = EXT_IMAP4FLAGS_OPERATION_REMOVEFLAG,
	.dump = cmd_flag_operation_dump,
	.execute = cmd_flag_operation_execute
};

/*
 * Code generation
 */

static bool cmd_flag_generate
(const struct sieve_codegen_env *cgenv, struct sieve_command *cmd)
{
	struct sieve_ast_argument *arg1, *arg2;

	/* Emit operation */
	if ( sieve_command_is(cmd, cmd_setflag) )
		sieve_operation_emit(cgenv->sblock, cmd->ext, &setflag_operation);
	else if ( sieve_command_is(cmd, cmd_addflag) )
		sieve_operation_emit(cgenv->sblock, cmd->ext, &addflag_operation);
	else if ( sieve_command_is(cmd, cmd_removeflag) )
		sieve_operation_emit(cgenv->sblock, cmd->ext, &removeflag_operation);

	arg1 = cmd->first_positional;
	arg2 = sieve_ast_argument_next(arg1);

	if ( arg2 == NULL ) {
		/* No variable */
		sieve_opr_omitted_emit(cgenv->sblock);
		if ( !sieve_generate_argument(cgenv, arg1, cmd) )
			return FALSE;
	} else {
		/* Full command */
		if ( !sieve_generate_argument(cgenv, arg1, cmd) )
			return FALSE;
		if ( !sieve_generate_argument(cgenv, arg2, cmd) )
			return FALSE;
	}
	return TRUE;
}

/*
 * Code dump
 */

bool cmd_flag_operation_dump
(const struct sieve_dumptime_env *denv, sieve_size_t *address)
{
	struct sieve_operand oprnd;

	sieve_code_dumpf(denv, "%s", sieve_operation_mnemonic(denv->oprtn));
	sieve_code_descend(denv);

	sieve_code_mark(denv);
	if ( !sieve_operand_read(denv->sblock, address, NULL, &oprnd) ) {
		sieve_code_dumpf(denv, "ERROR: INVALID OPERAND");
		return FALSE;
	}

	if ( !sieve_operand_is_omitted(&oprnd) ) {
		return
			sieve_opr_string_dump_data(denv, &oprnd, address, "variable name") &&
			sieve_opr_stringlist_dump(denv, address, "list of flags");
	}

	return
		sieve_opr_stringlist_dump(denv, address, "list of flags");
}

/*
 * Code execution
 */

static int cmd_flag_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
	const struct sieve_operation *op = renv->oprtn;
	struct sieve_operand oprnd;
	struct sieve_stringlist *flag_list;
	struct sieve_variable_storage *storage;
	unsigned int var_index;
	ext_imapflag_flag_operation_t flag_op;
	int ret;

	/*
	 * Read operands
	 */

	/* Read bare operand (two types possible) */
	if ( (ret=sieve_operand_runtime_read
		(renv, address, NULL, &oprnd)) <= 0 )
		return ret;

	/* Variable operand (optional) */
	if ( !sieve_operand_is_omitted(&oprnd) ) {
		/* Read the variable operand */
		if ( (ret=sieve_variable_operand_read_data
			(renv, &oprnd, address, "variable", &storage, &var_index)) <= 0 )
			return ret;

		/* Read flag list */
		if ( (ret=sieve_opr_stringlist_read(renv, address, "flag-list", &flag_list))
			<= 0 )
			return ret;

	/* Flag-list operand */
	} else {
		storage = NULL;
		var_index = 0;

		/* Read flag list */
		if ( (ret=sieve_opr_stringlist_read(renv, address,
			"flag-list", &flag_list)) <= 0 )
			return ret;
	}

	/*
	 * Perform operation
	 */

	/* Determine what to do */

	if ( sieve_operation_is(op, setflag_operation) ) {
		sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS, "setflag command");
		flag_op = sieve_ext_imap4flags_set_flags;
	} else if ( sieve_operation_is(op, addflag_operation) ) {
		sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS, "addflag command");
		flag_op = sieve_ext_imap4flags_add_flags;
	} else if ( sieve_operation_is(op, removeflag_operation) ) {
		sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS, "removeflag command");
		flag_op = sieve_ext_imap4flags_remove_flags;
	} else {
		i_unreached();
	}

	sieve_runtime_trace_descend(renv);

	/* Perform requested operation */
	return flag_op(renv, op->ext, storage, var_index, flag_list);
}