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

#include "lib.h"
#include "mempool.h"
#include "imem.h"
#include "array.h"
#include "strfuncs.h"
#include "str-sanitize.h"
#include "path-util.h"
#include "unlink-directory.h"
#include "env-util.h"
#include "mail-storage-service.h"
#include "mail-namespace.h"
#include "mail-storage.h"
#include "imap-metadata.h"

#include "sieve-common.h"
#include "sieve-error.h"
#include "sieve-actions.h"
#include "sieve-interpreter.h"

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

#include "testsuite-mailstore.h"

#include <sys/stat.h>
#include <sys/types.h>

struct testsuite_mailstore_mail {
	struct testsuite_mailstore_mail *next;

	char *folder;
	struct mailbox *box;
	struct mailbox_transaction_context *trans;
	struct mail *mail;
};

/*
 * Forward declarations
 */

static void testsuite_mailstore_free(bool all);

/*
 * State
 */

static struct mail_user *testsuite_mailstore_user = NULL;

static struct testsuite_mailstore_mail *testsuite_mailstore_mail = NULL;

static char *testsuite_mailstore_location = NULL;
static char *testsuite_mailstore_attrs = NULL;

/*
 * Initialization
 */

void testsuite_mailstore_init(void)
{
	struct mail_user *mail_user_dovecot, *mail_user;
	struct mail_namespace *ns;
	struct mail_namespace_settings *ns_set;
	struct mail_storage *storage;
	const char *tmpdir, *error, *cwd;

	tmpdir = testsuite_tmp_dir_get();
	testsuite_mailstore_location =
		i_strconcat(tmpdir, "/mailstore", NULL);
	testsuite_mailstore_attrs =
		i_strconcat(tmpdir, "/mail-attrs.dict", NULL);

	if (mkdir(testsuite_mailstore_location, 0700) < 0) {
		i_fatal("failed to create temporary directory '%s': %m.",
			testsuite_mailstore_location);
	}

	mail_user_dovecot = sieve_tool_get_mail_user(sieve_tool);

	if (t_get_working_dir(&cwd, &error) < 0)
		i_fatal("Failed to get working directory: %s", error);
	const char *const code_override_fields[] = {
		t_strconcat("mail_home=", cwd, NULL),
		"mail_driver=maildir",
		t_strconcat("mail_path=", testsuite_mailstore_location, NULL),
#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
		"mail_attribute/dict=file",
		"mail_attribute/dict/file/driver=file",
		t_strconcat("mail_attribute/dict/file/path=", testsuite_mailstore_attrs, NULL),
#endif
		NULL,
	};
	struct settings_instance *set_instance =
		mail_storage_service_user_get_settings_instance(mail_user_dovecot->service_user);
	struct mail_storage_service_input input = {
		.username = "testsuite-mail-user@example.org",
		.set_instance = set_instance,
		.no_userdb_lookup = TRUE,
		.code_override_fields = code_override_fields,
	};
	if (mail_storage_service_lookup_next(
			sieve_tool_get_mail_storage_service(sieve_tool),
			&input, &mail_user, &error) < 0)
		i_fatal("Test user initialization failed: %s", error);
	mail_user->autocreated = TRUE;

	ns_set = p_new(mail_user->pool, struct mail_namespace_settings, 1);
	ns_set->name = "";
	ns_set->separator = ".";

	ns = mail_namespaces_init_empty(mail_user);
	ns->flags |= NAMESPACE_FLAG_INBOX_USER;
	ns->set = ns_set;

	if (mail_storage_create(ns, mail_user->event, 0, &storage, &error) < 0)
		i_fatal("Couldn't create testsuite storage: %s", error);
	if (mail_namespaces_init_finish(ns, &error) < 0)
		i_fatal("Couldn't create testsuite namespace: %s", error);

	testsuite_mailstore_user = mail_user;
}

void testsuite_mailstore_deinit(void)
{
	const char *error;

	testsuite_mailstore_free(TRUE);

	if (unlink_directory(testsuite_mailstore_location,
			     UNLINK_DIRECTORY_FLAG_RMDIR, &error) < 0) {
		i_warning("failed to remove temporary directory '%s': %s.",
			  testsuite_mailstore_location, error);
	}

	i_free(testsuite_mailstore_location);
	i_free(testsuite_mailstore_attrs);
	mail_user_unref(&testsuite_mailstore_user);
}

/*
 * Mail user
 */

struct mail_user *testsuite_mailstore_get_user(void)
{
	if (testsuite_mailstore_user == NULL)
		return sieve_tool_get_mail_user(sieve_tool);
	return testsuite_mailstore_user;
}

/*
 * Mailbox Access
 */

bool testsuite_mailstore_mailbox_create(
	const struct sieve_runtime_env *renv ATTR_UNUSED, const char *folder)
{
	struct mail_user *mail_user = testsuite_mailstore_user;
	struct mail_namespace *ns = mail_user->namespaces;
	struct mailbox *box;

	box = mailbox_alloc(ns->list, folder, 0);

	if (mailbox_create(box, NULL, FALSE) < 0) {
		mailbox_free(&box);
		return FALSE;
	}

	mailbox_free(&box);

	return TRUE;
}

