/*
 * 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