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

#include "lib.h"
#include "compat.h"
#include "mempool.h"
#include "hash.h"
#include "array.h"
#include "str-sanitize.h"

#include "sieve-extensions.h"
#include "sieve-code.h"
#include "sieve-address.h"
#include "sieve-commands.h"
#include "sieve-binary.h"
#include "sieve-comparators.h"
#include "sieve-match-types.h"
#include "sieve-validator.h"
#include "sieve-generator.h"
#include "sieve-interpreter.h"
#include "sieve-dump.h"
#include "sieve-match.h"

#include "sieve-address-parts.h"

#include <string.h>

/*
 * Default address parts
 */

const struct sieve_address_part_def *sieve_core_address_parts[] = {
	&all_address_part, &local_address_part, &domain_address_part
};

const unsigned int sieve_core_address_parts_count =
	N_ELEMENTS(sieve_core_address_parts);

/*
 * Address-part 'extension'
 */

static bool addrp_validator_load
	(const struct sieve_extension *ext, struct sieve_validator *valdtr);

const struct sieve_extension_def address_part_extension = {
	.name = "@address-parts",
	.validator_load = addrp_validator_load
};

/*
 * Validator context:
 *   name-based address-part registry.
 */

static struct sieve_validator_object_registry *_get_object_registry
(struct sieve_validator *valdtr)
{
	struct sieve_instance *svinst;
	const struct sieve_extension *adrp_ext;

	svinst = sieve_validator_svinst(valdtr);
	adrp_ext = sieve_get_address_part_extension(svinst);
	return sieve_validator_object_registry_get(valdtr, adrp_ext);
}

void sieve_address_part_register
(struct sieve_validator *valdtr, const struct sieve_extension *ext,
	const struct sieve_address_part_def *addrp_def)
{
	struct sieve_validator_object_registry *regs = _get_object_registry(valdtr);

	sieve_validator_object_registry_add(regs, ext, &addrp_def->obj_def);
}

static bool sieve_address_part_exists
(struct sieve_validator *valdtr, const char *identifier)
{
	struct sieve_validator_object_registry *regs = _get_object_registry(valdtr);

	return sieve_validator_object_registry_find(regs, identifier, NULL);
}

static const struct sieve_address_part *sieve_address_part_create_instance
(struct sieve_validator *valdtr, struct sieve_command *cmd,
	const char *identifier)
{
	struct sieve_validator_object_registry *regs = _get_object_registry(valdtr);
	struct sieve_object object;
	struct sieve_address_part *addrp;

	if ( !sieve_validator_object_registry_find(regs, identifier, &object) )
		return NULL;

	addrp = p_new(sieve_command_pool(cmd), struct sieve_address_part, 1);
	addrp->object = object;
	addrp->def = (const struct sieve_address_part_def *) object.def;

  return addrp;
}

static bool addrp_validator_load
(const struct sieve_extension *ext, struct sieve_validator *valdtr)
{
	struct sieve_validator_object_registry *regs =
		sieve_validator_object_registry_init(valdtr, ext);
	unsigned int i;

	/* Register core address-parts */
	for ( i = 0; i < sieve_core_address_parts_count; i++ ) {
		sieve_validator_object_registry_add
			(regs, NULL, &(sieve_core_address_parts[i]->obj_def));
	}

	return TRUE;
}

void sieve_address_parts_link_tags
(struct sieve_validator *valdtr, struct sieve_command_registration *cmd_reg,
	int id_code)
{
	struct sieve_instance *svinst;
	const struct sieve_extension *adrp_ext;

	svinst = sieve_validator_svinst(valdtr);
	adrp_ext = sieve_get_address_part_extension(svinst);

	sieve_validator_register_tag
		(valdtr, cmd_reg, adrp_ext, &address_part_tag, id_code);
}

/*
 * Address-part tagged argument
 */

/* Forward declarations */

static bool tag_address_part_is_instance_of
	(struct sieve_validator *valdtr, struct sieve_command *cmd,
		const struct sieve_extension *ext, const char *identifier, void **data);
static bool tag_address_part_validate
	(struct sieve_validator *valdtr, struct sieve_ast_argument **arg,
		struct sieve_command *cmd);
static bool tag_address_part_generate
	(const struct sieve_codegen_env *cgenv, struct sieve_ast_argument *arg,
		struct sieve_command *cmd);

/* Argument object */

const struct sieve_argument_def address_part_tag = {
	.identifier = "ADDRESS-PART",
	.is_instance_of = tag_address_part_is_instance_of,
	.validate = tag_address_part_validate,
	.generate = tag_address_part_generate
};

/* Argument implementation */

static bool tag_address_part_is_instance_of
(struct sieve_validator *valdtr, struct sieve_command *cmd,
	const struct sieve_extension *ext ATTR_UNUSED, const char *identifier,
	void **data)
{
	const struct sieve_address_part *addrp;

	if ( data == NULL )
		return sieve_address_part_exists(valdtr, identifier);

	if ( (addrp=sieve_address_part_create_instance
		(valdtr, cmd, identifier)) == NULL )
		return FALSE;

	*data = (void *) addrp;
	return TRUE;
}

