/*********************************************************************/
/*                                                                   */
/*                     AgentService Framework                        */
/*                       www.agentservice.it                         */
/*                                                                   */
/* Copyright (C) 2007 l.i.d.o. - DIST, University of Genoa, Italy    */
/* GNU Lesser General Public License                                 */
/*                                                                   */
/* This library is free software; you can redistribute it and/or     */
/* modify it under the terms of the GNU Lesser General Public        */
/* License as published by the Free Software Foundation,             */
/* version 2.1 of the License.                                       */
/*                                                                   */
/* This library is distributed in the hope that it will be useful,   */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of    */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
/* Lesser General Public License for more details.                   */
/*                                                                   */
/* You should have received a copy of the GNU Lesser General Public  */
/* License along with this library; if not, write to the             */
/* Free Software Foundation, Inc., 59 Temple Place - Suite 330,      */
/* Boston, MA  02111-1307, USA.                                      */
/*                                                                   */
/*********************************************************************/
using System;
using System.Reflection;
using System.Collections;
using AgentService.Platform;
using AgentService.Platform.Modules;
using AgentService.Platform.Commands;
using AgentService.Interop;


namespace AgentService.Platform
{
	/// <summary>
	/// Interface IPlatformContext. Defines the basic functionalities accessible
	/// to each module.
	/// </summary>
	public interface IPlatformContext : IEventSinkManager, IEventManager	
	{
		#region Platform Information
		/// <summary>
		/// Gets the platform base directory.
		/// </summary>
		string PlatformBaseDir 
		{
			get;
		}

		/// <summary>
		/// Gets the platform core modules configuration path.
		/// </summary>
		string PlatformCoreConfPath 
		{
			get;
		}

		/// <summary>
		/// Gets the platform core modules bin path.
		/// </summary>
		string PlatformCoreBinPath 
		{
			get; 
		}

		/// <summary>
		/// Gets the platform additional modules configuration path.
		/// </summary>
		string PlatformAddConfPath 
		{
			get;
		}

		/// <summary>
		/// Gets the platform additional modules bin path.
		/// </summary>
		string PlatformAddBinPath 
		{
			get;
		}

		/// <summary>
		/// Gets the platform description.
		/// </summary>
		IPlatformDescription Description 
		{
			get;
		}
		/// <summary>
		/// Gets true if the platform started
		/// for the first time (after install).
		/// </summary>
		bool IsFirstStart 
		{
			get;
		}
		#endregion

		#region PlatformCommands

		
		/// <summary>
		/// Posts a command to the platform command queue.
		/// </summary>
		/// <param name="cmd">command object</param>
		void PostCommand(PlatformCommand cmd);

		#endregion

	}

	/// <summary>
	/// Class CustomEventInfo. Defines the information
	/// about a custom event.
	/// </summary>
	public class CustomEventInfo 
	{
		/// <summary>
		/// Gets the custom event token
		/// </summary>
		public int Token 
		{
			get 
			{
				return this.GetHashCode();
			}
		}
		/// <summary>
		/// custom event name
		/// </summary>
		private string name;
		/// <summary>
		/// Gets, sets the custom event name.
		/// </summary>
		public string Name
		{
			get 
			{
				return this.name;
			}
			set
			{
				this.name = value;
			}
		}

		/// <summary>
		/// List of handlers attached to this
		/// event.
		/// </summary>
		public event PlatformEventHandler Handlers;

		/// <summary>
		/// Constructs a CustomEventInfo instance.
		/// </summary>
		/// <param name="name">name of the event</param>
		public CustomEventInfo(string name) 
		{
			this.name = name;
		}
		/// <summary>
		/// Raises the custom event.
		/// </summary>
		/// <param name="sender">sender of the event</param>
		/// <param name="args">event arguments</param>
		public void Raise(object sender, PlatformEventArgs args)
		{
			if (this.Handlers != null)
			{
				this.Handlers(sender, args);
			}
		}
	}


