/*
 * Copyright 2010-2015, Haiku Inc. All Rights Reserved.
 * Copyright 2010 Clemens Zeidler. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 */
#ifndef COMMANDS_H
#define COMMANDS_H
 
 
#include <StringList.h>
 
#include <vector>
 
#include "Response.h"
 
 
namespace IMAP {
 
 
struct MessageEntry {
	MessageEntry()
		:
		uid(0),
		flags(0)
	{
	}
 
	uint32	uid;
	uint32	flags;
	uint32	size;
};
typedef std::vector<MessageEntry> MessageEntryList;
 
typedef std::vector<uint32> MessageUIDList;
 
enum MessageFlags {
	kSeen				= 0x01,
	kAnswered			= 0x02,
	kFlagged			= 0x04,
	kDeleted			= 0x08,
	kDraft				= 0x10,
	// \Recent doesn't really have any useful meaning, so we just ignore it
 
	kServerFlagsMask	= 0x0000ffff
};
 
 
class Handler {
public:
								Handler();
	virtual						~Handler();
 
	virtual	bool				HandleUntagged(Response& response) = 0;
};
 
 
class Command {
public:
	virtual						~Command();
 
	virtual	BString				CommandString() = 0;
	virtual	status_t			HandleTagged(Response& response);
};
 
 
class RawCommand : public Command {
public:
								RawCommand(const BString& command);
 
	virtual	BString				CommandString();
 
private:
			BString				fCommand;
};
 
 
class LoginCommand : public Command, public Handler {
public:
								LoginCommand(const char* user,
									const char* password);
 
	virtual	BString				CommandString();
	virtual	bool				HandleUntagged(Response& response);
 
			const ArgumentList&	Capabilities() const { return fCapabilities; }
 
private:
			const char*			fUser;
			const char*			fPassword;
			ArgumentList		fCapabilities;
};
 
 
class SelectCommand : public Command, public Handler {
public:
								SelectCommand();
								SelectCommand(const char* mailboxName);
 
	virtual	BString				CommandString();
	virtual	bool				HandleUntagged(Response& response);
 
			void				SetTo(const char* mailboxName);
			uint32				NextUID() { return fNextUID; }
			uint32				UIDValidity() { return fUIDValidity; }
 
private:
			BString				fMailboxName;
			uint32				fNextUID;
			uint32				fUIDValidity;
};
 
 
class CapabilityHandler : public Command, public Handler {
public:
	virtual	BString				CommandString();
	virtual	bool				HandleUntagged(Response& response);
 
			const ArgumentList&	Capabilities() const { return fCapabilities; }
 
private:
			ArgumentList		fCapabilities;
};
 
 
class FetchMessageEntriesCommand : public Command, public Handler {
public:
								FetchMessageEntriesCommand(
									MessageEntryList& entries, uint32 from,
									uint32 to, bool uids);
 
			BString				CommandString();
	virtual	bool				HandleUntagged(Response& response);
 
private:
			MessageEntryList&	fEntries;
			uint32				fFrom;
			uint32				fTo;
			bool				fUIDs;
};
 
 
enum FetchFlags {
	kFetchHeader	= 0x01,
	kFetchBody		= 0x02,
	kFetchAll		= kFetchHeader | kFetchBody,
	kFetchFlags		= 0x04,
};
 
 
class FetchListener {
public:
	virtual	bool				FetchData(uint32 fetchFlags, BDataIO& stream,
									size_t& length) = 0;
	virtual void				FetchedData(uint32 fetchFlags, uint32 uid,
									uint32 flags) = 0;
};
 
 
class FetchCommand : public Command, public Handler,
	public LiteralHandler {
public:
								FetchCommand(uint32 from, uint32 to,
									uint32 fetchFlags);
								FetchCommand(MessageUIDList& uids,
									size_t max, uint32 fetchFlags);
 
			void				SetListener(FetchListener* listener);
			FetchListener*		Listener() const { return fListener; }
 
	virtual	BString				CommandString();
	virtual	bool				HandleUntagged(Response& response);
	virtual bool				HandleLiteral(Response& response,
									ArgumentList& arguments, BDataIO& stream,
									size_t& length);
 
private:
			BString				fSequence;
			uint32				fFlags;
			FetchListener*		fListener;
};
 
 
class SetFlagsCommand : public Command, public Handler {
public:
								SetFlagsCommand(uint32 uid, uint32 flags);
 
