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

#include "lib.h"
#include "str.h"
#include "istream.h"
#include "smtp-params.h"
#include "message-address.h"
#include "mail-storage.h"
#include "master-service.h"
#include "mail-raw.h"

#include "sieve-common.h"
#include "sieve-address.h"
#include "sieve-error.h"
#include "sieve-message.h"
#include "sieve-interpreter.h"

#include "sieve-tool.h"

#include "testsuite-common.h"
#include "testsuite-message.h"

/*
 * Testsuite message environment
 */

struct testsuite_message {
	struct testsuite_message *next;

	struct mail_raw *mail_raw;
};

struct sieve_message_data testsuite_msgdata;
static struct smtp_params_rcpt testsuite_rcpt_params;

static struct testsuite_message *testsuite_msg;

static const char *_default_message_data =
"From: sender@example.com\n"
"To: recipient@example.org\n"
"Subject: Frop!\n"
"\n"
"Friep!\n";

static struct smtp_address *testsuite_env_mail_from = NULL;
static struct smtp_address *testsuite_env_rcpt_to = NULL;
static struct smtp_address *testsuite_env_orig_rcpt_to = NULL;
static char *testsuite_env_auth = NULL;

static pool_t testsuite_msg_pool;
static string_t *testsuite_msg_default;
static char *testsuite_msg_id = NULL;

static const struct smtp_address *
testsuite_message_get_address(struct mail *mail, const char *header)
{
	struct message_address *addr;
	struct smtp_address *smtp_addr;
	const char *str;

	if (mail_get_first_header(mail, header, &str) <= 0)
		return NULL;
	addr = message_address_parse(pool_datastack_create(),
				     (const unsigned char *)str,
				     strlen(str), 1, 0);
	if (addr == NULL || addr->mailbox == NULL || *addr->mailbox == '\0')
		return NULL;
	if (smtp_address_create_from_msg_temp(addr, &smtp_addr) < 0)
		return NULL;
	return smtp_addr;
}

static void testsuite_message_set_data(struct mail *mail)
{
	const struct smtp_address *recipient = NULL, *sender = NULL;
	const char *msg_id;

	static const struct smtp_address default_recipient = {
		.localpart = "recipient",
		.domain = "example.com",
	};
	static const struct smtp_address default_sender = {
		.localpart = "sender",
		.domain = "example.com",
	};

	i_free(testsuite_env_mail_from);
	i_free(testsuite_env_rcpt_to);
	i_free(testsuite_env_orig_rcpt_to);
	i_free(testsuite_env_auth);
	i_free(testsuite_msg_id);

	/*
	 * Collect necessary message data
	 */

	/* Get recipient address */
	recipient = testsuite_message_get_address(mail, "Envelope-To");
	if (recipient == NULL)
		recipient = testsuite_message_get_address(mail, "To");
	if (recipient == NULL)
		recipient = &default_recipient;

	/* Get sender address */
	sender = testsuite_message_get_address(mail, "Return-path");
	if (sender == NULL)
		sender = testsuite_message_get_address(mail, "Sender");
	if (sender == NULL)
		sender = testsuite_message_get_address(mail, "From");
	if (sender == NULL)
		sender = &default_sender;

	testsuite_env_mail_from = smtp_address_clone(default_pool, sender);
	testsuite_env_rcpt_to = smtp_address_clone(default_pool, recipient);
	testsuite_env_orig_rcpt_to = smtp_address_clone(default_pool, recipient);

	(void)mail_get_message_id(mail, &msg_id);
	testsuite_msg_id = i_strdup(msg_id);

	i_zero(&testsuite_msgdata);
	testsuite_msgdata.mail = mail;
	testsuite_msgdata.auth_user = sieve_tool_get_username(sieve_tool);
	testsuite_msgdata.envelope.mail_from = testsuite_env_mail_from;
	testsuite_msgdata.envelope.rcpt_to = testsuite_env_rcpt_to;
	testsuite_msgdata.id = testsuite_msg_id;

	i_zero(&testsuite_rcpt_params);
	testsuite_rcpt_params.orcpt.addr = testsuite_env_orig_rcpt_to;

	testsuite_msgdata.envelope.rcpt_params = &testsuite_rcpt_params;
}

static struct testsuite_message *testsuite_message_new(void)
{
	struct testsuite_message *msg;

	msg = i_new(struct testsuite_message, 1);
	msg->next = testsuite_msg;
	testsuite_msg = msg;

	return msg;
}

static void testsuite_message_new_string(string_t *mail_str)
{
	struct mail_user *mail_raw_user =
		sieve_tool_get_mail_raw_user(sieve_tool);
	struct testsuite_message *msg;

	msg = testsuite_message_new();
	msg->mail_raw = mail_raw_open_data(mail_raw_user, mail_str);

	testsuite_message_set_data(msg->mail_raw->mail);
}

static void testsuite_message_new_file(const char *mail_path)
{
	struct mail_user *mail_raw_user =
		sieve_tool_get_mail_raw_user(sieve_tool);
	struct testsuite_message *msg;

	msg = testsuite_message_new();
	msg->mail_raw = mail_raw_open_file(mail_raw_user, mail_path);

	testsuite_message_set_data(msg->mail_raw->mail);
}