	/// <summary>
	/// Class EventSinkInfo. Mantains the information
	/// about the sink of a given event.
	/// </summary>
	public class EventSinkInfo 
	{

		/// <summary>
		/// event sink descriptor.
		/// </summary>
		private EventSinkDescriptor descriptor;
		/// <summary>
		/// Gets, sets the descriptor of the sink
		/// </summary>
		public EventSinkDescriptor Descriptor 
		{
			get 
			{
				return this.descriptor;
			}
			set
			{
				this.descriptor = value;
			}
		}
		/// <summary>
		/// Sink of the event.
		/// </summary>
		private event PlatformEventSinkHandler sink;

		/// <summary>
		/// Constructs an EventSinkInfo instance.
		/// </summary>
		/// <param name="descriptor">descriptor of th sink</param>
		/// <param name="sink">sink of the event</param>
		public EventSinkInfo(EventSinkDescriptor descriptor, PlatformEventSinkHandler sink)
		{
			this.descriptor = descriptor;
			this.sink += sink;
		}

		/// <summary>
		/// Raises the event and forwards it to the connected sink.
		/// </summary>
		/// <param name="args">event sink arguments</param>
		public void Absorbe(PlatformSinkEventArgs args) 
		{
			this.sink(this, args);
		}
	}
	/// <summary>
	/// Class PlatformContext. Defines the context that is accessible to each module.
	/// </summary>
	public class PlatformContext  : IPlatformContext
	{
		/// <summary>
		/// reference to the platform.
		/// </summary>
		private IPlatform platform;

		/// <summary>
		/// Maps the custom name of the custom events
		/// to the real custom event objects.
		/// </summary>
		private Hashtable customEventMap;

		/// <summary>
		/// Maps the event sink object to real
		/// event sink.
		/// </summary>
		private Hashtable eventSinkMap;


		#region Standard Platform Events

		/// <summary>
		/// Fires every time an agent is created.
		/// </summary>
		public event PlatformEventHandler OnAgentCreated;
		/// <summary>
		/// Fires every time an agent is resumed.
		/// </summary>
		public event PlatformEventHandler OnAgentResumed;
		/// <summary>
		/// Fires every time an agent is stopped.
		/// </summary>
		public event PlatformEventHandler OnAgentStopped;
		/// <summary>
		/// Fires every time an agent is woken up.
		/// </summary>
		public event PlatformEventHandler OnAgentWokenUp;
		/// <summary>
		/// Fires every time a message is sent.
		/// </summary>
		public event PlatformEventHandler OnMessageSent;
		/// <summary>
		/// Fires every time a message is sent.
		/// </summary>
		public event PlatformEventHandler OnMessageReceived;
		/// <summary>
		/// Fires every time a bulk of messages is received.
		/// </summary>
		public event PlatformEventHandler OnMessageBatch;
		/// <summary>
		/// Fires every time a conversation is requested.
		/// </summary>
		public event PlatformEventHandler OnConversationRequested;
		/// <summary>
		/// Fires every time a conversation is accepted and then opened.
		/// </summary>
		public event PlatformEventHandler OnConversationAccepted;
		/// <summary>
		/// Fires every time a comversation is refused.
		/// </summary>
		public event PlatformEventHandler OnConversationRefused;
		/// <summary>
		/// Fires every time a conversation is closed.
		/// </summary>
		public event PlatformEventHandler OnConversationClosed;
		/// <summary>
		/// Fires every time an agent is persisted.
		/// </summary>
		public event PlatformEventHandler OnAgentPersisted;
		/// <summary>
		/// Fires every time an assembly is uploaded into the platform storage.
		/// </summary>
		public event PlatformEventHandler OnAssemblyUploaded;
		/// <summary>
		/// Fires every time an assembly is removed from the platform storage.
		/// </summary>
		public event PlatformEventHandler OnAssemblyRemoved;

		#endregion