static bool tag_address_part_validate
(struct sieve_validator *valdtr ATTR_UNUSED, struct sieve_ast_argument **arg,
	struct sieve_command *cmd ATTR_UNUSED)
{
	/* NOTE: Currenly trivial, but might need to allow for further validation for
	 * future extensions.
	 */

	/* Syntax:
	 *   ":localpart" / ":domain" / ":all" (subject to extension)
   	 */

	/* Skip tag */
	*arg = sieve_ast_argument_next(*arg);

	return TRUE;
}

static bool tag_address_part_generate
(const struct sieve_codegen_env *cgenv, struct sieve_ast_argument *arg,
	struct sieve_command *cmd ATTR_UNUSED)
{
	struct sieve_address_part *addrp =
		(struct sieve_address_part *) arg->argument->data;

	sieve_opr_address_part_emit(cgenv->sblock, addrp);

	return TRUE;
}

/*
 * Address-part operand
 */

const struct sieve_operand_class sieve_address_part_operand_class =
	{ "address part" };

static const struct sieve_extension_objects core_address_parts =
	SIEVE_EXT_DEFINE_MATCH_TYPES(sieve_core_address_parts);

const struct sieve_operand_def address_part_operand = {
	.name = "address-part",
	.code = SIEVE_OPERAND_ADDRESS_PART,
	.class = &sieve_address_part_operand_class,
	.interface = &core_address_parts
};

/*
 * Address-part string list
 */

static int sieve_address_part_stringlist_next_item
	(struct sieve_stringlist *_strlist, string_t **str_r);
static void sieve_address_part_stringlist_reset
	(struct sieve_stringlist *_strlist);
static int sieve_address_part_stringlist_get_length
	(struct sieve_stringlist *_strlist);
static void sieve_address_part_stringlist_set_trace
(struct sieve_stringlist *_strlist, bool trace);

struct sieve_address_part_stringlist {
	struct sieve_stringlist strlist;

	const struct sieve_address_part *addrp;
	struct sieve_address_list *addresses;
};

struct sieve_stringlist *sieve_address_part_stringlist_create
(const struct sieve_runtime_env *renv, const struct sieve_address_part *addrp,
	struct sieve_address_list *addresses)
{
	struct sieve_address_part_stringlist *strlist;

	strlist = t_new(struct sieve_address_part_stringlist, 1);
	strlist->strlist.runenv = renv;
	strlist->strlist.next_item = sieve_address_part_stringlist_next_item;
	strlist->strlist.reset = sieve_address_part_stringlist_reset;
	strlist->strlist.get_length = sieve_address_part_stringlist_get_length;
	strlist->strlist.set_trace = sieve_address_part_stringlist_set_trace;

	strlist->addrp = addrp;
	strlist->addresses = addresses;

	return &strlist->strlist;
}

static int sieve_address_part_stringlist_next_item
	(struct sieve_stringlist *_strlist, string_t **str_r)
{
	struct sieve_address_part_stringlist *strlist =
		(struct sieve_address_part_stringlist *)_strlist;
	struct smtp_address item;
	string_t *item_unparsed;
	int ret;

	*str_r = NULL;

	while ( *str_r == NULL ) {
		if ( (ret=sieve_address_list_next_item
			(strlist->addresses, &item, &item_unparsed)) <= 0 )
			return ret;

		if ( item.localpart == NULL ) {
			if ( item_unparsed != NULL ) {
				if ( _strlist->trace ) {
					sieve_runtime_trace(_strlist->runenv, 0,
						"extracting `%s' part from non-address value `%s'",
						sieve_address_part_name(strlist->addrp),
						str_sanitize(str_c(item_unparsed), 80));
				}

				if ( str_len(item_unparsed) == 0 ||
					sieve_address_part_is(strlist->addrp, all_address_part) )
					*str_r = item_unparsed;
			}
		} else {
			const struct sieve_address_part *addrp = strlist->addrp;
			const char *part = NULL;

			if ( _strlist->trace ) {
				sieve_runtime_trace(_strlist->runenv, 0,
					"extracting `%s' part from address %s",
					sieve_address_part_name(strlist->addrp),
					smtp_address_encode_path(&item));
			}

			if ( addrp->def != NULL && addrp->def->extract_from != NULL )
				part = addrp->def->extract_from(addrp, &item);

			if ( part != NULL )
				*str_r = t_str_new_const(part, strlen(part));
		}
	}

	return 1;
}

static void sieve_address_part_stringlist_reset
	(struct sieve_stringlist *_strlist)
{
	struct sieve_address_part_stringlist *strlist =
		(struct sieve_address_part_stringlist *)_strlist;

	sieve_address_list_reset(strlist->addresses);
}

static int sieve_address_part_stringlist_get_length
	(struct sieve_stringlist *_strlist)
{
	struct sieve_address_part_stringlist *strlist =
		(struct sieve_address_part_stringlist *)_strlist;

	return sieve_address_list_get_length(strlist->addresses);
}

