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

#include "lib.h"
#include "hash.h"

#include "sieve-common.h"
#include "sieve-extensions.h"
#include "sieve-interpreter.h"

#include "ext-environment-common.h"

struct ext_environment_interpreter_context;

/*
 * Core environment items
 */

static const struct sieve_environment_item_def *core_env_items[] = {
	&domain_env_item,
	&host_env_item,
	&location_env_item,
	&phase_env_item,
	&name_env_item,
	&version_env_item,
};

static unsigned int core_env_items_count = N_ELEMENTS(core_env_items);

static void
sieve_environment_item_insert(
	struct ext_environment_interpreter_context *ctx,
	struct sieve_interpreter *interp, const struct sieve_extension *ext,
	const struct sieve_environment_item_def *item_def);

/*
 * Validator context
 */

struct ext_environment_interpreter_context {
	HASH_TABLE(const char *,
		   const struct sieve_environment_item *) name_items;
	ARRAY(const struct sieve_environment_item *) prefix_items;

	bool active:1;
};

static void
ext_environment_interpreter_extension_free(const struct sieve_extension *ext,
					   struct sieve_interpreter *interp,
					   void *context);

struct sieve_interpreter_extension environment_interpreter_extension = {
	.ext_def = &environment_extension,
	.free = ext_environment_interpreter_extension_free,
};

static struct ext_environment_interpreter_context *
ext_environment_interpreter_context_create(
	const struct sieve_extension *this_ext,
	struct sieve_interpreter *interp)
{
	pool_t pool = sieve_interpreter_pool(interp);
	struct ext_environment_interpreter_context *ctx;

	ctx = p_new(pool, struct ext_environment_interpreter_context, 1);

	hash_table_create(&ctx->name_items, default_pool, 0, str_hash, strcmp);
	i_array_init(&ctx->prefix_items, 16);

	sieve_interpreter_extension_register(interp, this_ext,
					     &environment_interpreter_extension,
					     ctx);
	return ctx;
}

static void
ext_environment_interpreter_extension_free(
	const struct sieve_extension *ext ATTR_UNUSED,
	struct sieve_interpreter *interp ATTR_UNUSED, void *context)
{
	struct ext_environment_interpreter_context *ctx =
		(struct ext_environment_interpreter_context *)context;

	hash_table_destroy(&ctx->name_items);
	array_free(&ctx->prefix_items);
}

static struct ext_environment_interpreter_context *
ext_environment_interpreter_context_get(const struct sieve_extension *this_ext,
					struct sieve_interpreter *interp)
{
	struct ext_environment_interpreter_context *ctx =
		(struct ext_environment_interpreter_context *)
		sieve_interpreter_extension_get_context(interp, this_ext);

	if (ctx == NULL) {
		ctx = ext_environment_interpreter_context_create(
			this_ext, interp);
	}
	return ctx;
}

void ext_environment_interpreter_init(const struct sieve_extension *this_ext,
				      struct sieve_interpreter *interp)
{
	struct ext_environment_interpreter_context *ctx;
	unsigned int i;

	/* Create our context */
	ctx = ext_environment_interpreter_context_get(this_ext, interp);

	for (i = 0; i < core_env_items_count; i++) {
		sieve_environment_item_insert(ctx, interp, this_ext,
					      core_env_items[i]);
	}

	ctx->active = TRUE;
}

bool sieve_ext_environment_is_active(const struct sieve_extension *env_ext,
				     struct sieve_interpreter *interp)
{
	struct ext_environment_interpreter_context *ctx =
		ext_environment_interpreter_context_get(env_ext, interp);

	return (ctx != NULL && ctx->active);
}

/*
 * Registration
 */

static void
sieve_environment_item_insert(
	struct ext_environment_interpreter_context *ctx,
	struct sieve_interpreter *interp, const struct sieve_extension *ext,
	const struct sieve_environment_item_def *item_def)
{
	pool_t pool = sieve_interpreter_pool(interp);
	struct sieve_environment_item *item_mod;

	item_mod = p_new(pool, struct sieve_environment_item, 1);
	item_mod->def = item_def;
	item_mod->ext = ext;

	const struct sieve_environment_item *item = item_mod;
	if (!item_def->prefix)
		hash_table_insert(ctx->name_items, item_def->name, item);
	else
		array_append(&ctx->prefix_items, &item, 1);
}

void sieve_environment_item_register(
	const struct sieve_extension *env_ext, struct sieve_interpreter *interp,
	const struct sieve_extension *ext,
	const struct sieve_environment_item_def *item_def)
{
	struct ext_environment_interpreter_context *ctx;

	i_assert(sieve_extension_is(env_ext, environment_extension));
	ctx = ext_environment_interpreter_context_get(env_ext, interp);

	sieve_environment_item_insert(ctx, interp, ext, item_def);
}

/*
 * Retrieval
 */