		/// <summary>
		/// Constructs a PlatformContext object with the given platform properties.
		/// </summary>
		/// <param name="baseDir">platform base directory</param>
		/// <param name="coreBinPath">core modules bin path</param>
		/// <param name="coreCofnPath">core modules conf path</param>
		/// <param name="addBinPath">additional modules bin path</param>
		/// <param name="addConfPath">additional modules conf path</param>
		public PlatformContext(IPlatform platform
			/* PlatformDescription description, string baseDir, 
								string coreBinPath, string coreConfPath, 
								string addBinPath, string addConfPath
			*/) 
		{

			this.platform = platform;
			this.description = platform.Description;
			this.platformBaseDir = platform.Configuration.BaseDirPath;
			this.platformCoreBinPath = platform.Configuration.CoreModulesBinPath;
			this.platformCoreConfPath = platform.Configuration.CoreModulesConfPath;
			this.platformAddConfPath = platform.Configuration.AdditionalModulesConfPath;
			this.platformAddBinPath = platform.Configuration.AdditionalModulesBinPath;

			this.customEventMap = new Hashtable();
			this.eventSinkMap = new Hashtable();

		}

		#region Platform Information
		/// <summary>
		/// platform base directory
		/// </summary>
		private string platformBaseDir;
		/// <summary>
		/// Gets the platform base directory
		/// </summary>
		public string PlatformBaseDir 
		{
			get 
			{
				return this.platformBaseDir;
			}
		}

		/// <summary>
		/// platform core modules configuration path
		/// </summary>
		private string platformCoreConfPath;
		/// <summary>
		/// Gets the platform core modules configuration path
		/// </summary>
		public string PlatformCoreConfPath 
		{
			get 
			{
				return this.platformCoreConfPath;
			}
		}

		/// <summary>
		/// platform core modules bin path
		/// </summary>
		private string platformCoreBinPath;
		/// <summary>
		/// Gets the platform core modules bin path
		/// </summary>
		public string PlatformCoreBinPath 
		{
			get 
			{
				return this.platformCoreBinPath;
			}
		}

		/// <summary>
		/// platform additional modules configuration path
		/// </summary>
		private string platformAddConfPath;
		/// <summary>
		/// Gets the platform additional modules configuration path
		/// </summary>
		public string PlatformAddConfPath 
		{
			get 
			{
				return this.platformAddConfPath;
			}
		}

		/// <summary>
		/// platform additional modules bin path
		/// </summary>
		private string platformAddBinPath;
		/// <summary>
		/// Gets the platform additional modules bin path
		/// </summary>
		public string PlatformAddBinPath 
		{
			get 
			{
				return this.platformAddBinPath;
			}
		}

		/// <summary>
		/// platform description
		/// </summary>
		private IPlatformDescription description;
		/// <summary>
		/// Gets the platform description
		/// </summary>
		public IPlatformDescription Description 
		{
			get 
			{
				return this.description;
			}
		}
		/// <summary>
		/// Gets true if the platform started 
		/// after an installation.
		/// </summary>
		public bool IsFirstStart 
		{
			get 
			{
				return this.platform.Configuration.IsFirstStart;
			}
		}
		
		#endregion

		#region Custom Events Management
		
		/// <summary>
		/// Adds an event to the custom event registry
		/// </summary>
		/// <param name="evtName">name of the event</param>
		/// <returns>a token that is used by the owner to track the event, 0 if the event is already present</returns>
		public int AddEvent(string evtName) 
		{
			lock(this.customEventMap.SyncRoot)
			{
				CustomEventInfo evtInfo = this.customEventMap[evtName] as CustomEventInfo;

				if ((evtInfo == null) && (evtName != null))
				{
					evtInfo = new CustomEventInfo(evtName);

					this.customEventMap.Add(evtName,evtInfo);

					return evtInfo.Token;
				
				}

				return 0;
			}
		}

		/// <summary>
		/// Removes the event associated to the given token
		/// </summary>
		/// <param name="token">token that identifies the event</param>
		public bool RemoveEvent(int token) 
		{
			lock(this.customEventMap.SyncRoot)
			{
				CustomEventInfo found = null;

				foreach(CustomEventInfo evtInfo in this.customEventMap.Values)
				{
					if (evtInfo.Token == token)
					{
						found = evtInfo;
						break;
					}
				}

				if (found != null) 
				{
					this.customEventMap.Remove(found.Name);
					return true;
				}

				return false;
			}
		}