static struct testsuite_mailstore_mail *
testsuite_mailstore_open(const char *folder)
{
	enum mailbox_flags flags =
		MAILBOX_FLAG_SAVEONLY | MAILBOX_FLAG_POST_SESSION;
	struct mail_user *mail_user = testsuite_mailstore_user;
	struct mail_namespace *ns = mail_user->namespaces;
	struct mailbox *box;
	struct mailbox_transaction_context *t;
	struct testsuite_mailstore_mail *tmail, *tmail_prev;
	const char *error;

	if (!sieve_mailbox_check_name(folder, &error)) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: invalid mailbox name '%s' specified: %s",
			folder, error);
		return NULL;
	}

	tmail = testsuite_mailstore_mail;
	tmail_prev = NULL;
	while (tmail != NULL) {
		if (strcmp(tmail->folder, folder) == 0) {
			if (tmail_prev != NULL) {
				/* Remove it from list if it is not first. */
				tmail_prev->next = tmail->next;
			}
			break;
		}
		tmail_prev = tmail;
		tmail = tmail->next;
	}
	if (tmail != NULL) {
		if (tmail != testsuite_mailstore_mail) {
			/* Bring it to front */
			tmail->next = testsuite_mailstore_mail;
			testsuite_mailstore_mail = tmail;
		}
		return tmail;
	}

	box = mailbox_alloc(ns->list, folder, flags);
	if (mailbox_open(box) < 0) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: failed to open mailbox '%s'", folder);
		mailbox_free(&box);
		return NULL;
	}

	/* Sync mailbox */

	if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: failed to sync mailbox '%s'", folder);
		mailbox_free(&box);
		return NULL;
	}

	/* Start transaction */

	t = mailbox_transaction_begin(box, 0, __func__);

	tmail = i_new(struct testsuite_mailstore_mail, 1);
	tmail->next = testsuite_mailstore_mail;
	testsuite_mailstore_mail = tmail;

	tmail->folder = i_strdup(folder);
	tmail->box = box;
	tmail->trans = t;
	tmail->mail = mail_alloc(t, 0, NULL);

	return tmail;
}

static void testsuite_mailstore_free(bool all)
{
	struct testsuite_mailstore_mail *tmail;

	if (testsuite_mailstore_mail == NULL)
		return;

	tmail = (all ?
		 testsuite_mailstore_mail : testsuite_mailstore_mail->next);
	while (tmail != NULL) {
		struct testsuite_mailstore_mail *tmail_next = tmail->next;

		mail_free(&tmail->mail);
		mailbox_transaction_rollback(&tmail->trans);
		mailbox_free(&tmail->box);
		i_free(tmail->folder);
		i_free(tmail);

		tmail = tmail_next;
	}
	if (all)
		testsuite_mailstore_mail = NULL;
	else
		testsuite_mailstore_mail->next = NULL;
}

void testsuite_mailstore_flush(void)
{
	testsuite_mailstore_free(FALSE);
}

bool testsuite_mailstore_mail_index(const struct sieve_runtime_env *renv,
				    const char *folder, unsigned int index)
{
	struct testsuite_mailstore_mail *tmail;
	struct mailbox_status status;

	tmail = testsuite_mailstore_open(folder);
	if (tmail == NULL) {
		testsuite_message_set_default(renv);
		return FALSE;
	}

	mailbox_get_open_status(tmail->box, STATUS_MESSAGES, &status);
	if (index >= status.messages)
		return FALSE;

	mail_set_seq(tmail->mail, index+1);
	testsuite_message_set_mail(renv, tmail->mail);

	return TRUE;
}

/*
 * IMAP metadata
 */

int testsuite_mailstore_set_imap_metadata(const char *mailbox,
					  const char *annotation,
					  const char *value)
{
	struct imap_metadata_transaction *imtrans;
	struct mail_attribute_value avalue;
	struct mailbox *box;
	enum mail_error error_code;
	const char *error;
	int ret;

	if (!imap_metadata_verify_entry_name(annotation, &error)) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: imap metadata: "
			"specified annotation name '%s' is invalid: %s",
			str_sanitize(annotation, 256), error);
		return -1;
	}

	if (mailbox != NULL) {
		struct mail_namespace *ns;
		ns = mail_namespace_find(testsuite_mailstore_user->namespaces,
					 mailbox);
		box = mailbox_alloc(ns->list, mailbox, 0);
		imtrans = imap_metadata_transaction_begin(box);
	} else {
		box = NULL;
		imtrans = imap_metadata_transaction_begin_server(
			testsuite_mailstore_user);
	}

	i_zero(&avalue);
	avalue.value = value;
	if ((ret = imap_metadata_set(imtrans, annotation, &avalue)) < 0) {
		error = imap_metadata_transaction_get_last_error(
			imtrans, &error_code);
		imap_metadata_transaction_rollback(&imtrans);
	} else {
		ret = imap_metadata_transaction_commit(&imtrans,
						       &error_code, &error);
	}
	if (box != NULL)
		mailbox_free(&box);

	if (ret < 0) {
		e_error(testsuite_sieve_instance->event,
			"testsuite: imap metadata: "
			"failed to assign annotation '%s': %s",
			str_sanitize(annotation, 256), error);
		return -1;
	}
	return 0;
}
