/*
 * Copyright 2012-2016, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef IMAP_FOLDER_H
#define IMAP_FOLDER_H


#include <hash_map>
#include <hash_set>

#include <sys/stat.h>

#include <Entry.h>
#include <Node.h>
#include <Handler.h>
#include <String.h>

#include <locks.h>

#include "Commands.h"


class BFile;
class IMAPProtocol;


struct MessageToken {
        BString mailboxName;
        uint32  uidValidity;
        uint32  uid;
};

// Additional local only message flags
enum FolderMessageFlags {
        kPartialMessage = 0x00010000,
};


class FolderListener {
public:
        virtual uint32                          MessageAdded(const MessageToken& fromToken,
                                                                        const entry_ref& ref) = 0;
        virtual void                            MessageDeleted(const MessageToken& token) = 0;

        virtual void                            MessageFlagsChanged(const MessageToken& token,
                                                                        const entry_ref& ref, uint32 oldFlags,
                                                                        uint32 newFlags) = 0;
};


class IMAPFolder : public BHandler {
public:
                                                                IMAPFolder(IMAPProtocol& protocol,
                                                                        const BString& mailboxName,
                                                                        const entry_ref& ref);
        virtual                                         ~IMAPFolder();

                        status_t                        Init();

                        const BString&          MailboxName() const { return fMailboxName; }
                        ino_t                           NodeID() const { return fNodeID; }

                        void                            SetListener(FolderListener* listener);
                        void                            SetUIDValidity(uint32 uidValidity);

                        uint32                          LastUID() const { return fLastUID; }

                        status_t                        GetMessageEntryRef(uint32 uid, entry_ref& ref);
                        status_t                        GetMessageUID(const entry_ref& ref,
                                                                        uint32& uid) const;
                        uint32                          MessageFlags(uint32 uid);

                        void                            SyncMessageFlags(uint32 uid,
                                                                        uint32 mailboxFlags);
                        void                            MessageEntriesFetched();

                        status_t                        StoreMessage(uint32 fetchFlags, BDataIO& stream,
                                                                        size_t& length, entry_ref& ref,
                                                                        BFile& file);
                        void                            MessageStored(entry_ref& ref, BFile& file,
                                                                        uint32 fetchFlags, uint32 uid,
                                                                        uint32 flags);

                        void                            RegisterPendingBodies(
                                                                        IMAP::MessageUIDList& uids,
                                                                        const BMessenger* replyTo);
                        status_t                        StoreBody(uint32 uid, BDataIO& stream,
                                                                        size_t& length, entry_ref& ref,
                                                                        BFile& file);
                        void                            BodyStored(entry_ref& ref, BFile& file,
                                                                        uint32 uid);
                        void                            StoringBodyFailed(const entry_ref& ref,
                                                                        uint32 uid, status_t error);

                        void                            DeleteMessage(uint32 uid);

        virtual void                            MessageReceived(BMessage* message);

private:
                        void                            _WaitForFolderState();
                        void                            _InitializeFolderState();
                        void                            _ReadFolderState();
        static  status_t                        _ReadFolderState(void* self);

                        const MessageToken      _Token(uint32 uid) const;
                        void                            _NotifyStoredBody(const entry_ref& ref,
                                                                        uint32 uid, status_t status);
                        status_t                        _GetMessageEntryRef(uint32 uid,
                                                                        entry_ref& ref) const;
                        status_t                        _DeleteLocalMessage(uint32 uid);

                        void                            _IMAPToMailFlags(uint32 flags,
                                                                        BMessage& attributes);
                        status_t                        _MailToIMAPFlags(BNode& node, uint32& flags);
                        void                            _TestMessageFlags(uint32 previousFlags,
                                                                        uint32 mailboxFlags, uint32 currentFlags,
                                                                        uint32 testFlag, uint32& nextFlags);

                        uint32                          _ReadUniqueID(BNode& node) const;
                        status_t                        _WriteUniqueID(BNode& node, uint32 uid) const;
                        uint32                          _ReadUniqueIDValidity(BNode& node) const;
                        status_t                        _WriteUniqueIDValidity(BNode& node) const;
                        uint32                          _ReadFlags(BNode& node) const;
                        status_t                        _WriteFlags(BNode& node, uint32 flags) const;

                        uint32                          _ReadUInt32(BNode& node,
                                                                        const char* attribute) const;
                        status_t                        _WriteUInt32(BNode& node,
                                                                        const char* attribute, uint32 value) const;

                        status_t                        _WriteStream(BFile& file, BDataIO& stream,
                                                                        size_t& length) const;

private:
        typedef std::vector<BMessenger> MessengerList;
#if __GNUC__ >= 4
        typedef __gnu_cxx::hash_map<uint32, uint32> UIDToFlagsMap;
        typedef __gnu_cxx::hash_map<uint32, entry_ref> UIDToRefMap;
        typedef __gnu_cxx::hash_map<uint32, MessengerList> MessengerMap;
        typedef __gnu_cxx::hash_set<uint32> UIDSet;
#else
        typedef std::hash_map<uint32, uint32> UIDToFlagsMap;
        typedef std::hash_map<uint32, entry_ref> UIDToRefMap;
        typedef std::hash_map<uint32, MessengerList> MessengerMap;
        typedef std::hash_set<uint32> UIDSet;
#endif

                        IMAPProtocol&           fProtocol;
                        const entry_ref         fRef;
                        BString                         fMailboxName;
                        ino_t                           fNodeID;
                        uint32                          fUIDValidity;
                        uint32                          fLastUID;
                        FolderListener*         fListener;
                        mutex                           fLock;
                        mutex                           fFolderStateLock;
                        thread_id                       fReadFolderStateThread;
                        bool                            fFolderStateInitialized;
                        bool                            fQuitFolderState;
                        UIDToRefMap                     fRefMap;
                        UIDToFlagsMap           fFlagsMap;
                        UIDSet                          fSynchronizedUIDsSet;
                        UIDToFlagsMap           fPendingFlagsMap;
                        MessengerMap            fPendingBodies;
};


#endif  // IMAP_FOLDER_H