		/// <summary>
		/// Raises the event associated to the given token
		/// </summary>
		/// <param name="token">token that identifies the event</param>
		/// <param name="args">event argument</param>
		/// <returns>true if the event is found</returns>
		public bool RaiseEvent(int token, PlatformEventArgs args) 
		{
			lock(this.customEventMap.SyncRoot)
			{
				CustomEventInfo found = null;

				foreach(CustomEventInfo evtInfo in this.customEventMap.Values)
				{
					if (evtInfo.Token == token)
					{
						found = evtInfo;
						found.Raise(this,args);
						return true;
					}
				}

				return false;
			}
		}

		/// <summary>
		/// Registers an handler to the given event
		/// </summary>
		/// <param name="evtName">name that identifies the event</param>
		/// <param name="handler">delegate the will be registered</param>
		/// <returns>true if the registration process is successful, false if the event is not present</returns>
		public bool Register(string evtName, PlatformEventHandler handler) 
		{
			lock(this.customEventMap.SyncRoot)
			{
				CustomEventInfo evtInfo = this.customEventMap[evtName] as CustomEventInfo;
				if (evtInfo != null) 
				{
					evtInfo.Handlers += handler;

					return true;
				}

				return false;
			}
		}

		/// <summary>
		/// Deregisters an handler to the given event
		/// </summary>
		/// <param name="evtName">name that identifies the event</param>
		/// <param name="handler">delegate to deregister</param>
		/// <returns>true if the deregistration process succeeds, falise if the event is not present</returns>
		public bool Deregister(string evtName, PlatformEventHandler handler)
		{
			lock(this.customEventMap.SyncRoot)
			{
				CustomEventInfo evtInfo = this.customEventMap[evtName] as CustomEventInfo;
				if (evtInfo != null) 
				{
					evtInfo.Handlers -= handler;


					return true;
				}

				return false;
			}
		}


		
		#endregion

		#region Standard Event Management
		/// <summary>
		/// Fires a specified PlatformEvent, with the given args,
		/// used by the platform in order to notify the modules that
		/// have been registered for that event
		/// </summary>
		/// <param name="eventType">type of the event</param>
		/// <param name="args">corresponding srguments</param>
		/// <param name="token">owning token</param>
		public void RaiseStandardEvent(PlatformEvent eventType, PlatformEventArgs args, int token) 
		{
			
			if ((token == this.platform.Messaging.GetHashCode())	&&
				((eventType == PlatformEvent.ConversationAccepted)	||
				 (eventType == PlatformEvent.ConversationClosed)	||
				 (eventType == PlatformEvent.ConversationRefused)	||
				 (eventType == PlatformEvent.MessageBatch)			||
				 (eventType == PlatformEvent.MessageReceived)		||
				 (eventType == PlatformEvent.MessageSent))
			   )
			{
				this.raise(eventType, args);
			}
			else if ((token == this.platform.Storage.GetHashCode())	&&
					 ((eventType == PlatformEvent.AssemblyRemoved) ||
					  (eventType == PlatformEvent.AssemblyUploaded))
					)
			{
				this.raise(eventType, args);
			}
			else if (true) 
			{
				// TODO: for all the events related to
				//		 the activity of the AMS
			}
		}

		/// <summary>
		/// Retrieves a valid token for the given core module.
		/// The token is used to allow core modules to raise
		/// the standard events that belongs to them.
		/// </summary>
		/// <param name="module">the instance of the module
		/// which is requesting the token</param>
		/// <returns>owning token</returns>
		public int GetToken(IPlatformModule module) 
		{
			if (module == this.platform.Messaging)
			{
				return this.platform.Messaging.GetHashCode();
			}
			if (module == this.platform.Storage)
			{
				return this.platform.Storage.GetHashCode();
			}
			return 0;
		}