static const struct sieve_environment_item *
ext_environment_item_lookup(struct ext_environment_interpreter_context *ctx,
			    const char **_name)
{
	const struct sieve_environment_item *item;
	const char *suffix, *name = *_name;

	item = hash_table_lookup(ctx->name_items, name);
	if (item != NULL)
		return item;

	array_foreach_elem(&ctx->prefix_items, item) {
		i_assert(item->def->prefix);

		if (str_begins(name, item->def->name, &suffix)) {
			if (*suffix == '.')
				++suffix;

			*_name = suffix;
			return item;
		}
	}
	return NULL;
}

const char *
ext_environment_item_get_value(const struct sieve_extension *env_ext,
			       const struct sieve_runtime_env *renv,
			       const char *name)
{
	struct ext_environment_interpreter_context *ctx;
	const struct sieve_environment_item *item;

	i_assert(sieve_extension_is(env_ext, environment_extension));
	ctx = ext_environment_interpreter_context_get(env_ext, renv->interp);

	item = ext_environment_item_lookup(ctx, &name);
	if (item == NULL)
		return NULL;

	i_assert(item->def != NULL);
	if (item->def->value != NULL)
		return item->def->value;
	if (item->def->get_value != NULL)
		return item->def->get_value(renv, item, name);
	return NULL;
}

/*
 * Default environment items
 */

/* "domain":

     The primary DNS domain associated with the Sieve execution context, usually
     but not always a proper suffix of the host name.
 */

static const char *
envit_domain_get_value(const struct sieve_runtime_env *renv,
		       const struct sieve_environment_item *item ATTR_UNUSED,
		       const char *name ATTR_UNUSED)
{
	const struct sieve_execute_env *eenv = renv->exec_env;

	return eenv->svinst->domainname;
}

const struct sieve_environment_item_def domain_env_item = {
	.name = "domain",
	.get_value = envit_domain_get_value,
};

/* "host":

     The fully-qualified domain name of the host where the Sieve script is
     executing.
 */

static const char *
envit_host_get_value(const struct sieve_runtime_env *renv,
		     const struct sieve_environment_item *item ATTR_UNUSED,
		     const char *name ATTR_UNUSED)
{
	const struct sieve_execute_env *eenv = renv->exec_env;

	return eenv->svinst->hostname;
}

const struct sieve_environment_item_def host_env_item = {
	.name = "host",
	.get_value = envit_host_get_value,
};

/* "location":

     Sieve evaluation can be performed at various different points as messages
     are processed. This item provides additional information about the type of
     service that is evaluating the script.  Possible values are:
      "MTA" - the Sieve script is being evaluated by a Message Transfer Agent
      "MDA" - evaluation is being performed by a Mail Delivery Agent
      "MUA" - evaluation is being performed by a Mail User Agent (right...)
      "MS"  - evaluation is being performed by a Message Store
 */

static const char *
envit_location_get_value(const struct sieve_runtime_env *renv,
			 const struct sieve_environment_item *item ATTR_UNUSED,
			 const char *name ATTR_UNUSED)
{
	const struct sieve_execute_env *eenv = renv->exec_env;

	switch (eenv->svinst->env_location ) {
	case SIEVE_ENV_LOCATION_MDA:
		return "MDA";
	case SIEVE_ENV_LOCATION_MTA:
		return "MTA";
	case SIEVE_ENV_LOCATION_MS:
		return "MS";
	default:
		break;
	}
	return NULL;
}

const struct sieve_environment_item_def location_env_item = {
	.name = "location",
	.get_value = envit_location_get_value
};

/* "phase":

     The point relative to final delivery where the Sieve script is being
     evaluated.  Possible values are "pre", "during", and "post", referring
     respectively to processing before, during, and after final delivery has
     taken place.
 */

static const char *
envit_phase_get_value(const struct sieve_runtime_env *renv,
		      const struct sieve_environment_item *item ATTR_UNUSED,
		      const char *name ATTR_UNUSED)
{
	const struct sieve_execute_env *eenv = renv->exec_env;

	switch (eenv->svinst->delivery_phase) {
	case SIEVE_DELIVERY_PHASE_PRE:
		return "pre";
	case SIEVE_DELIVERY_PHASE_DURING:
		return "during";
	case SIEVE_DELIVERY_PHASE_POST:
		return "post";
	default:
		break;
	}
	return NULL;
}

const struct sieve_environment_item_def phase_env_item = {
	.name = "phase",
	.get_value = envit_phase_get_value
};

/* "name":

    The product name associated with the Sieve interpreter.
 */

const struct sieve_environment_item_def name_env_item = {
	.name = "name",
	.value = PIGEONHOLE_NAME" Sieve"
};

/* "version":

   The product version associated with the Sieve interpreter. The meaning of the
   product version string is product-specific and should always be considered
   in the context of the product name given by the "name" item.
 */

const struct sieve_environment_item_def version_env_item = {
	.name = "version",
	.value = PIGEONHOLE_VERSION,
};
