/*********************************************************************/
/*                                                                   */
/*                     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 Microsoft.ObjectSpaces;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

using AgentService.Platform;



namespace AgentService.Agent.Knowledge
{
	/// <summary>
	/// Enum PersistenceMode. Defines the different modes used to persist Knowledge objects.
	/// </summary>
	public enum PersistenceMode
	{
		/// <summary>
		/// Knowledge is never persisted
		/// </summary>
		NotPersistent,
		
		/// <summary>
		/// Knowledge is persisted when the agent is persisted or manually
		/// </summary>
		Persistent,

		/// <summary>
		/// Knowledge is auto persisted on every update
		/// </summary>
		StrongPersistent
	}
	
	/// <summary>
	/// Delegate KnowledgeChangedDelegate. Handler for the OnPersistKnowledge event launched 
	/// by the Knowledge class.
	/// </summary>
	internal delegate void KnowledgeChangedDelegate(object sender); 

	/// <summary>
	/// Class Knowledge. A knowledge is a container of CLI types that are shared 
	/// among the behaviours of an agent and that are persisted against a stream.
	/// The class is abstract provides a common base for all knowledge objects.
	/// </summary>
    [Serializable()]
	public abstract class Knowledge:ISerializable
	{
		#region Members and Properties

		/// <summary>
		/// Collection of items that are contained in the knowledge
		/// </summary>
		private System.Collections.Hashtable items;

		/// <summary>
		/// Collection of temporary items used to access knowledge within an exclusive context
		/// </summary>
		private System.Collections.Hashtable tempItems;

		/// <summary>
		/// Knowledge string Identifier
		/// </summary>
		string name;
		/// <summary>
		/// Gets the name of the knowledge
		/// </summary>
		public string Name
		{
			get 
			{
				return name;
			}
		}		
		
		/// <summary>
		/// Name of the Agent that owns the knowledge
		/// </summary>
		internal string ownerName;

		/// <summary>
		/// locked flag
		/// </summary>
		private bool isLocked;
		/// <summary>
		/// Gets the locked flag
		/// </summary>
		public bool IsLocked 
		{
			get 
			{
				return this.isLocked;
			}
		}

		/// <summary>
		/// Persistence mode
		/// </summary>
		private PersistenceMode pMode;
		/// <summary>
		/// Gets the persistence mode
		/// </summary>
		public PersistenceMode Mode 
		{
			get 
			{
				return this.pMode;
			}
		}

		/// <summary>
		/// Event OnPersisrtKnowledge. Thrown by the knowledge object, when its internal items 
		/// change and the persistence mode is StrongPersistent
		/// </summary>
		internal event KnowledgeChangedDelegate OnPersistKnowledge;

		/// <summary>
		/// Reference to the behaviour instance that is locking the
		/// knowledge instance
		/// </summary>
		private Behaviour.Behaviour lockingBehaviour;

		#endregion

		# region Constructors

		/// <summary>
		/// Constructs a Knowledge object with no items,
		/// persistence mode is set to Persistent
		/// </summary>
		public Knowledge()
		{
			this.name = null;
			this.items = new System.Collections.Hashtable();
			this.pMode = PersistenceMode.Persistent;
			this.lockingBehaviour = null;
		}

		/// <summary>
		/// Costructs a Knowledge object with the given knowledge name and persistence mode
		/// </summary>
		/// <param name="knowledgeName">name of the knowledge object</param>
		/// <param name="pMode">persistence mode</param>
		public Knowledge(string knowledgeName, PersistenceMode pMode)
		{
			this.name = knowledgeName;
			this.items = new System.Collections.Hashtable();
			this.pMode = pMode;
			this.lockingBehaviour = null;
		}

		/// <summary>
		/// Costructs a Knowledge object with a given knowledge persistent object and agent owner name
		/// </summary>
		/// <param name="kp">persistent version of the knowledge</param>
		public Knowledge(KnowledgePersistent kp, string ownerName)
		{
			this.name = kp.Name;
			this.items = kp.Items;
			this.pMode = kp.Mode;
			this.lockingBehaviour = null;
			this.ownerName = ownerName;
		}

		/// <summary>
		/// Deserialization constructor
		/// </summary>
		/// <param name="info">SerializationInfo to populate with data</param>
		/// <param name="context">contextual information about the source or destination of the serialization</param>
		public Knowledge(SerializationInfo info, StreamingContext context) 
		{
			this.name = info.GetValue("name", typeof(string)) as string;
			this.items = info.GetValue("items", typeof(System.Collections.Hashtable)) as System.Collections.Hashtable;
			this.pMode = (PersistenceMode) info.GetValue("pMode", typeof(PersistenceMode));
		}
			
		/// <summary>
		/// Serialize the knowledge onto a sreaming context
		/// </summary>
		/// <param name="info">SerializationInfo to populate with data</param>
		/// <param name="context">contextual information about the source or destination of the serialization</param>
		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.AddValue("name", this.name);
			info.AddValue("items", this.items);
			info.AddValue("pMode", this.pMode);
		}

		#endregion

		# region Synch Methods 

		/// <summary>
		/// Tests if a Behaviour locks the Knowledge
		/// </summary>
		/// <param name="lockBehaviour">candidate Behaviour</param>
		/// <returns>True if the Knowledge is locked by the given Behaviour</returns>
		public bool IsLockedBy(Behaviour.Behaviour lockBehaviour)
		{
			lock(this) 
			{
				if( this.lockingBehaviour != null ) 
				{
					return this.lockingBehaviour.Name.Equals(lockBehaviour.Name);
				}
				return false;
			}
		}

		/// <summary>
		/// Locks the Knowledge for the given Behaviour
		/// </summary>
		/// <param name="lockBehaviour">locking Behaviour</param>
		internal void Lock(AgentService.Agent.Behaviour.Behaviour lockingBehaviour)
		{
			while(true)
			{
				lock(this)
				{
					if(!this.isLocked)
					{
						this.isLocked = true;
						this.lockingBehaviour = lockingBehaviour;
						this.tempItems = this.cloneItems(this.items);
						return;
					}
				}
				System.Threading.Thread.Sleep(100);
			}
			//Is the exception necessary?
			//throw new KnowledgeLockedException(this.Name);
		}

		/// <summary>
		/// Releases a knowledge previously locked. Throws KnowledgeUnlockedException if the knowledge was not locked.
		/// </summary>
		internal void UnLock()
		{
			lock(this)
			{
				if(this.isLocked)
				{
					this.isLocked = false;
					this.lockingBehaviour = null;
					this.tempItems = null; 
					return;
				}
			}
			// TODO: Log knowledge release
			// throw new KnowledgeUnlockedException(this.Name);
		}
		#endregion

		# region Knowledge Item Management

		/// <summary>
		/// Adds new item to knowledge
		/// </summary>
		/// <param name="itemIdentifier">string key used to access the knowldge item</param>
		/// <param name="typeName">type of the item</param>
		/// <param name="reference">reference to object that need to be stored whithin the knowledge</param>
		// TODO: lo facciamo attraverso un knowledgefactorycontext passato al costruttore (solito gioco dell'active) 
		protected void AddItem(string itemIdentifier, System.Type typeName, object reference)//string assemblyName,string objType,object[] args)
		{
			if (this.items.Contains(itemIdentifier))
			{
				throw new KnowledgeItemAlreadyExistException(itemIdentifier,this.name); 
			}
			this.items.Add(itemIdentifier, new KnowledgeItem(itemIdentifier,typeName,reference));
		}

		/// <summary>
		/// Retrieves all the item's identifiers
		/// </summary>
		/// <returns>The list of item's identifiers</returns>
		public string[] GetItemsId()
		{
			lock(this)
			{
				string[] itemIds = new string[this.items.Count];
				this.items.Keys.CopyTo(itemIds,0);
				return itemIds;
			}
		}

		/// <summary>
		/// Updates changes in the knowledge items
		/// </summary>
		/// <param name="lockBehaviour"></param>
		public void Update(Behaviour.Behaviour lockBehaviour)
		{
			lock(this)
			{
				if(this.IsLockedBy(lockBehaviour))
				{
					this.items = this.cloneItems(this.tempItems);
					if(this.Mode == PersistenceMode.StrongPersistent)
					{
						this.OnPersistKnowledge(this);
					}
				}
				else
				{
                    // MOD: 7/6/2006 Christian Vecchiola - added throw exception
                    throw new KnowledgeUnlockedException(this.name);
				}
			}
		}
	
		/// <summary>
		/// Knowledge indexer. Gets the instance associated to the given item identifier
		/// </summary>
		public object this[string itemId, Behaviour.Behaviour behaviour]
		{
			get
			{
				if(this.lockingBehaviour == behaviour)
				{
					KnowledgeItem item = this.tempItems[itemId] as KnowledgeItem;
					return item.instance;
				}
                // MOD: 7/6/2006 Christian Vecchiola - added throw exception
                throw new KnowledgeAccessException(this.name);
			}
			set
			{
                if (this.lockingBehaviour == behaviour)
                {
                    KnowledgeItem item = this.tempItems[itemId] as KnowledgeItem;
                    item.instance = value;
                }
                else
                {
                    // MOD: 7/6/2006 Christian Vecchiola - added throw exception
                    throw new KnowledgeAccessException(this.name);
                }
			}
		}

		/// <summary>
		/// Clones the given hashtable
		/// </summary>
		/// <param name="original">hashtable "source" object</param>
		/// <returns>cloned hashtable</returns>
		private System.Collections.Hashtable cloneItems(System.Collections.Hashtable original)
		{

			System.IO.MemoryStream ms = new System.IO.MemoryStream();
			BinaryFormatter bf = new BinaryFormatter();
            bf.Binder = new AgentService.Platform.ASBinder();
			bf.Serialize(ms,original);
			ms.Position = 0;
			System.Collections.Hashtable copy = bf.Deserialize(ms) as System.Collections.Hashtable;
			
			return copy;
			
            /* MOD: 7/6/200 Christian Vecchiola switched to cloned items
              
			return original;
            */
		}
		# endregion

		#region Persistence

		/// <summary>
		/// Gets the persistent version of the knowledge 
		/// </summary>
		/// <returns>persistent version of the knowledge</returns>
		public KnowledgePersistent GetPersistent() 
		{
			KnowledgePersistent persistent = new KnowledgePersistent(this.name, this.items);
			persistent.Mode = this.pMode;
			persistent.TypeName = this.GetType().FullName;

			return persistent;
		}


		/// <summary>
		/// Resumes a knowledge object from a persisted version
		/// </summary>
		/// <param name="kp">persisted version of the knowledge</param>
		public void ResumeFrom(KnowledgePersistent kp) 
		{
			this.items = kp.Items;
			this.name = kp.Name;
			this.pMode = kp.Mode;
		}

		#endregion
	}

}