		/// <summary>
		/// Raises a standard event
		/// </summary>
		/// <param name="eventType">standard event type</param>
		/// <param name="args">event arguments</param>
		internal void raise(PlatformEvent eventType, PlatformEventArgs args)
		{
			switch(eventType)
			{
				case PlatformEvent.AgentCreated	: 
					if (this.OnAgentCreated != null)
						this.OnAgentCreated(this,args);		
					break;

				case PlatformEvent.AgentPersisted : 
					if (this.OnAgentPersisted != null)
						this.OnAgentPersisted(this,args); 
					break;

				case PlatformEvent.AgentResumed : 
					if (this.OnAgentResumed != null)
						this.OnAgentResumed(this,args); 
					break;
				
				case PlatformEvent.AgentStopped : 
					if (this.OnAgentStopped != null)
						this.OnAgentStopped(this,args); 
					break;
				
				case PlatformEvent.AgentWokenUp : 
					if (this.OnAgentWokenUp != null)
						this.OnAgentWokenUp(this,args); 
					break;
				
				case PlatformEvent.AssemblyUploaded :
					if (this.OnAssemblyUploaded != null)
						this.OnAssemblyUploaded(this,args); 
					break;

				case PlatformEvent.AssemblyRemoved :
					if (this.OnAssemblyRemoved != null)
						this.OnAssemblyRemoved(this,args); 
					break;
				
				case PlatformEvent.MessageSent :
					if (this.OnMessageSent != null)
						this.OnMessageSent(this,args); 
					break;
				
				case PlatformEvent.MessageReceived :
					if (this.OnMessageReceived != null)
						this.OnMessageReceived(this,args); 
					break;
				
				case PlatformEvent.MessageBatch :
					if (this.OnMessageBatch != null)
						this.OnMessageBatch(this,args); 
					break;
				
				case PlatformEvent.ConversationRequested : 
					if (this.OnConversationRequested != null)
						this.OnConversationRequested(this,args);
					break;
				
				case PlatformEvent.ConversationAccepted : 
					if (this.OnConversationAccepted != null)
						this.OnConversationAccepted(this,args); 
					break;
				
				case PlatformEvent.ConversationRefused : 
					if (this.OnConversationRefused != null)
						this.OnConversationRefused(this,args); 
					break;
				
				case PlatformEvent.ConversationClosed : 
					if (this.OnConversationClosed != null)
						this.OnConversationClosed(this,args); 
					break;
			}		
		}


		#endregion 

		#region Platform Commands
		/// <summary>
		/// Posts a command to the platform command queue
		/// </summary>
		/// <param name="cmd">command object</param>
		public void PostCommand(PlatformCommand cmd) 
		{
			// TODO: Add code here to handle the 
			//		 command posting operation
			throw new System.NotImplementedException();
		}

		#endregion

		#region Event Sink Management
		/// <summary>
		/// Returns the list of all the registered event
		/// sinks.
		/// </summary>
		/// <returns>the list of the current event sinks</returns>
		public EventSinkDescriptor[] GetRegisteredSinks()
		{
			lock(this.eventSinkMap.SyncRoot)
			{
				EventSinkDescriptor[] descriptors = new EventSinkDescriptor[this.eventSinkMap.Count];
				int ndx = 0;
				foreach(EventSinkInfo info in this.eventSinkMap.Values)
				{
					descriptors[ndx++] = info.Descriptor;
				}

				return descriptors;
			}
		}