	virtual	BString				CommandString();
	virtual	bool				HandleUntagged(Response& response);
 
private:
			uint32				fUID;
			uint32				fFlags;
};
 
 
#if 0
class AppendCommand : public IMAPMailboxCommand {
public:
								AppendCommand(IMAPMailbox& mailbox,
									BPositionIO& message, off_t size,
									int32 flags, time_t time);
 
			BString				CommandString();
			bool				HandleUntagged(const BString& response);
 
private:
			BPositionIO&		fMessageData;
			off_t				fDataSize;
			int32				fFlags;
			time_t				fTime;
};
#endif
 
 
class ExistsListener {
public:
	virtual	void				MessageExistsReceived(uint32 count) = 0;
};
 
 
class ExistsHandler : public Handler {
public:
								ExistsHandler();
 
			void				SetListener(ExistsListener* listener);
			ExistsListener*		Listener() const { return fListener; }
 
	virtual	bool				HandleUntagged(Response& response);
 
private:
			ExistsListener*		fListener;
};
 
 
/*! Just send a expunge command to delete kDeleted flagged messages. The
	response is handled by the unsolicited ExpungeHandler which is installed
	all the time.
*/
class ExpungeCommand : public Command {
public:
								ExpungeCommand();
 
			BString				CommandString();
};
 
 
class ExpungeListener {
public:
	virtual	void				MessageExpungeReceived(uint32 index) = 0;
};
 
 
class ExpungeHandler : public Handler {
public:
								ExpungeHandler();
 
			void				SetListener(ExpungeListener* listener);
			ExpungeListener*	Listener() const { return fListener; }
 
	virtual	bool				HandleUntagged(Response& response);
 
private:
			ExpungeListener*	fListener;
};
 
 
#if 0
class FlagsHandler : public Handler {
public:
								FlagsHandler(IMAPMailbox& mailbox);
 
			bool				HandleUntagged(const BString& response);
};
#endif
 
 
class ListCommand : public Command, public Handler {
public:
								ListCommand(const char* prefix,
									bool subscribedOnly);
 
	virtual	BString				CommandString();
	virtual	bool				HandleUntagged(Response& response);
 
			const BStringList&	FolderList();
			const BString&		Separator() { return fSeparator; }
 
private:
			const char*			_Command() const;
 
private:
			RFC3501Encoding		fEncoding;
			const char*			fPrefix;
			BStringList			fFolders;
			BString				fSeparator;
			bool				fSubscribedOnly;
};
 
 
class SubscribeCommand : public Command {
public:
								SubscribeCommand(const char* mailboxName);
 
			BString				CommandString();
 
private:
			BString				fMailboxName;
};
 
 
class UnsubscribeCommand : public Command {
public:
								UnsubscribeCommand(const char* mailboxName);
 
			BString				CommandString();
 
private:
			BString				fMailboxName;
};
 
 
class GetQuotaCommand : public Command, public Handler {
public:
								GetQuotaCommand(
									const char* mailboxName = "INBOX");
 
			BString				CommandString();
			bool				HandleUntagged(Response& response);
 
			uint64				UsedStorage();
			uint64				TotalStorage();
private:
			BString				fMailboxName;
 
			uint64				fUsedStorage;
			uint64				fTotalStorage;
};
 
 
}	// namespace IMAP
 
 
#endif // COMMANDS_H