/*
 * Copyright 2010, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Clemens Zeidler <haiku@clemens-zeidler.de>
 */
#ifndef VOLUME_WATCHER_H
#define VOLUME_WATCHER_H


#include <vector>

#include <Debug.h>
#include <Handler.h>
#include <NodeMonitorHandler.h>
#include <Volume.h>

#include <ObjectList.h>

#include "AnalyserDispatcher.h"
#include "CatchUpManager.h"
#include "IndexServerAddOn.h"


class VolumeWatcher;


class WatchNameHandler : public NodeMonitorHandler {
public:
								WatchNameHandler(VolumeWatcher* volumeWatcher);

			void				EntryCreated(const char *name, ino_t directory,
									dev_t device, ino_t node);
			void				EntryRemoved(const char *name, ino_t directory,
									dev_t device, ino_t node);
			void				EntryMoved(const char *name,
									const char *fromName, ino_t from_directory,
									ino_t to_directory, dev_t device,
									ino_t node, dev_t nodeDevice);
			void				StatChanged(ino_t node, dev_t device,
									int32 statFields);

			void				MessageReceived(BMessage* msg);
private:
			VolumeWatcher*		fVolumeWatcher;
};


typedef std::vector<entry_ref> EntryRefVector;


class VolumeWatcher;


const uint32 kTriggerWork = '&twk';	// what a bad message


class VolumeWorker : public AnalyserDispatcher
{
public:
								VolumeWorker(VolumeWatcher* watcher);

			void				MessageReceived(BMessage *message);

			bool				IsBusy();

private:
			void				_Work();

			void				_SetBusy(bool busy = true);

			VolumeWatcher*		fVolumeWatcher;
			int32				fBusy;
};


class VolumeWatcherBase {
public:
								VolumeWatcherBase(const BVolume& volume);

			const BVolume&		Volume() { return fVolume; }

			bool				Enabled() { return fEnabled; }
			bigtime_t			GetLastUpdated() { return fLastUpdated; }

protected:
			bool				ReadSettings();
			bool				WriteSettings();

			BVolume				fVolume;

			bool				fEnabled;

			bigtime_t			fLastUpdated;
};


/*! Used to thread safe exchange refs. While the watcher thread file the current
list the worker thread can handle the second list. The worker thread gets his entries by calling SwapList while holding the watcher thread lock. */
class SwapEntryRefVector {
public:
								SwapEntryRefVector();

			EntryRefVector*		SwapList();
			EntryRefVector*		CurrentList();
private:
			EntryRefVector		fFirstList;
			EntryRefVector		fSecondList;
			EntryRefVector*		fCurrentList;
			EntryRefVector*		fNextList;
};


struct list_collection
{
			EntryRefVector*		createdList;
			EntryRefVector*		deletedList;
			EntryRefVector*		modifiedList;
			EntryRefVector*		movedList;
			EntryRefVector*		movedFromList;
};


/*! Watch a volume and delegate changed entries to a VolumeWorker. */
class VolumeWatcher : public VolumeWatcherBase, public BLooper {
public:
								VolumeWatcher(const BVolume& volume);
								~VolumeWatcher();

			bool				StartWatching();
			void				Stop();

			//! thread safe
			bool				AddAnalyser(FileAnalyser* analyser);
			bool				RemoveAnalyser(const BString& name);

			void				GetSecureEntries(list_collection& collection);

			bool				FindEntryRef(ino_t node, dev_t device,
									entry_ref& entry);

private:
	friend class WatchNameHandler;

			void				_NewEntriesArrived();

			bool				fWatching;

			WatchNameHandler	fWatchNameHandler;

			SwapEntryRefVector	fCreatedList;
			SwapEntryRefVector	fDeleteList;
			SwapEntryRefVector	fModifiedList;
			SwapEntryRefVector	fMovedList;
			SwapEntryRefVector	fMovedFromList;

			VolumeWorker*		fVolumeWorker;
			CatchUpManager		fCatchUpManager;
};


#endif