		/// <summary>
		/// Registers an event sink. 
		/// </summary>
		/// <param name="evtSink">event sink descriptor</param>
		/// <param name="handler">handler of the event</param>
		/// <param name="token">owning token</param>
		/// <returns>
		/// one of the following:
		/// <list type="bullet">
		/// <item>SinkAlreadyExists - the proposed event sink has been already registered</item>
		/// <item>SinkInvalidEvent - the event descriptor does not identify a valid event sink</item>
		/// <item>SinkOk - registration successful</item>
		/// </list>
		/// </returns>
		public SinkStatusCodes RegisterEventSink(EventSinkDescriptor evtSink, PlatformEventSinkHandler handler, out int token)
		{
			token = 0;
			if ((evtSink == null) || (handler == null))
			{
				return SinkStatusCodes.SinkInvalidEvent;
			}
			
			lock(this.eventSinkMap.SyncRoot)
			{
				EventSinkInfo info = this.eventSinkMap[evtSink.Name] as EventSinkInfo;
				if (info != null)
				{
					return SinkStatusCodes.SinkAlreadyExists;
				}
			
			
				info = new EventSinkInfo(evtSink,handler);
				token = info.GetHashCode();
				this.eventSinkMap.Add(info.Descriptor.Name, info);
			}

			return SinkStatusCodes.SinkOk;
		}
 
		/// <summary>
		/// Deregisters an event sink.
		/// </summary>
		/// <param name="evtSink">event sink descriptor</param>
		/// <param name="token">owning token</param>
		/// <returns>
		/// one of the following:
		/// <list type="bullet">
		/// <item>SinkNotFound - the event sink identified by the descriptor does not exists</item>
		/// <item>SinkNotOwned  - the given token does not allow the modification of the sink</item>
		/// <item>SinkInvalidEvent - the event descriptor does not identify a valid event sink</item>
		/// <item>SinkOk - deregistration successful</item>
		/// </list>
		/// </returns>
		public SinkStatusCodes DeregisterEventSink(EventSinkDescriptor evtSink, int token)
		{
			if (evtSink == null)
			{
				return SinkStatusCodes.SinkInvalidEvent;
			}
			
			lock(this.eventSinkMap.SyncRoot)
			{
				EventSinkInfo info = this.eventSinkMap[evtSink.Name] as EventSinkInfo;
				if (info == null)
				{
					return SinkStatusCodes.SinkNotFound;
				}
				if (info.GetHashCode() != token)
				{
					return SinkStatusCodes.SinkNotOwned;
				}
			
				this.eventSinkMap.Remove(info.Descriptor.Name);
			}
			return SinkStatusCodes.SinkOk;
		}

		/// <summary>
		/// Raises an avent for a speficied event sink.
		/// </summary>
		/// <param name="evtName">event name</param>
		/// <param name="evt">event</param>
		/// <returns>
		/// one of the following:
		/// <list type="bullet">
		/// <item>SinkNotFound - the event sink identified by the name does not exists</item>
		/// <item>SinkInvalidEvent - the event object is not valid for the given event sink</item>
		/// <item>SinkOk - the event has been pumped to the sink</item>
		/// </list>
		/// </returns>
		public SinkStatusCodes PumpEvent(string evtName, PlatformSinkEvent evt) 
		{
			lock(this.eventSinkMap.SyncRoot)
			{
				EventSinkInfo info = this.eventSinkMap[evtName] as EventSinkInfo;
				if (info == null)
				{
					return SinkStatusCodes.SinkNotFound;
				}
				if (info.Descriptor.EventType.IsInstanceOfType(evt))
				{
					info.Absorbe(new PlatformSinkEventArgs(evtName,evt));
					return SinkStatusCodes.SinkOk;
				}
				return SinkStatusCodes.SinkInvalidEvent;
			}
			
		}

		/// <summary>
		/// Check if anyone is resgistered as event sink of a given avent
		/// </summary>
		/// <param name="evtSinkDescriptor">Descriptor of the event sink</param>
		/// <returns>True if anyone is registered as event sink</returns>
		public bool IsEventSinkRegistered (EventSinkDescriptor evtSinkDescriptor)
		{
			EventSinkDescriptor[] sinkDescriptors = this.GetRegisteredSinks();
			foreach (EventSinkDescriptor descriptor in sinkDescriptors)
			{
				if (evtSinkDescriptor.Equals(descriptor))
				{
					return true;
				}
			}
			return false;
		}

		#endregion

	}

}