/*
 * This file is a part of Winix
 * and is not publicly distributed
 * 
 * Copyright (c) 2008-2010, Tomasz Sowa
 * All rights reserved.
 * 
 */
 

#ifndef headerfilecmsluplugin
#define headerfilecmsluplugin

#include <vector>
#include <string>
#include <map>
#include "request.h"
#include "data.h"
#include "pluginmsg.h"
#include "log.h"
#include "plugindata.h"


/*
	all your plugin functions can have signature either:
	void my_function(PluginInfo & info); or
	void my_function();

	only the main Init should have:
	extern "C" void Init(PluginFunction & info);

	in the Init you can add your own functions by using plugin.Assign() method
	and you can set the name of the plugin by setting info.p1 pointer 
	to a string buffer (const char *)
	(this buffer will not be copied so it should not be destroyed after Init finishes)
*/




struct PluginInfo
{
	// these variables are used for some purposes
	// depending on a hook in which they are used
	void * p1;
	void * p2;
	long l1;
	long l2;

	// unique plugin identifier
	int plugin_id;
	
	// pointer to the plugin session (can be null if not set by the plugin)
	// you should use WINIX_SESSION_CREATED and WINIX_SESSION_REMOVE
	// to create your plugin's session data
	PluginDataBase * plugin_data_base; 

	// function return status
	// default: false (if not set by the plugin)
	bool ret;
	
	
	void Clear()
	{
		p1 = 0;
		p2 = 0;
		l1 = 0;
		l2 = 0;

		plugin_id = -1;
		plugin_data_base = 0;

		ret = false;
	}
};



class Plugin
{
public:	

	// index of a plugin which is called by Call() method
	// normally: -1
	int current_plugin;

	// Fun is a type of a function you should provide in your plugin
	typedef void (*Fun1)(PluginInfo &);
	typedef void (*Fun2)(void);


	struct Slot
	{
		Fun1 fun1;
		Fun2 fun2;
		int index; // plugin index (which plugin has inserted the slot)
		bool is_running;

		Slot()
		{
			fun1  = 0;
			fun2  = 0;
			index = -1;
			is_running = false;
		}
	};


	Plugin();
	~Plugin();

	void LoadPlugin(const char * filename);
	void LoadPlugin(const std::string & filename);
	void LoadPlugins(const std::vector<std::string> & plugins);
	void UnloadPlugins();
	
	void Call(int message);
	void Call(int message, void * p1_);
	void Call(int message, void * p1_, void * p2_);
	void Call(int message, long l1_);
	void Call(int message, long l1_, long l2_);
	void Call(int message, void * p1_, long l1_);
	void Call(int message, void * p1_, long l1_, long l2_);
	void Call(int message, void * p1_, void * p2_, long l1_);
	void Call(int message, void * p1_, void * p2_, long l1_, long l2_);
	
	// how many plugins there are
	size_t Size();

	// assign a function to a message
	// you can assign more than one function to a specific message
	void Assign(int message, Fun1);
	void Assign(int message, Fun2);

private:	


	struct PluginsItem
	{
		void * handle;
		const char * plugin_name; // plugin name (can be null if was not set by the plugin)
	};

	typedef std::vector<PluginsItem> Plugins;
	Plugins plugins;
	
	typedef std::multimap<int, Slot> Slots;
	Slots slots;
	
	PluginInfo info;

	void * LoadInitFun(const char * filename, Fun1 & fun_init);
	void Call(int message, Slots::iterator & slot);
};




extern Plugin plugin;

#endif