/*********************************************************************/
/*                                                                   */
/*                     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.Collections.Generic;
using System.Reflection;

using AgentService.Agent;
using AgentService.Agent.Behaviour;
using AgentService.Agent.Knowledge;
using AgentService.Agent.Runtime;

using AgentService.Platform;
using AgentService.Platform.DF;
using AgentService.Platform.AMS;
using AgentService.Platform.MTS;
using AgentService.Platform.Modules;


namespace AgentService.Agent
{
    /// <summary>
    /// The delegate that manages the OnPersistAgent event.
    /// </summary>
    public delegate void PersistAgentDelegate(object sender, PersistenceEventArgs args);
        
    /// <summary>
    /// Delegate BehaviourDelegate. Delegate that manages every event related to the behaviour.
    /// </summary>
    public delegate void BehaviourDelegate(object sender, BehaviourArgs args);

    /// <summary>
    /// The delegate that manages the most of the Agent events:
    /// activation, stopping, termination...
    /// </summary>
    public delegate void AgentDelegate(AID sender);

    /// <summary>
    /// Class BehaviourArgs. Collects information about the event related
    /// to the behaviour. It mantains a reference to the behaviour type,
    /// name and state.
    /// </summary>
    public class BehaviourArgs
    {

        /// <summary>
        /// Type of the behaviour.
        /// </summary>
        private System.Type type;
        /// <summary>
        /// Gets the type of the behaviour, if the
        /// type is equal to Agent.Behaviour.Behaviour
        /// the event is not tied to a specific Behaviour
        /// class or instance but to all the Behaviour instances
        /// of the agent.
        /// </summary>
        public System.Type Type
        {
            get
            {
                return this.type;
            }
        }
        /// <summary>
        /// Name of the behaviour, if the name is null
        /// the event is related to the all the Behaviour
        /// instances of the agent.
        /// </summary>
        private string name;
        /// <summary>
        /// Gets the name of the behaviour, if the name is null
        /// the event is related to the all the Behaviour
        /// instances of the agent.
        /// </summary>
        public string Name
        {
            get
            {
                return this.name;
            }
        }

        /// <summary>
        /// State of the behaviour.
        /// </summary>
        private BehaviourState state;
        /// <summary>
        /// Gets the state of the behaviour.
        /// </summary>
        private BehaviourState State
        {
            get
            {
                return this.state;
            }
        }
        /// <summary>
        /// if true, the behaviour that terminated
        /// was the last behaviour scheduled by the
        /// agent.
        /// </summary>
        private bool bLast;
        /// <summary>
        /// Gets the Last flag, if true the behaviour
        /// that originated the event was the last 
        /// behaviour scheduled by the agent
        /// </summary>
        public bool IsLast
        {
            get
            {
                return this.bLast;
            }
        }

        /// <summary>
        /// Construct a BehaviourArgs object.
        /// </summary>
        /// <param name="type">type of the behaviour</param>
        /// <param name="name">name of the behaviour</param>
        /// <param name="state">state of the behaviour</param>
        /// <param name="bLast">if true this is the behaviour instance 
        /// associated to the event was the last remined in the scheduler</param>
        public BehaviourArgs(System.Type type, string name, BehaviourState state, bool bLast)
        {
            this.type = type;
            this.name = name;
            this.state = state;
            this.bLast = bLast;
        }
        /// <summary>
        /// Construct a BehaviourArgs object.
        /// </summary>
        /// <param name="type">type of the behaviour</param>
        /// <param name="name">name of the behaviour</param>
        /// <param name="state">state of the behaviour</param>
        public BehaviourArgs(System.Type type, string name, BehaviourState state)
        {
            this.type = type;
            this.name = name;
            this.state = state;
            this.bLast = false;
        }

    }

    /// <summary>
    /// Class PeristenceEventArgs. Wraps the agent persistent object.
    /// </summary>
    public class PersistenceEventArgs
    {


        /// <summary>
        /// Persistent version of the agent.
        /// </summary>
        private AgentPersistent persistent;
        /// <summary>
        /// Gets the persistent version of the agent.
        /// </summary>
        public AgentPersistent Persistent
        {
            get
            {
                return this.persistent;
            }

        }

        /// <summary>
        /// Constructs a PersistenceEventArgs object for the given
        /// AgentPersistent object.
        /// </summary>
        /// <param name="ap">persistent version of the agent</param>
        public PersistenceEventArgs(AgentPersistent ap)
        {
            this.persistent = ap;
        }

    }
	



	

	
	/// <summary>
	/// Class Agent. Defines a running instance of an agent.
	/// </summary>
	public class Agent: IAgent
	{
		# region Members
		
		#region Agent Events

		/// <summary>
		/// Conversation handler delegate.
		/// </summary>
		private ConversationDelegate convHandler; 

		/// <summary>
		/// Class DefaultAgentProxy. Agent proxy instance 
		/// it is used to forward event handler addition 
		/// and removal to the agent instance.
		/// </summary>
		private class DefaultAgentEventProxy : IAgentEventProxy 
		{
			/// <summary>
			/// agent instance.
			/// </summary>
			private IAgent agent;

			/// <summary>
			/// flags that controls event forwardin, if
			/// true the events are forwarded, if false not.
			/// </summary>
			internal bool bForwardEvents;
		
			/// <summary>
			/// Fires when the agent is activated.
			/// </summary>
			public event AgentDelegate OnActivateAgent 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnActivateAgent += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnActivateAgent -= value;
					}
				}
			}
			/// <summary>
			/// Fires when the agent is stopped.
			/// </summary>
			public event AgentDelegate OnStopAgent 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnStopAgent += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnStopAgent -= value;
					}
				}
			}
			/// <summary>
			/// Fires when the system reosurces of the agent
			/// need to be released.
			/// </summary>
			public event AgentDelegate OnReleaseAgent 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnReleaseAgent += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnReleaseAgent -= value;
					}
				}
			}
			/// <summary>
			/// Fires when the agent is terminated.
			/// </summary>
			public event AgentDelegate OnTerminateAgent 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnTerminateAgent += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnTerminateAgent -= value;
					}
				}
			}
			/// <summary>
			/// Fires when a new behaviour in the agent is
			/// created.
			/// </summary>
			public event BehaviourDelegate OnNewBehaviour 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnNewBehaviour += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnNewBehaviour -= value;
					}
				}
			}
			/// <summary>
			/// Fires when an agent's behaviour is started.
			/// </summary>
			public event BehaviourDelegate OnStartBehaviour 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnStartBehaviour += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnStartBehaviour -= value;
					}
				}
			}
			/// <summary>
			/// Fires when an agent's behaviour is suspended.
			/// </summary>
			public event BehaviourDelegate OnSuspendBehaviour 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnSuspendBehaviour += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnSuspendBehaviour -= value;
					}
				}
			}
			/// <summary>
			/// Fires when an agent's behaviour is terminated.
			/// </summary>
			public event BehaviourDelegate OnTerminateBehaviour 
			{
				add 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnTerminateBehaviour += value;					
					}
				}
				remove 
				{
					if (this.bForwardEvents == true)
					{
						this.agent.OnTerminateBehaviour -= value;
					}
				}
			}

			/// <summary>
			/// Creates a proxy for the given agent instance.
			/// </summary>
			/// <param name="agent">agent instance.</param>
			internal DefaultAgentEventProxy(IAgent agent)
			{
				this.agent = agent;
				this.bForwardEvents = false;
			}
			
			
		}


		/// <summary>
		/// proxy to the agent events.
		/// </summary>
		private DefaultAgentEventProxy eventProxy;

		/// <summary>
		/// Thrown when the agent is activated.
		/// </summary>
		public event AgentDelegate OnActivateAgent;

		/// <summary>
		/// Fires every time an agent has terminated
		/// its activity either because it has been 
		/// stopped by the platform or because it has
		/// terminated.
		/// </summary>
		public event AgentDelegate OnReleaseAgent;

		/// <summary>
		/// thrown when the agent is stopped
		/// </summary>
		public event AgentDelegate OnStopAgent;

		/// <summary>
		/// thrown when the agent temrminates its execution
		/// </summary>
		public event AgentDelegate OnTerminateAgent;


		/// <summary>
		/// thrown by a persistent agent, when its internal data 
		/// change
		/// </summary>
		/*internal*/ public event PersistAgentDelegate OnPersistAgent;
		
		#endregion

		#region Behaviour related events

		/// <summary>
		/// Fires every time a new behaviour is created.
		/// </summary>
		public event BehaviourDelegate OnNewBehaviour;
		/// <summary>
		/// Fires every time a behaviour is started.
		/// </summary>
		public event BehaviourDelegate OnStartBehaviour;
		/// <summary>
		/// Fires every time a behaviour is terminated.
		/// </summary>
		public event BehaviourDelegate OnTerminateBehaviour;
		/// <summary>
		/// Fires every time a behaviour is suspended.
		/// </summary>
		public event BehaviourDelegate OnSuspendBehaviour;
		/// <summary>
		/// Fires every time a behaviour is woken up.
		/// </summary>
		public event BehaviourDelegate OnWakeUpBehaviour;

		#endregion

		/// <summary>
		/// Unique Agent-IDentifier. 
		/// </summary>
		protected AID aid;
		/// <summary>
		/// Gets the Agent's AID.
		/// </summary>
		public AID AID
		{
			get 
			{
				return this.aid;
			}

			set
			{
				this.aid = value;
				this.persistent.SetAID(value);
			}
		}

		/// <summary>
		/// Life cycle state of the Agent.
		/// </summary>
		private AgentState state = AgentState.Unknown;
		/// <summary>
		/// Gets the Agent's state.
		/// </summary>
		public AgentState State
		{
			get
			{
				return this.state;
			}
			set
			{
				this.state = value;
				this.persistent.SetState(value);

			}

		}


		/// <summary>
		/// Persistence flag.
		/// </summary>
		private bool bPersist;
		/// <summary>
		/// Gets the persistence flag.
		/// </summary>
		public bool IsPersistent 
		{
			get 
			{
				return this.bPersist;
			}
		}

		/// <summary>
		/// Behaviour scheduler.
		/// </summary>
		private AgentService.Agent.Behaviour.IBehaviourScheduler scheduler;

		/// <summary>
		/// Runtime environment for the agent.
		/// </summary>
		private AgentService.Agent.Runtime.IRuntimeEx runtime;

		/// <summary>
		/// Collection of KnowledgeManager objects.
		/// </summary>
		private AgentService.Agent.Knowledge.KnowledgeCollection knowledges;
		/// <summary>
		/// Gets the collection of KnowledgeManager objects.
		/// </summary>
		public AgentService.Agent.Knowledge.KnowledgeCollection Knowledges 
		{
			get 
			{
				return this.knowledges;
			}
		}

		/// <summary>
		/// Collection of Behaviour objects belonging to the Agent.
		/// </summary>		
		private AgentService.Agent.Behaviour.BehaviourCollection behaviours;
		/// <summary>
		/// Gets the collection of Behaviour objects.
		/// </summary>
		public AgentService.Agent.Behaviour.BehaviourCollection Behaviours
		{
			get
			{
				return this.behaviours;
			}
		}

		/// <summary>
		/// Collection of Knowledge type objects handled by the agent.
		/// </summary>
		private TypeDescriptorCollection knowledgeTypes;
		/// <summary>
		/// Returns the collection of the Knowledge type objects that
		/// the agent handles.
		/// </summary>
		public TypeDescriptorCollection KnowledgeTypes 
		{
			get
			{
				return this.knowledgeTypes;
			}
		}
		/// <summary>
		/// Collection of Behaviour type objects handled by the agent.
		/// </summary>
		private TypeDescriptorCollection behaviourTypes;
		/// <summary>
		/// Returns the collection of the Behaviour type objects that
		/// the agent handles.
		/// </summary>
		public TypeDescriptorCollection BehaviourTypes 
		{
			get
			{
				return this.behaviourTypes;
			}
		}

		/// <summary>
		/// Reference to the AgentTemplate managed by the Agent.
		/// </summary>
		internal protected AgentTemplate template;

		/// <summary>
		/// The type context that loads into the agent the knowledge's and behaviour's type added by the template.
		/// </summary>
		private DefaultTypeContext typeContext;

		/// <summary>
		/// The factory context that istantiates and loads into the agent knowledge's and behaviour's object added by the template.
		/// </summary>
		private DefaultFactoryContext factoryContext;


		/// <summary>
		/// Persistent version of the agent.
		/// </summary>
		internal AgentPersistent persistent;

        public AgentPersistent Persistent
        {
            get
            {
                return this.persistent;
            }
            set
            {
                this.persistent = value;
            }
        }

		/// <summary>
		/// Profile of the agent
		/// </summary>
		private AgentProfile profile;

		/// <summary>
		/// Get the profile of the agent
		/// </summary>
		public AgentProfile Profile
		{
			get
			{
				if (this.profile == null)
				{
					TypeDescriptor[] bhDescriptors = new TypeDescriptor[this.behaviourTypes.Count];
					TypeDescriptor[] knDescriptors = new TypeDescriptor[this.knowledgeTypes.Count];
					lock(this.behaviourTypes)
					{
						this.behaviourTypes.CopyTo(bhDescriptors, 0);
					}
					lock(this.knowledgeTypes)
					{
						this.knowledgeTypes.CopyTo(knDescriptors, 0);
						
					}
					TypeDescriptor agentTemplateDescriptor = new TypeDescriptor(this.template.GetType());
					this.profile = new AgentProfile(bhDescriptors,knDescriptors,agentTemplateDescriptor,this.aid.GlobalName,this.aid.HapName);

				}
				return this.profile;
			}
		}

		/// <summary>
		/// Name of agent's config file
		/// </summary>
		private string configFileName;

		/// <summary>
		/// Get the config file name of the agent
		/// </summary>
		public string ConfigFileName
		{
			get
			{
				return this.configFileName;
			}
		}

		#endregion

		# region Constructor
		
		/// <summary>
		/// Constructs an empty Agent.
		/// </summary>
		public Agent()
		{
			this.knowledges = new AgentService.Agent.Knowledge.KnowledgeCollection();
			this.behaviours = new AgentService.Agent.Behaviour.BehaviourCollection();
			this.knowledgeTypes = new TypeDescriptorCollection();
			this.behaviourTypes = new TypeDescriptorCollection();

			this.factoryContext = new DefaultFactoryContext(this);
			this.typeContext = new DefaultTypeContext(this);

			this.scheduler = new Behaviour.BehaviourScheduler();

			this.persistent = new AgentPersistent();
			this.bPersist  = true;

			this.convHandler = new ConversationDelegate(this.HandleConversation);

		}

		/// <summary>
		/// Constructs an agent by specifying the persistence flag.
		/// </summary>
		/// <param name="bPersist">persistence flag</param>
		public Agent(bool bPersist) 
		{
			this.knowledges = new AgentService.Agent.Knowledge.KnowledgeCollection();
			this.behaviours = new AgentService.Agent.Behaviour.BehaviourCollection();
			this.knowledgeTypes = new TypeDescriptorCollection();
			this.behaviourTypes = new TypeDescriptorCollection();

			this.factoryContext = new DefaultFactoryContext(this);
			this.typeContext = new DefaultTypeContext(this);


			this.scheduler = new Behaviour.BehaviourScheduler();

			// TODO: Code review: why always create agentpersistent?
			this.persistent = new AgentPersistent();
			
			this.bPersist = bPersist;

			this.convHandler = new ConversationDelegate(this.HandleConversation);

		}

		#endregion

		# region Agent Activity

		/// <summary>
		/// Initialize the internal Agent's data structures.
		/// </summary>
		/// <param name="configFile">configuration file for agent initialization including the full path</param>
		public void Initiate(string configFile)
		// public void Initialize(object configFile)
		{
            //MOD: 07/06/2006: Marco Garr: removed typeContext from AgentTemplate.Initialize
            //                 now types are registered automatically using AgentAttributes.

            AgentBehavioursAttribute behas = (AgentBehavioursAttribute)Attribute.GetCustomAttribute(this.template.GetType(), typeof(AgentBehavioursAttribute));
            if (behas != null)
            {
                this.typeContext.RegisterBehaviourTypes(behas.Types);
            }
            AgentKnowledgesAttribute knows = (AgentKnowledgesAttribute)Attribute.GetCustomAttribute(this.template.GetType(), typeof(AgentKnowledgesAttribute));
            if (knows != null)
            {
                this.typeContext.RegisterKnowledgeTypes(knows.Types);
            }

            if (configFile != null)
            {
                bool bOk = this.template.Configure(configFile);
                if (bOk == false)
                {
                    throw new AgentService.Generic.AgentServiceException("Unexpected error reading: " + configFile);
                }
            }
            this.template.Initiate(this.factoryContext);

			this.configFileName = System.IO.Path.GetFileName(configFile);
		}

		/// <summary>
		/// Starts the agent activity.
		/// </summary>
		public void Activate()
		{

			if (this.OnActivateAgent!= null)
			{
				this.OnActivateAgent(this.AID);
			}
			lock(this.behaviours)
			{
				foreach(Behaviour.Behaviour behaviour in this.behaviours)
				{
					behaviour.Bind(this.runtime.Clone(behaviour));
				}
			}
			this.scheduler.StartAll();
		}

		/// <summary>
		/// Assigns an AgentTemplate to the Agent and gives him an AID.
		/// </summary>
		/// <param name="fullTemplateName">full template name of the corresponding AgentTemplate subtype</param>
		/// <param name="assemblyName">name of the containing assembly of the AgentTemplate subtype</param>
		public void SetTemplate(AgentTemplate template)
		{

			this.template = template;
			if (this.bPersist == true)
			{
				this.persistent.SetTemplateName(template.GetType().FullName);
			}
		}

		/// <summary>
		/// Commits the agent migration process
		/// </summary>
		/// <param name="bIsSourceInstance">flag used to distinguish the source
		///									and the target platform</param>
		public void CommitMove (bool bIsSourceInstance)
		{
			if (bIsSourceInstance == true)
			{
				// call the template to finalize all the data belonging to
				// the template
				this.template.Terminate();

				// no more behaviours in execution; the agent terminated its work
				this.state = AgentState.Unknown;
				if (this.OnTerminateAgent != null)
				{
					this.OnTerminateAgent(this.AID);
				}
			}
			else
			{
				// everything the agent needs to restart its activity in the
				// target platform
			}
		}

		# endregion

		# region Manage Platform Services

		/// <summary>
		/// Binds the agent to the runtime environemt of the platform.
		/// </summary>
		/// <param name="runtime">gives access to the runtime services of the platform</param>
		public void Bind(AgentService.Agent.Runtime.IRuntimeEx runtime) 
		{
			this.runtime = runtime;
				
			if (this.eventProxy == null)
			{
				this.eventProxy = new DefaultAgentEventProxy(this);
			}
			this.eventProxy.bForwardEvents = true;
			this.runtime.PersistenceSvc.BindEvents(this.eventProxy);
			this.runtime.MessageSvc.BindEvents(this.eventProxy);
		    this.runtime.LogSvc.BindEvents(this.eventProxy);
			this.runtime.WPageSvc.BindEvents(this.eventProxy);
			this.runtime.YPageSvc.BindEvents(this.eventProxy);
		    /*
			this.runtime.LogSvc.OpenSession(this.GetHashCode());
			this.OnStopAgent += this.runtime.MessageSvc.GetStopAgentDelegate();
			*/
			this.runtime.MessageSvc.OnIncomingConversation += this.convHandler;
            this.eventProxy.bForwardEvents = false;
		}
		
		/// <summary>
		/// Loads agent data from its persisted version.
		/// </summary>
		/// <param name="agentPersistent">persisted version of the agent</param>
		public virtual void ResumeFrom(AgentPersistent agentPersistent) 
		{
			this.persistent = agentPersistent;
			
            // MOD: 19/07/2006 Simone Belotti: check if collections are empty. If not, erase all the elements
            if (this.knowledges.Count != 0)
            {
                this.knowledges = new KnowledgeCollection();
            }
            // ENDMOD

			this.knowledgeTypes = agentPersistent.KnowledgeTypeNames;
			this.behaviourTypes = agentPersistent.BehaviourTypeNames;

			for(int ndx = 0;  ndx<agentPersistent.PersistedKnowledges.Count; ndx++)
			{
				Knowledge.KnowledgePersistent kp = agentPersistent.PersistedKnowledges[ndx];
				System.Type type = this.findTypeByName(kp.TypeName);
				if (type != null)
				{
					System.Reflection.ConstructorInfo constructor = type.GetConstructor(System.Type.EmptyTypes);
					// FIXME: require the 1 string parameter constructor!!!!!
					//        parameter: name of the knowledge object
					Knowledge.Knowledge know = constructor.Invoke(new object[0] {} ) as Knowledge.Knowledge;
					know.ResumeFrom(kp);
					know.ownerName = this.AID.Name;
                    know.OnPersistKnowledge += new Knowledge.KnowledgeChangedDelegate(this.PersistChanges);
					this.knowledges.Add(know);
				}
			}

            // MOD: 19/07/2006
            if (this.behaviours.Count != 0)
            {
                this.behaviours.RemoveAll();
            }

			foreach(Behaviour.BehaviourPersistent bp in agentPersistent.PersistedBehaviours)
			{
				object[] parameters = new object[bp.KnowledgeNames.Length+1];
				parameters[0] = bp.Name;
				
				// CHANGE 29/01/2006: i=1 -> i=0: wrong because it goes outside
				//					  boundary limits
				// int i = 0;


				for(int ndx=1; ndx<parameters.Length; ndx++)
				{
					foreach(Knowledge.Knowledge kndx in this.knowledges)
					{
						if (kndx.Name.CompareTo(bp.KnowledgeNames[ndx-1]) == 0)
						{
							parameters[ndx] = kndx;
						}
					}
				}

				parameters[0] = bp.Name;

				Type type = this.findTypeByName(bp.BehaviourTypeName);

					
				if (type != null)
				{
					Behaviour.Behaviour behaviour =  Activator.CreateInstance(type, parameters)
														as Behaviour.Behaviour;
					lock(this.behaviours) 
					{
						this.Behaviours.Add(behaviour);
					}
					behaviour.SetOwner(this);
					behaviour.State = bp.State;

					this.scheduler.Add(behaviour);

				}

			}

            
			this.template.Resume(this.typeContext,this.factoryContext);

			this.state = persistent.State;

			
		}

		/// <summary>
		/// Gets the type object related to the given type name.
		/// </summary>
		/// <param name="typeName">name of the type</param>
		/// <returns>type object holding the information about the type</returns>
		private System.Type findTypeByName(string typeName) 
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			Type type = null;
			foreach(Assembly assembly in assemblies) 
			{
				type = assembly.GetType(typeName);
				if (type != null)
					break;
			}

			return type;
		}
		
		/// <summary>
		/// Creates the persistent version of the agent.
		/// </summary>
		/// <returns>persisted version of the agent</returns>
		public AgentPersistent GetPersistent() 
		{
			if (this.bPersist)
			{
				// CHANGE: 23/01/2003 - Added the following statement to
				//						Clear the persistedKnowledge data structure
				this.persistent.PersistedKnowledges.RemoveAll();
				foreach(Knowledge.Knowledge knowledge in this.knowledges)
				{
					this.persistent.PersistedKnowledges.Add(knowledge.GetPersistent());		
				}
				lock(this.behaviours) 
				{
					foreach(Behaviour.Behaviour behaviour in this.behaviours) 
					{
						foreach(Behaviour.BehaviourPersistent bp in this.persistent.PersistedBehaviours) 
						{
							if (behaviour.Name.CompareTo(bp.Name) == 0) 
							{
								bp.State = behaviour.State;
							}
						}
					}
				}
				this.persistent.SetState(this.state);
			
				return this.persistent;
			}

			return null;
		}

		/// <summary>
		/// Handles the incoming conversation event.
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="args">information about the incoming conversation</param>
		private void HandleConversation(object sender, ConversationArgs args)
		{
			DefaultAgentContext context = new DefaultAgentContext(this);
			this.template.HandleConversation(context, args);
		}

		#endregion

		#region Manage Agent Behaviours

		/// <summary>
		/// Adds a new behaviour to the agent and starts it.
		/// </summary>
		/// <param name="behaviour">The Behaviour to be added to the Agent</param>
		/// <param name="bStart">if true starts the behaviour</param>
		public void SubmitBehaviour(Behaviour.Behaviour behaviour, bool bStart)
		{
			
			lock(this.behaviours) 
			{
				this.behaviours.Add(behaviour);
			}
			this.scheduler.Add(behaviour);

			// notifies all the runtime components
			// that a new beahviour has been created
			// in this way we can properly handle 
			// the WaitForTermination statement

			if (this.OnNewBehaviour != null)
			{
				this.OnNewBehaviour(this, new BehaviourArgs(behaviour.GetType(), behaviour.Name, behaviour.State));
			}

			if (bStart == true)
			{
				// we have to bind the behaviour to the runtime
				// because bStart == true and this means that
				// the behaviour has been created at runtime and
				// has not yet bound
				behaviour.Bind(this.runtime.Clone(behaviour));
				this.scheduler.Start(behaviour);
			}
		}

		/// <summary>
		/// Suspends a behaviour instance.
		/// </summary>
		/// <param name="behaviour">behaviour instances that will be suspended</param>
		public void SuspendBehaviour(AgentService.Agent.Behaviour.Behaviour behaviour)
		{
			this.scheduler.Suspend(behaviour);

			// notifies all the runtime components
			// that a behaviour has been suspended

			if (this.OnSuspendBehaviour != null)
			{
				this.OnSuspendBehaviour(this, new BehaviourArgs(behaviour.GetType(), behaviour.Name, behaviour.State));
			}

		}
		
		/// <summary>
		/// Suspends all the behaviour instances.
		/// </summary> 
		public void SuspendAllBehaviours()
		{
			this.scheduler.SuspendAll();

			// notifies all the runtime components
			// that a all the behaviours have been
			// suspended

			if (this.OnSuspendBehaviour != null)
			{
				this.OnSuspendBehaviour(this, new BehaviourArgs(typeof(Behaviour.Behaviour), null, BehaviourState.Suspended));
			}

		}

		/// <summary>
		/// Resumes a suspended behaviour instance.
		/// </summary>
		/// <param name="behaviour">suspended behaviour instance that will be resumed</param>
		public void WakeUpBehaviour(AgentService.Agent.Behaviour.Behaviour behaviour)
		{
			this.scheduler.WakeUp(behaviour);

			// notifies all the runtime components
			// that a new behaviour has been created
			// woken up

			if (this.OnWakeUpBehaviour != null)
				this.OnWakeUpBehaviour(this, new BehaviourArgs(behaviour.GetType(), behaviour.Name, behaviour.State));

		}

		/// <summary>
		/// Resumes all suspended behaviour instances.
		/// </summary>
		public void WakeUpAllBehaviours()
		{
			this.scheduler.WakeUpAll();

			// notifies all the runtime components
			// that a new behaviour has been created
			// woken up

			if (this.OnWakeUpBehaviour != null)
				this.OnWakeUpBehaviour(this, new BehaviourArgs(typeof(Behaviour.Behaviour), null, BehaviourState.Running));

		}

		/// <summary>
		/// Removes a behaviour instance.
		/// </summary>
		/// <param name="behaviour">behaviour instance that will be removed</param>
		public void RemoveBehaviour(AgentService.Agent.Behaviour.Behaviour behaviour)
		{

			bool bTerminate = false;
			// ok the code behaviour has finished
			// its activity so we notify all the
			// handlers about the event

			this.scheduler.Remove(behaviour);

			lock(this.behaviours)
			{
				this.behaviours.Remove(behaviour);
				//MOD: Christian Vecchiola - 02/12/2005
				//	   Agent Termination
				if (this.behaviours.Count == 0)
				{
					bTerminate = true;
 				}
				//END MOD
			}

			// notifies all the runtime components
			// that a new behaviour has been terminated

			if (this.OnTerminateBehaviour != null) 
			{
				this.OnTerminateBehaviour(this, new BehaviourArgs(behaviour.GetType(), behaviour.Name, behaviour.State, bTerminate));
			}
			// checks if there are no more behaviours running
			// if bTerminate is true, ok we're done

			if (bTerminate == true)
			{
				// finalizes the agent instance:
				// let all runtime components stop
				// their activity.
				if (this.OnReleaseAgent != null)
				{
					this.OnReleaseAgent(this.aid);
				}
				// call the template to finalize
				// all the data belonging to the
				// template
				this.template.Terminate();
	
				// no more behaviours in execution
				// the agent has terminated its work
				this.state = AgentState.Terminated;
				if (this.OnTerminateAgent != null)
				{
					this.OnTerminateAgent(this.AID);
				}

				// disconnects the event handlers.
				this.Unbind();

			}
			else
			{
				if (this.bPersist == true)
				{
					lock(this.persistent.PersistedBehaviours) 
					{
						this.persistent.PersistedBehaviours.Remove(behaviour);
					}
				
					if (this.OnPersistAgent != null)
					{
						PersistenceEventArgs args = new PersistenceEventArgs(this.GetPersistent());
						this.OnPersistAgent(this,args);
					}
				}
			}
		}
		
		/// <summary>
		/// Removes all behaviours instances.
		/// </summary> 
		public void RemoveAllBehaviours()
		{
			this.Stop();
			lock(this.behaviours) 
			{
				this.behaviours.RemoveAll();
			}
			// notifies all the runtime components
			// that a new behaviour has been terminated
			if (this.OnTerminateBehaviour != null)
			{
				this.OnTerminateBehaviour(this, new BehaviourArgs(typeof(Behaviour.Behaviour), null, BehaviourState.Unknown, true));
			}
			// NOTE: Do not check if the agent is persistent since the
			//		 it is going to be destroyed.
		}

		/// <summary>
		/// Starts a collection of behaviours instances.
		/// </summary>
		/// <param name="behaviourNames">list of behaviour instances names that will be started</param>
		public void StartBehaviours(params string[] behaviourNames)
		{
			foreach(string name in behaviourNames)
			{
				lock(this.behaviours)
				{
					foreach(AgentService.Agent.Behaviour.Behaviour deployedBehaviour in this.behaviours)
					{
						if(deployedBehaviour.Name.Equals(name))
						{
							this.scheduler.Start(deployedBehaviour);
							// REVIEW: design a new state for started?
							if (this.OnStartBehaviour != null)
								this.OnStartBehaviour(this, new BehaviourArgs(deployedBehaviour.GetType(), deployedBehaviour.Name, deployedBehaviour.State));
							break;
						}
					}
				}
			}	
		}

		/// <summary>
		/// Starts all the behaviour instances previously added.
		/// </summary>  
		public void StartAllBehaviours()
		{
			this.scheduler.StartAll();

			// REVIEW: design a new state for behaviour just started?

			if (this.OnStartBehaviour != null)
			{
				this.OnStartBehaviour(this, new BehaviourArgs(typeof(Behaviour.Behaviour), null, BehaviourState.Running));
			}
		}
        /// <summary>
        /// Kills all the threads and stops the agent
        /// as a result of the normal activity of the
        /// platform.
        /// </summary>
        public void Stop() 
        {
            this.Stop(false);
        }
		/// <summary>
		/// Kills all the threads belonging to the agent.
		/// </summary>
        /// <param name="bAbort">stop reason, if true the agent terminated abnormally</param>
		public void Stop(bool bAbort)
		{
            // in case of normal termination
            // we signal all the events as
            // normal
            if (bAbort == false)
            {
                // if the agent is persistent
                // the scheduler will not change
                // the state of behaviours
                this.scheduler.RemoveAll(this.bPersist == false);
                if (this.OnReleaseAgent != null)
                {
                    this.OnReleaseAgent(this.aid);
                }
                // MOD: Christian need to call this before dying.
                this.template.Terminate();

                // this.runtime.LogSvc.CloseSession(theis.GetHashCode());
                if (this.OnStopAgent != null)
                {
                    this.OnStopAgent(this.aid);
                }
            }
			this.Unbind();
            this.runtime.LogSvc.CloseSession(this.GetHashCode());
		}
		/// <summary>
		/// Releases all the resources 
		/// </summary>
		private void Unbind()
		{
			this.eventProxy.bForwardEvents = true;
            
			this.runtime.YPageSvc.UnbindEvents(this.eventProxy);
			this.runtime.WPageSvc.UnbindEvents(this.eventProxy);
			this.runtime.LogSvc.UnbindEvents(this.eventProxy);
			this.runtime.MessageSvc.UnbindEvents(this.eventProxy);
			this.runtime.PersistenceSvc.UnbindEvents(this.eventProxy);
			this.runtime.MessageSvc.OnIncomingConversation -= this.convHandler;
			this.eventProxy.bForwardEvents = false;
		}
		
		# endregion
		
		# region Manage Agent Knowledges

		/// <summary>
		/// Locks a knowledge instance to be used by a behaviour instance.
		/// </summary>
		/// <param name="lockingBehaviour">behaviour instance that wants to use the knowledge instances</param>
		/// <param name="myKnowledgeList">list of knowledge instancess to be locked</param>
		public void LockKnowledge(AgentService.Agent.Behaviour.Behaviour lockingBehaviour,params Knowledge.Knowledge[] myKnowledgeList)
		{
			lock(this.knowledges)
			{
				// check if behavior has already locked some knowledge for deadlock avoidance
				foreach(Knowledge.Knowledge k in this.knowledges)
				{
					if(k.IsLockedBy(lockingBehaviour))
					{
						throw new KnowledgeLockedException(k.Name);
					}
				}

				// search for the knowledge to be ordered and locked
				foreach(Knowledge.Knowledge kN in myKnowledgeList)
				{
					foreach(Knowledge.Knowledge know in this.knowledges)
					{
						if(know.Name.Equals(kN.Name))
						{
							if(!know.IsLocked)
							{
								know.Lock(lockingBehaviour);
								break;
							}
							else
							{
								lockingBehaviour.ReleaseKnowledge(true);
								throw new KnowledgeLockedException(know.Name);
							}
						}
					}
				}
			}
			
		}

		/// <summary>
		/// Persists the changes for a given Knowledge's item.
		/// </summary>
		///<param name="sender">knowledge object which fired the update event</param>
		public void PersistChanges(object sender)
		{
			Knowledge.Knowledge know = sender as Knowledge.Knowledge;
			if(know != null)
			{
				lock(this.knowledges)
				{
					if(this.knowledges.Contains(know))
					{
						this.runtime.PersistenceSvc.PersistKnowledge(know);
					}
				}
			}
			else
			{
				//TODO: log sender is null or is not a knowlegde
			}
		}

		/// <summary>
		/// Releases the knowledge instances previously locked by a behaviour instance.
		/// </summary>
		/// <param name="releaseBehaviour">behaviour instance that releases the Knowledge</param>
		public void ReleaseKnowledge(AgentService.Agent.Behaviour.Behaviour releaseBehaviour)
		{
			lock(this)
			{
				bool lockFlag = true;
				foreach(Knowledge.Knowledge know in this.knowledges)
				{
					if(know.IsLockedBy(releaseBehaviour))
					{
						know.UnLock();
						lockFlag = false;
						// Mettici il log
						//Console.WriteLine(String.Format("{0} : Resource {1} released by {2}", this.aid.Name, k.know.GetName(), releaseBehaviour.GetName()));
					}
				}
				if(lockFlag)
				{
					throw new KnowledgeUnlockedException(releaseBehaviour.Name);
				}
			}
		}

		# endregion
	}
}