static void sieve_address_part_stringlist_set_trace
(struct sieve_stringlist *_strlist, bool trace)
{
	struct sieve_address_part_stringlist *strlist =
		(struct sieve_address_part_stringlist *)_strlist;

	sieve_address_list_set_trace(strlist->addresses, trace);
}

/*
 * Default ADDRESS-PART, MATCH-TYPE, COMPARATOR access
 */

int sieve_addrmatch_opr_optional_dump
(const struct sieve_dumptime_env *denv, sieve_size_t *address,
	signed int *opt_code)
{
	signed int _opt_code = 0;
	bool final = FALSE, opok = TRUE;

	if ( opt_code == NULL ) {
		opt_code = &_opt_code;
		final = TRUE;
	}

	while ( opok ) {
		int opt;

		if ( (opt=sieve_opr_optional_dump(denv, address, opt_code)) <= 0 )
			return opt;

		switch ( *opt_code ) {
		case SIEVE_MATCH_OPT_COMPARATOR:
			opok = sieve_opr_comparator_dump(denv, address);
			break;
		case SIEVE_MATCH_OPT_MATCH_TYPE:
			opok = sieve_opr_match_type_dump(denv, address);
			break;
		case SIEVE_AM_OPT_ADDRESS_PART:
			opok = sieve_opr_address_part_dump(denv, address);
			break;
		default:
			return ( final ? -1 : 1 );
		}
	}

	return -1;
}

int sieve_addrmatch_opr_optional_read
(const struct sieve_runtime_env *renv, sieve_size_t *address,
	signed int *opt_code, int *exec_status, struct sieve_address_part *addrp,
	struct sieve_match_type *mtch, struct sieve_comparator *cmp)
{
	signed int _opt_code = 0;
	bool final = FALSE;
	int status = SIEVE_EXEC_OK;

	if ( opt_code == NULL ) {
		opt_code = &_opt_code;
		final = TRUE;
	}

	if ( exec_status != NULL )
		*exec_status = SIEVE_EXEC_OK;

	while ( status == SIEVE_EXEC_OK ) {
		int opt;

		if ( (opt=sieve_opr_optional_read(renv, address, opt_code)) <= 0 ){
			if ( opt < 0 && exec_status != NULL )
				*exec_status = SIEVE_EXEC_BIN_CORRUPT;
			return opt;
		}

		switch ( *opt_code ) {
		case SIEVE_MATCH_OPT_COMPARATOR:
			if (cmp == NULL) {
				sieve_runtime_trace_error(renv, "unexpected comparator operand");
				if ( exec_status != NULL )
					*exec_status = SIEVE_EXEC_BIN_CORRUPT;
				return -1;
			}
			status = sieve_opr_comparator_read(renv, address, cmp);
			break;
		case SIEVE_MATCH_OPT_MATCH_TYPE:
			if (mtch == NULL) {
				sieve_runtime_trace_error(renv, "unexpected match-type operand");
				if ( exec_status != NULL )
					*exec_status = SIEVE_EXEC_BIN_CORRUPT;
				return -1;
			}
			status = sieve_opr_match_type_read(renv, address, mtch);
			break;
		case SIEVE_AM_OPT_ADDRESS_PART:
			if (addrp == NULL) {
				sieve_runtime_trace_error(renv, "unexpected address-part operand");
				if ( exec_status != NULL )
					*exec_status = SIEVE_EXEC_BIN_CORRUPT;
				return -1;
			}
			status = sieve_opr_address_part_read(renv, address, addrp);
			break;
		default:
			if ( final ) {
				sieve_runtime_trace_error(renv, "invalid optional operand");
				if ( exec_status != NULL )
					*exec_status = SIEVE_EXEC_BIN_CORRUPT;
				return -1;
			}
			return 1;
		}
	}

	if ( exec_status != NULL )
		*exec_status = status;
	return -1;
}

/*
 * Core address-part modifiers
 */

static const char *addrp_all_extract_from
(const struct sieve_address_part *addrp ATTR_UNUSED,
	const struct smtp_address *address)
{
	if ( address->localpart == NULL )
		return NULL;
	return smtp_address_encode(address);
}

static const char *addrp_domain_extract_from
(const struct sieve_address_part *addrp ATTR_UNUSED,
	const struct smtp_address *address)
{
	return address->domain;
}

static const char *addrp_localpart_extract_from
(const struct sieve_address_part *addrp ATTR_UNUSED,
	const struct smtp_address *address)
{
	return address->localpart;
}

const struct sieve_address_part_def all_address_part = {
	SIEVE_OBJECT("all",
		&address_part_operand, SIEVE_ADDRESS_PART_ALL),
	.extract_from = addrp_all_extract_from
};

const struct sieve_address_part_def local_address_part = {
	SIEVE_OBJECT("localpart",
		&address_part_operand, SIEVE_ADDRESS_PART_LOCAL),
	.extract_from = addrp_localpart_extract_from
};

const struct sieve_address_part_def domain_address_part = {
	SIEVE_OBJECT("domain",
		&address_part_operand,	SIEVE_ADDRESS_PART_DOMAIN),
	.extract_from = addrp_domain_extract_from
};