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

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

#include "sieve-common.h"
#include "sieve-ast.h"
#include "sieve-binary.h"
#include "sieve-code.h"
#include "sieve-commands.h"
#include "sieve-validator.h"
#include "sieve-generator.h"
#include "sieve-interpreter.h"
#include "sieve-dump.h"

#include "sieve-ext-variables.h"

#include "ext-vnd-environment-common.h"

static bool
vnspc_vnd_environment_validate(struct sieve_validator *valdtr,
			       const struct sieve_variables_namespace *nspc,
			       struct sieve_ast_argument *arg,
			       struct sieve_command *cmd,
			       ARRAY_TYPE(sieve_variable_name) *var_name,
			       void **var_data, bool assignment);
static bool
vnspc_vnd_environment_generate(const struct sieve_codegen_env *cgenv,
			       const struct sieve_variables_namespace *nspc,
			       struct sieve_ast_argument *arg,
			       struct sieve_command *cmd, void *var_data);
static bool
vnspc_vnd_environment_dump_variable(
	const struct sieve_dumptime_env *denv,
	const struct sieve_variables_namespace *nspc,
	const struct sieve_operand *oprnd, sieve_size_t *address);
static int
vnspc_vnd_environment_read_variable(
	const struct sieve_runtime_env *renv,
	const struct sieve_variables_namespace *nspc,
	const struct sieve_operand *oprnd,
	sieve_size_t *address, string_t **str_r);

static const struct sieve_variables_namespace_def
environment_namespace = {
	SIEVE_OBJECT("env", &environment_namespace_operand, 0),
	.validate = vnspc_vnd_environment_validate,
	.generate = vnspc_vnd_environment_generate,
	.dump_variable = vnspc_vnd_environment_dump_variable,
	.read_variable = vnspc_vnd_environment_read_variable,
};

static bool
vnspc_vnd_environment_validate(
	struct sieve_validator *valdtr,
	const struct sieve_variables_namespace *nspc ATTR_UNUSED,
	struct sieve_ast_argument *arg, struct sieve_command *cmd ATTR_UNUSED,
	ARRAY_TYPE(sieve_variable_name) *var_name, void **var_data,
	bool assignment)
{
	struct sieve_ast *ast = arg->ast;
	const struct sieve_variable_name *name_elements;
	unsigned int i, count;
	const char *variable;
	string_t *name;

	/* Compose environment name from parsed variable name */
	name = t_str_new(64);
	name_elements = array_get(var_name, &count);
	i_assert(count > 1);
	for (i = 1; i < count; i++) {
		if (name_elements[i].num_variable >= 0) {
			sieve_argument_validate_error(
				valdtr, arg, "vnd.dovecot.environment: "
				"invalid variable name within env namespace 'env.%d': "
				"encountered numeric variable name",
				name_elements[i].num_variable);
			return FALSE;
		}
		if (str_len(name) > 0)
			str_append_c(name, '.');
		str_append_str(name, name_elements[i].identifier);
	}

	variable = str_c(name);

	if (assignment) {
		sieve_argument_validate_error(
			valdtr, arg, "vnd.dovecot.environment: "
			"cannot assign to environment variable 'env.%s'",
			variable);
		return FALSE;
	}

	*var_data = p_strdup(sieve_ast_pool(ast), variable);
	return TRUE;
}

static bool
vnspc_vnd_environment_generate(const struct sieve_codegen_env *cgenv,
			       const struct sieve_variables_namespace *nspc,
			       struct sieve_ast_argument *arg ATTR_UNUSED,
			       struct sieve_command *cmd ATTR_UNUSED,
			       void *var_data)
{
	const struct sieve_extension *this_ext = SIEVE_OBJECT_EXTENSION(nspc);
	const char *variable = (const char *) var_data;
	struct ext_vnd_environment_context *extctx;

	if (this_ext == NULL)
		return FALSE;

	extctx = (struct ext_vnd_environment_context *)this_ext->context;

	sieve_variables_opr_namespace_variable_emit(
		cgenv->sblock, extctx->var_ext, this_ext,
		&environment_namespace);
	sieve_binary_emit_cstring(cgenv->sblock, variable);
	return TRUE;
}

static bool
vnspc_vnd_environment_dump_variable(
	const struct sieve_dumptime_env *denv,
	const struct sieve_variables_namespace *nspc ATTR_UNUSED,
	const struct sieve_operand *oprnd, sieve_size_t *address)
{
	string_t *var_name;

	if (!sieve_binary_read_string(denv->sblock, address, &var_name))
		return FALSE;

	if (oprnd->field_name != NULL) {
		sieve_code_dumpf(denv, "%s: VAR ${env.%s}",
				 oprnd->field_name, str_c(var_name));
	} else {
		sieve_code_dumpf(denv, "VAR ${env.%s}", str_c(var_name));
	}
	return TRUE;
}

static int
vnspc_vnd_environment_read_variable(
	const struct sieve_runtime_env *renv,
	const struct sieve_variables_namespace *nspc,
	const struct sieve_operand *oprnd, sieve_size_t *address,
	string_t **str_r)
{
	const struct sieve_extension *this_ext = SIEVE_OBJECT_EXTENSION(nspc);
	struct ext_vnd_environment_context *extctx = this_ext->context;
	string_t *var_name;
	const char *ext_value;

	if (!sieve_binary_read_string(renv->sblock, address, &var_name)) {
		sieve_runtime_trace_operand_error(
			renv, oprnd, "environment variable operand corrupt: "
			"invalid name");
		return SIEVE_EXEC_BIN_CORRUPT;
	}

	if (str_r !=  NULL) {
		const char *vname = str_c(var_name);

		ext_value = ext_environment_item_get_value(extctx->env_ext,
							   renv, vname);
		if (ext_value == NULL && strchr(vname, '_') != NULL) {
			char *p, *aname;

			/* Try again with '_' replaced with '-' */
			aname = t_strdup_noconst(vname);
			for (p = aname; *p != '\0'; p++) {
				if (*p == '_')
					*p = '-';
			}
			ext_value = ext_environment_item_get_value(
				extctx->env_ext, renv, aname);
		}

		if (ext_value == NULL) {
			*str_r = t_str_new_const("", 0);
			return SIEVE_EXEC_OK;
		}

		*str_r = t_str_new_const(ext_value, strlen(ext_value));
	}
	return SIEVE_EXEC_OK;
}

/*
 * Namespace registration
 */

static const struct sieve_extension_objects environment_namespaces =
	SIEVE_VARIABLES_DEFINE_NAMESPACE(environment_namespace);

const struct sieve_operand_def environment_namespace_operand = {
	.name = "env-namespace",
	.ext_def = &vnd_environment_extension,
	.class = &sieve_variables_namespace_operand_class,
	.interface = &environment_namespaces,
};

void ext_environment_variables_init(const struct sieve_extension *this_ext,
				    struct sieve_validator *valdtr)
{
	struct ext_vnd_environment_context *extctx = this_ext->context;

	sieve_variables_namespace_register(extctx->var_ext, valdtr, this_ext,
					   &environment_namespace);
}
