/*
 * Copyright 2004-2013, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 *		Jérôme Duval
 *		Marcus Overhagen
 *		John Scipione, jscipione@gmail.com
 */
#ifndef ADD_ON_MANAGER_H
#define ADD_ON_MANAGER_H


#include <InputServerDevice.h>
#include <InputServerFilter.h>
#include <InputServerMethod.h>
#include <Locker.h>
#include <Looper.h>

#include <AddOnMonitor.h>
#include <AddOnMonitorHandler.h>

#include <set>

#include "PathList.h"


using namespace BPrivate;

class AddOnManager : public AddOnMonitor {
public:
								AddOnManager();
								~AddOnManager();

	virtual	void 				MessageReceived(BMessage* message);

			void				LoadState();
			void				SaveState();

			status_t			StartMonitoringDevice(DeviceAddOn* addOn,
									const char* device);
			status_t			StopMonitoringDevice(DeviceAddOn* addOn,
									const char* device);

private:
			void				_RegisterAddOns();
			void				_UnregisterAddOns();

			status_t			_RegisterAddOn(BEntry& entry);
			status_t			_UnregisterAddOn(BEntry& entry);

			bool				_IsDevice(const char* path) const;
			bool				_IsFilter(const char* path) const;
			bool				_IsMethod(const char* path) const;

			status_t			_RegisterDevice(BInputServerDevice* device,
									const entry_ref& ref, image_id image);
			status_t			_RegisterFilter(BInputServerFilter* filter,
									const entry_ref& ref, image_id image);
			status_t			_RegisterMethod(BInputServerMethod* method,
									const entry_ref& ref, image_id image);

			status_t			_HandleFindDevices(BMessage* message,
									BMessage* reply);
			status_t			_HandleWatchDevices(BMessage* message,
									BMessage* reply);
			status_t			_HandleNotifyDevice(BMessage* message,
									BMessage* reply);
			status_t			_HandleIsDeviceRunning(BMessage* message,
									BMessage* reply);
			status_t			_HandleStartStopDevices(BMessage* message,
									BMessage* reply);
			status_t			_HandleControlDevices(BMessage* message,
									BMessage* reply);
			status_t			_HandleSystemShuttingDown(BMessage* message,
									BMessage* reply);
			status_t			_HandleMethodReplicant(BMessage* message,
									BMessage* reply);
			void				_HandleDeviceMonitor(BMessage* message);

			void				_LoadReplicant();
			void				_UnloadReplicant();
			int32				_GetReplicantAt(BMessenger target,
									int32 index) const;
			status_t			_GetReplicantName(BMessenger target,
									int32 uid, BMessage* reply) const;
			status_t			_GetReplicantView(BMessenger target, int32 uid,
									BMessage* reply) const;

			status_t			_AddDevicePath(DeviceAddOn* addOn,
									const char* path, bool& newPath);
			status_t			_RemoveDevicePath(DeviceAddOn* addOn,
									const char* path, bool& lastPath);

private:
	class MonitorHandler;
	friend class MonitorHandler;

	template<typename T> struct add_on_info {
		add_on_info()
			:
			image(-1), add_on(NULL)
		{
		}

		~add_on_info()
		{
			delete add_on;
			if (image >= 0)
				unload_add_on(image);
		}

		entry_ref				ref;
		image_id				image;
		T*						add_on;
	};
	typedef struct add_on_info<BInputServerDevice> device_info;
	typedef struct add_on_info<BInputServerFilter> filter_info;
	typedef struct add_on_info<BInputServerMethod> method_info;

			BObjectList<device_info> fDeviceList;
			BObjectList<filter_info> fFilterList;
			BObjectList<method_info> fMethodList;

			BObjectList<DeviceAddOn> fDeviceAddOns;
			PathList			fDevicePaths;

			MonitorHandler*		fHandler;
			std::set<BMessenger> fWatcherMessengerList;

			bool				fSafeMode;
};

#endif	// ADD_ON_MANAGER_H