/*
 * Copyright 2004-2016, Haiku, Inc. All Rights Reserved.
 * Copyright 2001 Dr. Zoidberg Enterprises. All rights reserved.
 * Copyright 2011 Clemens Zeidler. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 */
#ifndef _MAIL_PROTOCOL_H
#define _MAIL_PROTOCOL_H


#include <map>

#include <Looper.h>
#include <OS.h>
#include <ObjectList.h>
#include <Entry.h>
#include <File.h>

#include <E-mail.h>
#include <MailSettings.h>


class BMailFilter;
class BMailSettingsView;
class BView;


class BMailNotifier {
public:
	virtual						~BMailNotifier() {}

	virtual BMailNotifier*		Clone() = 0;

	virtual	void				ShowError(const char* error) = 0;
	virtual	void				ShowMessage(const char* message) = 0;

	virtual void				SetTotalItems(uint32 items) = 0;
	virtual void				SetTotalItemsSize(uint64 size) = 0;
	virtual	void				ReportProgress(uint32 items, uint64 bytes,
									const char* message = NULL) = 0;
	virtual void				ResetProgress(const char* message = NULL) = 0;
};


typedef status_t BMailFilterAction;

#define B_NO_MAIL_ACTION		0
#define B_MOVE_MAIL_ACTION		1
#define B_DELETE_MAIL_ACTION	2


class BMailProtocol : public BLooper {
public:
								BMailProtocol(const char* name,
									const BMailAccountSettings& settings);
	virtual						~BMailProtocol();

			const BMailAccountSettings& AccountSettings() const;

			void				SetMailNotifier(BMailNotifier* mailNotifier);
			BMailNotifier*		MailNotifier() const;

			//! We take ownership of the filters
			bool				AddFilter(BMailFilter* filter);
			int32				CountFilter() const;
			BMailFilter*		FilterAt(int32 index) const;
			BMailFilter*		RemoveFilter(int32 index);
			bool				RemoveFilter(BMailFilter* filter);

	virtual void				MessageReceived(BMessage* message);

			// Convenience methods that call the BMailNotifier
			void				ShowError(const char* error);
			void				ShowMessage(const char* message);

#if __GNUC__ > 2
			// Unhide virtual base methods
			using BHandler::AddFilter;
			using BHandler::RemoveFilter;
#endif

protected:
		 	void				SetTotalItems(uint32 items);
			void				SetTotalItemsSize(uint64 size);
			void				ReportProgress(uint32 items, uint64 bytes,
									const char* message = NULL);
			void				ResetProgress(const char* message = NULL);
			void				NotifyNewMessagesToFetch(int32 nMessages);

			// Filter notifications
			BMailFilterAction	ProcessHeaderFetched(entry_ref& ref,
									BFile& mail, BMessage& attributes);
			void				NotifyBodyFetched(const entry_ref& ref,
									BFile& mail, BMessage& attributes);
			BMailFilterAction	ProcessMessageFetched(entry_ref& ref,
									BFile& mail, BMessage& attributes);
			void				NotifyMessageReadyToSend(const entry_ref& ref,
									BFile& mail);
			void				NotifyMessageSent(const entry_ref& ref,
									BFile& mail);

			void				LoadFilters(
									const BMailProtocolSettings& settings);

private:
	static	BString				_LooperName(const char* name,
									const BMailAccountSettings& settings);
			BMailFilter*		_LoadFilter(const BMailAddOnSettings& settings);
			BMailFilterAction	_ProcessHeaderFetched(entry_ref& ref,
									BFile& mail, BMessage& attributes);
			void				_NotifyBodyFetched(const entry_ref& ref,
									BFile& mail, BMessage& attributes);

protected:
			const BMailAccountSettings fAccountSettings;
			BMailNotifier*		fMailNotifier;

private:
			BObjectList<BMailFilter> fFilterList;
			std::map<entry_ref, image_id> fFilterImages;
};


class BInboundMailProtocol : public BMailProtocol {
public:
								BInboundMailProtocol(const char* name,
									const BMailAccountSettings& settings);
	virtual						~BInboundMailProtocol();

	virtual void				MessageReceived(BMessage* message);

	virtual	status_t			SyncMessages() = 0;
	virtual status_t			FetchBody(const entry_ref& ref,
									BMessenger* replyTo);
	virtual	status_t			MarkMessageAsRead(const entry_ref& ref,
									read_flags flags = B_READ);

	static	void				ReplyBodyFetched(const BMessenger& replyTo,
									const entry_ref& ref, status_t status);

protected:
	virtual status_t			HandleFetchBody(const entry_ref& ref,
									const BMessenger& replyTo) = 0;

			void				NotiyMailboxSynchronized(status_t status);
};


class BOutboundMailProtocol : public BMailProtocol {
public:
								BOutboundMailProtocol(const char* name,
									const BMailAccountSettings& settings);
	virtual						~BOutboundMailProtocol();

	virtual	status_t			SendMessages(const BMessage& message,
									off_t totalBytes);

	virtual void				MessageReceived(BMessage* message);

protected:
	virtual	status_t			HandleSendMessages(const BMessage& message,
									off_t totalBytes) = 0;
};


// Your protocol needs to export these hooks in order to be picked up
extern "C" BInboundMailProtocol* instantiate_inbound_protocol(
	const BMailAccountSettings& settings);
extern "C" BOutboundMailProtocol* instantiate_outbound_protocol(
	const BMailAccountSettings& settings);

extern "C" BMailSettingsView* instantiate_protocol_settings_view(
	const BMailAccountSettings& accountSettings,
	const BMailProtocolSettings& settings);


#endif	// _MAIL_PROTOCOL_H