static void testsuite_message_free(bool all)
{
	struct testsuite_message *msg;

	if (testsuite_msg == NULL)
		return;

	msg = (all ? testsuite_msg : testsuite_msg->next);
	while (msg != NULL) {
		struct testsuite_message *msg_next = msg->next;

		mail_raw_close(&msg->mail_raw);
		i_free(msg);

		msg = msg_next;
	}
	if (all)
		testsuite_msg = NULL;
	else
		testsuite_msg->next = NULL;
}

void testsuite_message_flush(void)
{
	testsuite_message_free(FALSE);
}

void testsuite_message_init(void)
{
	testsuite_msg_pool = pool_alloconly_create("testsuite_message", 6096);

	testsuite_msg_default = str_new(testsuite_msg_pool, 1024);
	str_append(testsuite_msg_default, _default_message_data);

	testsuite_message_new_string(testsuite_msg_default);
}

void testsuite_message_set_default(const struct sieve_runtime_env *renv)
{
	sieve_message_context_reset(renv->msgctx);

	testsuite_message_new_string(testsuite_msg_default);
}

void testsuite_message_set_string(const struct sieve_runtime_env *renv,
				  string_t *message)
{
	sieve_message_context_reset(renv->msgctx);

	testsuite_message_new_string(message);
}

void testsuite_message_set_file(const struct sieve_runtime_env *renv,
				const char *file_path)
{
	sieve_message_context_reset(renv->msgctx);

	testsuite_message_new_file(file_path);
}

void testsuite_message_set_mail(const struct sieve_runtime_env *renv,
				struct mail *mail)
{
	sieve_message_context_reset(renv->msgctx);

	testsuite_message_set_data(mail);
}

void testsuite_message_deinit(void)
{
	testsuite_message_free(TRUE);

	i_free(testsuite_env_mail_from);
	i_free(testsuite_env_rcpt_to);
	i_free(testsuite_env_orig_rcpt_to);
	i_free(testsuite_env_auth);
	pool_unref(&testsuite_msg_pool);
	i_free(testsuite_msg_id);
}

void testsuite_envelope_set_sender_address(const struct sieve_runtime_env *renv,
					   const struct smtp_address *address)
{
	sieve_message_context_reset(renv->msgctx);

	i_free(testsuite_env_mail_from);

	testsuite_env_mail_from = smtp_address_clone(default_pool, address);
	testsuite_msgdata.envelope.mail_from = testsuite_env_mail_from;
}

void testsuite_envelope_set_sender(const struct sieve_runtime_env *renv,
				   const char *value)
{
	struct smtp_address *address = NULL;
	const char *error;

	if (smtp_address_parse_path(pool_datastack_create(), value,
				    (SMTP_ADDRESS_PARSE_FLAG_ALLOW_EMPTY |
				     SMTP_ADDRESS_PARSE_FLAG_BRACKETS_OPTIONAL),
				    &address, &error) < 0) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: envelope sender address "
			"'%s' is invalid: %s", value, error);
	}
	testsuite_envelope_set_sender_address(renv, address);
}

void testsuite_envelope_set_recipient_address(
	const struct sieve_runtime_env *renv,
	const struct smtp_address *address)
{
	sieve_message_context_reset(renv->msgctx);

	i_free(testsuite_env_rcpt_to);
	i_free(testsuite_env_orig_rcpt_to);

	testsuite_env_rcpt_to = smtp_address_clone(default_pool, address);
	testsuite_env_orig_rcpt_to = smtp_address_clone(default_pool, address);
	testsuite_msgdata.envelope.rcpt_to = testsuite_env_rcpt_to;
	testsuite_rcpt_params.orcpt.addr = testsuite_env_orig_rcpt_to;
}

void testsuite_envelope_set_recipient(const struct sieve_runtime_env *renv,
				      const char *value)
{
	struct smtp_address *address = NULL;
	const char *error;

	if (smtp_address_parse_path(pool_datastack_create(), value,
				    (SMTP_ADDRESS_PARSE_FLAG_ALLOW_LOCALPART |
				     SMTP_ADDRESS_PARSE_FLAG_BRACKETS_OPTIONAL),
				    &address, &error) < 0) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: envelope recipient address "
			"'%s' is invalid: %s", value, error);
	}
	testsuite_envelope_set_recipient_address(renv, address);
}

void testsuite_envelope_set_orig_recipient_address(
	const struct sieve_runtime_env *renv,
	const struct smtp_address *address)
{
	sieve_message_context_reset(renv->msgctx);

	i_free(testsuite_env_orig_rcpt_to);

	testsuite_env_orig_rcpt_to = smtp_address_clone(default_pool, address);
	testsuite_rcpt_params.orcpt.addr = testsuite_env_orig_rcpt_to;
}

void testsuite_envelope_set_orig_recipient(const struct sieve_runtime_env *renv,
					   const char *value)
{
	struct smtp_address *address = NULL;
	const char *error;

	if (smtp_address_parse_path(pool_datastack_create(), value,
				    (SMTP_ADDRESS_PARSE_FLAG_ALLOW_LOCALPART |
				     SMTP_ADDRESS_PARSE_FLAG_BRACKETS_OPTIONAL),
				    &address, &error) < 0) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: envelope recipient address "
			"'%s' is invalid: %s", value, error);
	}
	testsuite_envelope_set_orig_recipient_address(renv, address);
}

void testsuite_envelope_set_auth_user(const struct sieve_runtime_env *renv,
				      const char *value)
{
	sieve_message_context_reset(renv->msgctx);

	i_free(testsuite_env_auth);

	testsuite_env_auth = i_strdup(value);
	testsuite_msgdata.auth_user = testsuite_env_auth;
}
