//
// VMime library (http://www.vmime.org)
// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 3 of
// the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// Linking this library statically or dynamically with other modules is making
// a combined work based on this library.  Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//

#include "vmime/config.hpp"


#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_MAILDIR


#include "vmime/net/maildir/format/courierMaildirFormat.hpp"

#include "vmime/net/maildir/maildirStore.hpp"
#include "vmime/net/maildir/maildirUtils.hpp"

#include "vmime/platform.hpp"


namespace vmime {
namespace net {
namespace maildir {
namespace format {


courierMaildirFormat::courierMaildirFormat(const shared_ptr <context>& ctx)
	: maildirFormat(ctx) {

}


const string courierMaildirFormat::getName() const {

	return "courier";
}


void courierMaildirFormat::createFolder(const folder::path& path) {

	shared_ptr <utility::fileSystemFactory> fsf = platform::getHandler()->getFileSystemFactory();

	if (!fsf->isValidPath(folderPathToFileSystemPath(path, ROOT_DIRECTORY))) {
		throw exceptions::invalid_folder_name();
	}

	shared_ptr <utility::file> rootDir = fsf->create(
		folderPathToFileSystemPath(path, ROOT_DIRECTORY)
	);

	shared_ptr <utility::file> newDir = fsf->create(
		folderPathToFileSystemPath(path, NEW_DIRECTORY)
	);
	shared_ptr <utility::file> tmpDir = fsf->create(
		folderPathToFileSystemPath(path, TMP_DIRECTORY)
	);
	shared_ptr <utility::file> curDir = fsf->create(
		folderPathToFileSystemPath(path, CUR_DIRECTORY)
	);

	rootDir->createDirectory(true);

	newDir->createDirectory(false);
	tmpDir->createDirectory(false);
	curDir->createDirectory(false);

	shared_ptr <utility::file> maildirFile = fsf->create(
		folderPathToFileSystemPath(path, ROOT_DIRECTORY)
		 	/ utility::file::path::component("maildirfolder")
	);

	maildirFile->createFile();
}


void courierMaildirFormat::destroyFolder(const folder::path& path) {

	shared_ptr <utility::fileSystemFactory> fsf = platform::getHandler()->getFileSystemFactory();

	// Recursively delete directories of subfolders
	const std::vector <folder::path> folders = listFolders(path, true);

	for (std::vector <folder::path>::size_type i = 0, n = folders.size() ; i < n ; ++i) {

		maildirUtils::recursiveFSDelete(
			fsf->create(folderPathToFileSystemPath(folders[i], ROOT_DIRECTORY))
		);
	}

	// Recursively delete the directory of this folder
	maildirUtils::recursiveFSDelete(
		fsf->create(folderPathToFileSystemPath(path, ROOT_DIRECTORY))
	);
}


void courierMaildirFormat::renameFolder(
	const folder::path& oldPath,
	const folder::path& newPath
) {

	const std::vector <folder::path> folders = listFolders(oldPath, true);

	for (std::vector <folder::path>::size_type i = 0, n = folders.size() ; i < n ; ++i) {

		const folder::path folderOldPath = folders[i];

		folder::path folderNewPath = folderOldPath;
		folderNewPath.renameParent(oldPath, newPath);

		renameFolderImpl(folderOldPath, folderNewPath);
	}

	renameFolderImpl(oldPath, newPath);
}


void courierMaildirFormat::renameFolderImpl(
	const folder::path& oldPath,
	const folder::path& newPath
) {

	shared_ptr <utility::fileSystemFactory> fsf = platform::getHandler()->getFileSystemFactory();

	const utility::file::path oldFSPath =
		folderPathToFileSystemPath(oldPath, ROOT_DIRECTORY);

	const utility::file::path newFSPath =
		folderPathToFileSystemPath(newPath, ROOT_DIRECTORY);

	shared_ptr <utility::file> rootDir = fsf->create(oldFSPath);
	rootDir->rename(newFSPath);
}


bool courierMaildirFormat::folderExists(const folder::path& path) const {

	shared_ptr <utility::fileSystemFactory> fsf = platform::getHandler()->getFileSystemFactory();

	shared_ptr <utility::file> rootDir = fsf->create(
		folderPathToFileSystemPath(path, ROOT_DIRECTORY)
	);

	shared_ptr <utility::file> newDir = fsf->create(
		folderPathToFileSystemPath(path, NEW_DIRECTORY)
	);
	shared_ptr <utility::file> tmpDir = fsf->create(
		folderPathToFileSystemPath(path, TMP_DIRECTORY)
	);
	shared_ptr <utility::file> curDir = fsf->create(
		folderPathToFileSystemPath(path, CUR_DIRECTORY)
	);

	shared_ptr <utility::file> maildirFile = fsf->create(
		folderPathToFileSystemPath(path, ROOT_DIRECTORY)
		 	/ utility::file::path::component("maildirfolder")
	);

	bool exists = rootDir->exists() && rootDir->isDirectory() &&
	              newDir->exists() && newDir->isDirectory() &&
	              tmpDir->exists() && tmpDir->isDirectory() &&
	              curDir->exists() && curDir->isDirectory();

	// If this is not the root folder, then a file named "maildirfolder"
	// must also be present in the directory
	if (!path.isRoot()) {
		exists = exists && maildirFile->exists() && maildirFile->isFile();
	}

	return exists;
}


bool courierMaildirFormat::folderHasSubfolders(const folder::path& path) const {

	std::vector <string> dirs;
	return listDirectories(path, dirs, true);
}


const utility::file::path courierMaildirFormat::folderPathToFileSystemPath(
	const folder::path& path,
	const DirectoryType type
) const {

	// Virtual folder "/MyFolder/SubFolder" corresponds to physical
	// directory "[store root]/.MyFolder.SubFolder"
	utility::file::path fsPath = getContext()->getStore()->getFileSystemPath();

	if (!path.isRoot()) {

		string folderComp;

		for (size_t i = 0, n = path.getSize() ; i < n ; ++i) {
			folderComp += "." + toModifiedUTF7(path[i]);
		}

		fsPath /= utility::file::path::component(folderComp);
	}

	// Last component
	switch (type) {

		case ROOT_DIRECTORY:

			// Nothing to add
			break;

		case NEW_DIRECTORY:

			fsPath /= NEW_DIR;
			break;

		case CUR_DIRECTORY:

			fsPath /= CUR_DIR;
			break;

		case TMP_DIRECTORY:

			fsPath /= TMP_DIR;
			break;

		case CONTAINER_DIRECTORY:

			// Not used
			break;
	}

	return fsPath;
}


const std::vector <folder::path> courierMaildirFormat::listFolders(
	const folder::path& root,
	const bool recursive
) const {

	// First, list directories
	std::vector <string> dirs;
	listDirectories(root, dirs, false);

	// Then, map directories to folders
	std::vector <folder::path> folders;

	for (std::vector <string>::size_type i = 0, n = dirs.size() ; i < n ; ++i) {

		const string dir = dirs[i].substr(1) + ".";
		folder::path path;

		for (size_t pos = dir.find("."), prev = 0 ;
		     pos != string::npos ; prev = pos + 1, pos = dir.find(".", pos + 1)) {

			const string comp = dir.substr(prev, pos - prev);
			path /= fromModifiedUTF7(comp);
		}

		if (recursive || path.getSize() == root.getSize() + 1) {
			folders.push_back(path);
		}
	}

	return folders;
}


bool courierMaildirFormat::listDirectories(
	const folder::path& root,
	std::vector <string>& dirs,
	const bool onlyTestForExistence
) const {

	shared_ptr <utility::fileSystemFactory> fsf = platform::getHandler()->getFileSystemFactory();

	shared_ptr <utility::file> rootDir = fsf->create(
		getContext()->getStore()->getFileSystemPath()
	);

	if (rootDir->exists()) {

		// To speed up things, and if we are not searching in root folder,
		// search for directories with a common prefix
		string base;

		if (!root.isRoot()) {
			for (size_t i = 0, n = root.getSize() ; i < n ; ++i) {
				base += "." + toModifiedUTF7(root[i]);
			}
		}

		// Enumerate directories
		shared_ptr <utility::fileIterator> it = rootDir->getFiles();

		while (it->hasMoreElements()) {

			shared_ptr <utility::file> file = it->nextElement();

			if (isSubfolderDirectory(*file)) {

				const string dir = file->getFullPath().getLastComponent().getBuffer();

				if (base.empty() || (dir.length() > base.length() && dir.substr(0, base.length()) == base)) {

					dirs.push_back(dir);

					if (onlyTestForExistence) {
						return true;
					}
				}
			}
		}

	} else {

		// No sub-folder
	}

	std::sort(dirs.begin(), dirs.end());

	return !dirs.empty();
}


// static
bool courierMaildirFormat::isSubfolderDirectory(const utility::file& file) {

	// A directory which names starts with '.' may be a subfolder
	if (file.isDirectory() &&
	    file.getFullPath().getLastComponent().getBuffer().length() >= 1 &&
	    file.getFullPath().getLastComponent().getBuffer()[0] == '.') {

		return true;
	}

	return false;
}


// static
const string courierMaildirFormat::toModifiedUTF7(const folder::path::component& text) {

	// From http://www.courier-mta.org/?maildir.html:
	//
	// Folder names can contain any Unicode character, except for control
	// characters. US-ASCII characters, U+0x0020 - U+0x007F, except for the
	// period, forward-slash, and ampersand characters (U+0x002E, U+0x002F,
	// and U+0x0026) represent themselves. The ampersand is represented by
	// the two character sequence "&-". The period, forward slash, and non
	// US-ASCII Unicode characters are represented using the UTF-7 character
	// set, and encoded with a modified form of base64-encoding.
	//
	// The "&" character starts the modified base64-encoded sequence; the
	// sequence is terminated by the "-" character. The sequence of 16-bit
	// Unicode characters is written in big-endian order, and encoded using
	// the base64-encoding method described in section 5.2 of RFC 1521, with
	// the following modifications:
	//
	// * The "=" padding character is omitted. When decoding, an incomplete
	//   16-bit character is discarded.
	//
	// * The comma character, "," is used in place of the "/" character in
	//   the base64 alphabet.
	//
	// For example, the word "Resume" with both "e"s being the e-acute
	// character, U+0x00e9, is encoded as "R&AOk-sum&AOk-" (so a folder of
	// that name would be a maildir subdirectory called ".R&AOk-sum&AOk-").
	//

	// Transcode path component to UTF-7 charset.
	// WARNING: This may throw "exceptions::charset_conv_error"
	const string cvt = text.getConvertedText(charset(charsets::UTF_7));

	// Transcode to modified UTF-7 (RFC-2060).
	string out;
	out.reserve((cvt.length() * 3) / 2);

	bool inB64sequence = false;

	for (string::const_iterator it = cvt.begin() ; it != cvt.end() ; ++it) {

		const unsigned char c = *it;

		switch (c) {

			// Beginning of Base64 sequence: replace '+' with '&'
			case '+': {

				if (!inB64sequence) {
					inB64sequence = true;
					out += '&';
				} else {
					out += '+';
				}

				break;
			}
			// End of Base64 sequence
			case '-': {

				inB64sequence = false;
				out += '-';
				break;
			}
			// ',' is used instead of '/' in modified Base64,
			// and simply UTF7-encoded out of a Base64 sequence
			case '/': {

				if (inB64sequence) {
					out += ',';
				} else {
					out += "&Lw-";
				}

				break;
			}
			// Encode period (should not happen in a Base64 sequence)
			case '.': {

				out += "&Lg-";
				break;
			}
			// '&' (0x26) is represented by the two-octet sequence "&-"
			case '&': {

				if (!inB64sequence) {
					out += "&-";
				} else {
					out += '&';
				}

				break;
			}
			default: {

				out += c;
				break;
			}
		}
	}

	return out;
}


// static
const folder::path::component courierMaildirFormat::fromModifiedUTF7(const string& text) {

	// Transcode from modified UTF-7
	string out;
	out.reserve(text.length());

	bool inB64sequence = false;
	unsigned char prev = 0;

	for (string::const_iterator it = text.begin() ; it != text.end() ; ++it) {

		const unsigned char c = *it;

		switch (c) {

			// Start of Base64 sequence
			case '&': {

				if (!inB64sequence) {
					inB64sequence = true;
					out += '+';
				} else {
					out += '&';
				}

				break;
			}
			// End of Base64 sequence (or "&-" --> "&")
			case '-': {

				if (inB64sequence && prev == '&') {
					out += '&';
				} else {
					out += '-';
				}

				inB64sequence = false;
				break;
			}
			// ',' is used instead of '/' in modified Base64
			case ',': {

				out += (inB64sequence ? '/' : ',');
				break;
			}
			default: {

				out += c;
				break;
			}

		}

		prev = c;
	}

	// Store it as UTF-8 by default
	string cvt;
	charset::convert(out, cvt, charset(charsets::UTF_7), charset(charsets::UTF_8));

	return folder::path::component(cvt, charset(charsets::UTF_8));
}


bool courierMaildirFormat::supports() const {

	shared_ptr <utility::fileSystemFactory> fsf = platform::getHandler()->getFileSystemFactory();

	shared_ptr <utility::file> rootDir = fsf->create(
		getContext()->getStore()->getFileSystemPath()
	);

	if (rootDir->exists()) {

		// Try to find a file named "maildirfolder", which indicates
		// the Maildir is in Courier format
		shared_ptr <utility::fileIterator> it = rootDir->getFiles();

		while (it->hasMoreElements()) {

			shared_ptr <utility::file> file = it->nextElement();

			if (isSubfolderDirectory(*file)) {

				shared_ptr <utility::file> folderFile = fsf->create(
					file->getFullPath() / utility::file::path::component("maildirfolder")
				);

				if (folderFile->exists() && folderFile->isFile()) {
					return true;
				}
			}
		}
	}

	return false;
}


} // format
} // maildir
} // net
} // vmime


#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_MAILDIR