/*
 * Copyright 2011, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Clemens Zeidler <haiku@clemens-zeidler.de>
 */
#ifndef FILE_MONITOR_H
#define FILE_MONITOR_H


#include <map>
#include <vector>

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

#include "NodeMonitorHandler.h"


struct WatchedFile {
        entry_ref               entry;
        node_ref                node;
        /*! Don't use it as the primary cookie storage. To be set in EntryCreated
        in EntryViewInterface. */
        void*                   cookie;
};


class NodeRefComp {
public:
        bool
        operator()(const node_ref& a, const node_ref& b) const
        {
                return a.node < b.node;
        }
};


typedef std::map<node_ref, WatchedFile, NodeRefComp> WatchedFileList;


class EntryViewInterface {
public:
        virtual                                         ~EntryViewInterface() {};

        virtual void                            EntryCreated(WatchedFile* file) {};
        virtual void                            EntryRemoved(WatchedFile* file) {};
        virtual void                            EntryMoved(WatchedFile* file) {};
        virtual void                            StatChanged(WatchedFile* file) {};
        virtual void                            AttrChanged(WatchedFile* file) {};

        virtual void                            EntriesCleared() {};
};


const uint32 kMsgAddRefs = '&adr';
const uint32 kMsgCleared = '&clr';


typedef std::vector<entry_ref> RefList;


class ReadThread;


class FileMonitor : public NodeMonitorHandler {
public:
                                                                FileMonitor(EntryViewInterface* listener);
                                                                ~FileMonitor();

                        void                            SetReadThread(ReadThread* readThread);

                        void                            Reset();

        virtual void                            MessageReceived(BMessage* message);

        virtual void                            EntryCreated(const char *name, ino_t directory,
                                                                        dev_t device, ino_t node);
        virtual void                            EntryRemoved(const char *name, ino_t directory,
                                                                        dev_t device, ino_t node);
        virtual void                            EntryMoved(const char *name,
                                                                        const char *fromName, ino_t fromDirectory,
                                                                        ino_t toDirectory, dev_t device,
                                                                        ino_t node, dev_t nodeDevice);
        virtual void                            StatChanged(ino_t node, dev_t device,
                                                                        int32 statFields);
        virtual void                            AttrChanged(ino_t node, dev_t device);

private:
                        WatchedFile*            _FindFile(dev_t device, ino_t node);

                        EntryViewInterface*     fListener;
                        WatchedFileList         fWatchedFileList;

                        ReadThread*                     fReadThread;
                        RefList*                        fCurrentReadList;
                        uint32                          fCurrentReadIndex;
};


class ReadThread {
public:
                                                                ReadThread(FileMonitor* target);
        virtual                                         ~ReadThread() {}

                        status_t                        Run();
                        bool                            Running();
                        status_t                        Wait();

                        void                            Stop();
                        bool                            Stopped();

                        RefList*                        ReadRefList();
                        void                            ReadDone();

protected:
        virtual bool                            ReadNextEntry(entry_ref& entry) = 0;

                        int32                           Process();

        friend  int32 ReadThreadFunction(void *data);

                        BHandler*                       fTarget;

                        RefList                         fRefList1;
                        RefList                         fRefList2;
                        RefList*                        fWriteRefList;
                        RefList*                        fReadRefList;
                        bool                            fReading;

private:
                        void                            _SwapLists();
        inline  void                            _PublishEntrys(BMessenger& messenger);

                        bool                            fStopped;
                        thread_id                       fThreadId;

                        int16                           fNReaded;
                        bool                            fRunning;
};


#endif // FILE_MONITOR_H