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

#include "FileMonitor.h"

#include <Looper.h>

#include <Messenger.h>
#include <NodeMonitor.h>


FileMonitor::FileMonitor(EntryViewInterface* listener)
        :
        fListener(listener),
        fCurrentReadList(NULL),
        fCurrentReadIndex(0)
{

}


FileMonitor::~FileMonitor()
{
        Reset();
}


void
FileMonitor::SetReadThread(ReadThread* readThread)
{
        fReadThread = readThread;
}


void
FileMonitor::Reset()
{
        fWatchedFileList.clear();
        stop_watching(this);

        BMessenger messenger(this);
        messenger.SendMessage(kMsgCleared);

        if (fCurrentReadList != NULL)
                fCurrentReadIndex = fCurrentReadList->size();
}


void
FileMonitor::MessageReceived(BMessage* msg)
{
        switch (msg->what) {
                case kMsgAddRefs:
                {
                        if (fCurrentReadList == NULL)
                                fCurrentReadList = fReadThread->ReadRefList();
                        uint32 terminate =  fCurrentReadIndex + 50;
                        for (; fCurrentReadIndex < terminate; fCurrentReadIndex++) {
                                if (fCurrentReadIndex >= fCurrentReadList->size()) {
                                        fCurrentReadList = NULL;
                                        fCurrentReadIndex = 0;
                                        fReadThread->ReadDone();
                                        break;
                                }

                                entry_ref& entry = (*fCurrentReadList)[fCurrentReadIndex];
                                node_ref nodeRef;
                                BNode node(&entry);
                                if (node.GetNodeRef(&nodeRef) != B_OK)
                                        continue;

                                EntryCreated(entry.name, entry.directory, entry.device,
                                        nodeRef.node);
                        }
                        if (fCurrentReadList)
                                Looper()->PostMessage(kMsgAddRefs, this);

                        break;
                }

                case kMsgCleared:
                        fListener->EntriesCleared();
                        break;

                default:
                        NodeMonitorHandler::MessageReceived(msg);
                        break;
        }
}


void
FileMonitor::EntryCreated(const char *name, ino_t directory, dev_t device,
        ino_t node)
{
        WatchedFile file;
        NodeMonitorHandler::make_node_ref(device, node, &file.node);
        if (fWatchedFileList.find(file.node) != fWatchedFileList.end())
                return;

        NodeMonitorHandler::make_entry_ref(device, directory, name, &file.entry);
        fWatchedFileList[file.node] = file;

        watch_node(&file.node, B_WATCH_NAME | B_WATCH_STAT | B_WATCH_ATTR, this);
        fListener->EntryCreated(&fWatchedFileList[file.node]);
}


void
FileMonitor::EntryRemoved(const char *name, ino_t directory, dev_t device,
        ino_t node)
{
        WatchedFile* file = _FindFile(device, node);
        if (file == NULL)
                return;

        fListener->EntryRemoved(file);
        fWatchedFileList.erase(file->node);
}


void
FileMonitor::EntryMoved(const char *name, const char *fromName,
        ino_t fromDirectory, ino_t toDirectory, dev_t device, ino_t node,
        dev_t nodeDevice)
{
        WatchedFile* file = _FindFile(device, node);
        if (file == NULL)
                return;
        NodeMonitorHandler::make_entry_ref(device, toDirectory, name, &file->entry);
        NodeMonitorHandler::make_node_ref(device, node, &file->node);
        fListener->EntryMoved(file);
}


void
FileMonitor::StatChanged(ino_t node, dev_t device, int32 statFields)
{
        WatchedFile* file = _FindFile(device, node);
        if (file == NULL)
                return;
        fListener->StatChanged(file);
}


void
FileMonitor::AttrChanged(ino_t node, dev_t device)
{
        WatchedFile* file = _FindFile(device, node);
        if (file == NULL)
                return;
        fListener->AttrChanged(file);
}


WatchedFile*
FileMonitor::_FindFile(dev_t device, ino_t node)
{
        node_ref nodeRef;
        NodeMonitorHandler::make_node_ref(device, node, &nodeRef);

        WatchedFileList::iterator it = fWatchedFileList.find(nodeRef);
        if (it == fWatchedFileList.end())
                return NULL;

        return &it->second;
}


int32
ReadThreadFunction(void *data)
{
        ReadThread* that = (ReadThread*)data;
        return that->Process();
}


ReadThread::ReadThread(FileMonitor* target)
        :
        fTarget(target),
        fReading(false),
        fStopped(false),
        fThreadId(-1),
        fNReaded(0),
        fRunning(false)
{
        fWriteRefList = &fRefList1;
        fReadRefList = &fRefList2;
}


status_t
ReadThread::Run()
{
        if (fThreadId >= 0)
                return B_ERROR;

        fStopped = false;
        fThreadId = spawn_thread(ReadThreadFunction, "file reader", B_LOW_PRIORITY,
                this);
        fRunning = true;
        status_t status = resume_thread(fThreadId);
        if (status != B_OK)
                fRunning = false;
        return status;
}


bool
ReadThread::Running()
{
        return fRunning;
}


status_t
ReadThread::Wait()
{
        status_t exitValue;
        return wait_for_thread(fThreadId, &exitValue);
}


void
ReadThread::Stop()
{
        fStopped = true;
}


bool
ReadThread::Stopped()
{
        return fStopped;
}


RefList*
ReadThread::ReadRefList()
{
        return fReadRefList;
}


void
ReadThread::ReadDone()
{
        fReadRefList->clear();
        // and release the list
        fReading = false;

        if (!fRunning && fWriteRefList->size() != 0) {
                BMessenger messenger(fTarget);
                _PublishEntrys(messenger);
        }
}


int32
ReadThread::Process()
{
        BMessenger messenger(fTarget);

        entry_ref entry;
        while (ReadNextEntry(entry)) {
                if (Stopped()) {
                        fWriteRefList->clear();
                        break;
                }

                fWriteRefList->push_back(entry);

                fNReaded++;
                if (fNReaded >= 50)
                        _PublishEntrys(messenger);
        }

        fRunning = false;

        _PublishEntrys(messenger);

        fThreadId = -1;
        return B_OK;
}


void
ReadThread::_SwapLists()
{
        RefList* lastReadList = fReadRefList;
        fReadRefList = fWriteRefList;
        fWriteRefList = lastReadList;
}


void
ReadThread::_PublishEntrys(BMessenger& messenger)
{
        if (fReading || Stopped())
                return;
        _SwapLists();
        fReading = true;
        fNReaded = 0;
        messenger.SendMessage(kMsgAddRefs);
}