/*********************************************************************/
/*                                                                   */
/*                     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.Runtime.Serialization;

using AgentService.Platform.AMS;


namespace AgentService.Platform.MTS
{
	/// <summary>
	/// Enum MessageType. Defines the message types used by the AgentMessage class.
	/// ServiceMessage (-1) : Service messages used to set up and close conversations.
	/// SimpleMessage (0) : Simple messages that do not need a conversation.
	/// Greater than SimpleMessage (>0) : the message is bound to a conversation.
	/// </summary>
    [DataContract]
	public enum MessageType 
	{
		/// <summary>
		/// Service messages, not intended for the users (ie: conversation set up, closing etc..)
		/// </summary>
        [EnumMember]
        ServiceMessage = -1,//string "ServiceMessage"
		/// <summary>
		/// Simple messages that do not need a conversation
		/// </summary>
        [EnumMember]
        SimpleMessage = 0 //string "SimpleMessage"
	}

	/// <summary>
	/// Class AgentMessage. Defines the structure of a message exchanges among agents.
	/// </summary>
    [Serializable]
    [DataContract]
	public class AgentMessage/*: ISerializable*/
	{	
		/// <summary>
		/// The message envelope description
		/// </summary>	
		protected MessageEnvelope envelope;
		/// <summary>
		/// Gets the envelope of the message
		/// </summary>
        [DataMember]
		public MessageEnvelope Envelope
		{
			get
			{
				return this.envelope;
			}
            set
            {
                envelope = value;
            }		
		}

		/// <summary>
		/// The body part of the message
		/// </summary>
		protected MessageBody body;
		/// <summary>
		/// Gets the body part of the message
		/// </summary>
        [DataMember]
		public MessageBody Body
		{
			get
			{
				return this.body;
			}
			set
			{
				if(value!=null)
				{
					this.body = value;
				}
				//TODO: throw InvalidOperatorException?
				//		message: Cannot set body to null!
			}
		}

		/// <summary>
		/// The identifier of the conversation message belonging to
		/// </summary>
		internal string conversationId;
		/// <summary>
		/// Gets the number identifying the conversation message belongs to
		/// </summary>
        [DataMember]
		public string ConversationId
		{
			get
			{
				return this.conversationId;
			}

            set
            {
                this.conversationId = value;
            }
		}
		
		/// <summary>
		/// Constructs an AgentMessage object.
		/// </summary>
		public AgentMessage()
		{
			this.body = new MessageBody();
			this.envelope = new MessageEnvelope();
			this.conversationId = "SimpleMessage";
		}
		
		/// <summary>
		/// Constructs an AgentMessage object with the given receivers,acl, date time, body part, and conversation number.
		/// </summary>
		/// <param name="sender">The name of the agent who actually sent the message</param>
		/// <param name="acl">The name of the syntax representation of the message body</param>
		/// <param name="body">The body part of the message</param>
		/// <param name="receivers">The names of the primary recipients of the message</param>
		public AgentMessage(string acl,MessageBody body,params AID[] receivers)
		{
			if(receivers.Length == 0)
			{
				//todo: thinks about exception
			}
			this.envelope = new MessageEnvelope(acl,receivers);
			this.body = body;
            this.conversationId = "SimpleMessage";
		}

		/// <summary>
		/// Constructs an AgentMessage object with the given envelope, body part, and conversation number
		/// </summary>
		/// <param name="envelope">envelop of the message</param>
		/// <param name="body">body part of the message</param>
		/// <param name="conversationId">conversation identifier</param>
		public AgentMessage(MessageEnvelope envelope, MessageBody body, string conversationId)
		{
			this.envelope = envelope;
			this.body = body;
			this.conversationId = conversationId;
		}

		/// <summary>
		/// Creates a reply message to the sender
		/// </summary>
		/// <param name="copyBody">if true copies the body into the reply message, 
		///	false body's reply message empty</param>
		/// <returns>reply message</returns>
		public AgentMessage Reply(bool copyBody)
		{
			MessageEnvelope envelope = new MessageEnvelope(this.envelope.AclRepresentation,this.envelope.From);
			AgentMessage msg = new AgentMessage(envelope,new MessageBody(),this.conversationId);
			
			if(copyBody == true)
			{
				foreach(MessageBodyItem mbi in this.body)
				{
					msg.body.Add(mbi.Identifier,mbi.Instance);
				}
			}
			return msg;
		}
        /// <summary>
        /// Creates a reply message to the sender and all the receivers
        /// </summary>
        /// <param name="copyBody">if true copies the body into the reply message, 
        ///	false body's reply message empty</param>
        /// <returns>reply message</returns>
        public AgentMessage Reply(bool copyBody, AID aid)
        {
            int count = this.envelope.To.Count;
            AID[] receivers = new AID[count];
            receivers[0] = this.Envelope.From;
            int ndx = 1;

            for (int i = 0; i < count; i++)
            {
                AID rAid = this.Envelope.To[i];
                if (rAid.Name.Equals(aid.Name) == false)
                {
                    receivers[ndx] = rAid;
                    ndx++;
                }
            }

            MessageEnvelope envelope = new MessageEnvelope(this.envelope.AclRepresentation, receivers);
            AgentMessage msg = new AgentMessage(envelope, new MessageBody(), this.conversationId);

            if (copyBody == true)
            {
                foreach (MessageBodyItem mbi in this.body)
                {
                    msg.body.Add(mbi.Identifier, mbi.Instance);
                }
            }
            return msg;
        }
        /// <summary>
        /// Creates a reply message to the sender and sets the given message
        /// body for the response.
        /// </summary>
        /// <param name="body">message response body</param>
        /// <returns>reply message</returns>
        public AgentMessage Reply(MessageBody body)
        {
            MessageEnvelope envelope = new MessageEnvelope(this.envelope.AclRepresentation, this.envelope.From);
            AgentMessage msg = new AgentMessage(envelope, body, this.conversationId);

            return msg;
        }
        /// <summary>
        /// Creates a reply message to the sender and all the receivers.
        /// </summary>
        /// <param name="body">message response body</param>
        /// <param name="aid">sender aid</param>
        /// <returns>reply message</returns>
        public AgentMessage Reply(AID aid, MessageBody body)
        {
            int count = this.envelope.To.Count;
            AID[] receivers = new AID[count];
            receivers[0] = this.Envelope.From;
            int ndx = 1;

            for (int i = 0; i < count; i++)
            {
                AID rAid = this.Envelope.To[i];
                if (rAid.Name.Equals(aid.Name) == false)
                {
                    receivers[ndx] = rAid;
                    ndx++;
                }
            }

            MessageEnvelope envelope = new MessageEnvelope(this.envelope.AclRepresentation, receivers);
            AgentMessage msg = new AgentMessage(envelope, body, this.conversationId);

            return msg;
        }
 		/// <summary>
		/// Deserialization Constructor.
		/// </summary>
		/// <param name="info">SerializeInfo</param>
		/// <param name="context">The context in which deserializing</param>
		public AgentMessage(SerializationInfo info, StreamingContext context) 
		{
			this.envelope = (MessageEnvelope)info.GetValue("envelope", typeof(MessageEnvelope));
			this.body = (MessageBody)info.GetValue("body", typeof(MessageBody));
			this.conversationId = (string)info.GetValue("conversationId",typeof(string));
		}
			
		/// <summary>
		/// Serialization function.
		/// </summary>
		/// <param name="info">SerializeInfo</param>
		/// <param name="context">The context in which deserializing</param>
		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
            Console.WriteLine("GETOBJECTDATA CHIAMATA");
			info.AddValue("envelope", envelope);
			info.AddValue("body", body);
			info.AddValue("conversationId",conversationId);
		}

		/// <summary>
		/// Checks if the message is coming from
		/// the specified agent.
		/// </summary>
		/// <param name="sender">supposed sender</param>
		/// <returns>true if the message comes from the specified sender</returns>
		public bool IsFrom(AID sender) 
		{
			return this.envelope.From.Equals(sender);
		}
		/// <summary>
		/// Checks if the message's envelope Contains
		/// the given comment.
		/// </summary>
		/// <param name="comment">comment</param>
		/// <returns>true, if the comments section of the 
		/// envelop Contains the given comment</returns>
		public bool HasComment(string comment)
		{
			return this.envelope.Comments.Contains(comment);
		}

		/// <summary>
		/// Checks for object comparison.
		/// </summary>
		/// <param name="obj">other object</param>
		/// <returns>true if the two messages have the same envelope. 
		/// Comparison if performed by looking at the envelope hashcodes.
		/// </returns>
		public override bool Equals(object obj)
		{
			AgentMessage msg = obj as AgentMessage;
            //MOD: 06/04/2006: Marco Garr changed from date.GetHashcode() to date==
            //                  because with AppDomain we need to check the value
            //                  and no more the reference. Added the conversationId 
            //                  for a strong check. 
			return (((this.envelope.date) == (msg.envelope.date)) && (this.conversationId==msg.conversationId));
		}
        /// <summary>
        /// Gets the hash code for this AgentMessage instance.
        /// </summary>
        /// <returns>message date hash code</returns>
        public override int GetHashCode()
        {
            return this.envelope.date.GetHashCode();
        }

	}
}