/*********************************************************************/
/*                                                                   */
/*                     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;

namespace AgentService.Platform.Modules 
{

    /// <summary>
    /// Class ObjectDescription. It gives a description of the types
    /// needed to instantiate an Object object
    /// </summary>
    [Serializable]
    [DataContract]
    public class TypeDescriptor : ICloneable
    {
        /// <summary>
        /// Object full type name
        /// </summary>
        private string fullTypeName;
        /// <summary>
        /// Get object full type name
        /// </summary>
        [DataMember]
        public string FullTypeName
        {
            get
            {
                return this.fullTypeName;
            }
            set
            {
                this.fullTypeName = value;
            }
        }

        /// <summary>
        /// Object full base type name
        /// </summary>
        private string baseTypeName;
        /// <summary>
        /// Get object full base type name
        /// </summary>
        [DataMember]
        public string BaseTypeName
        {
            get
            {
                return this.baseTypeName;
            }
            set
            {
                this.baseTypeName = value;
            }
        }

        /// <summary>
        /// Name of the assembly containing the object definition
        /// </summary>
        private string assemblyName;
        /// <summary>
        /// Get the name of the assembly containing the object definition
        /// </summary>
        [DataMember]
        public string AssemblyName
        {
            get
            {
                return this.assemblyName;
            }
            set
            {
                this.assemblyName = value;
            }
        }
        /// <summary>
        /// Stores the public key token for
        /// fast comparisons.
        /// </summary>
        private ulong fastPublicKeyToken;
        /// <summary>
        /// Gets the public key token of the
        /// assembly containing the type.
        /// </summary>
        [DataMember]
        public ulong PublicKeyToken 
        {
            get 
            {
                return this.fastPublicKeyToken;
            }
            set 
            {
                this.fastPublicKeyToken = value;
            }
        }
        /// <summary>
        /// Public key token of the assembly containing the object definition
        /// </summary>
        //		private byte[] publicKeyToken;
        //		/// <summary>
        //		/// Get the public key token of the assembly containing the object definition
        //		/// </summary>
        //		public byte[] PublicKeyToken
        //		{
        //			get
        //			{
        //				return this.publicKeyToken;
        //			}
        //		}

        /// <summary>
        /// Default constructor: needed for binary serialization
        /// </summary>
        public TypeDescriptor()
        {
            //	this.publicKeyToken = null;
            this.fastPublicKeyToken = 0;
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="fullTypeName">full type name of the Object</param>
        /// <param name="baseTypeName">full base type name of the Object</param>
        /// <param name="assemblyName">name of the assembly containing Object's definition</param>
        /// <param name="pkt">public key token of the assembly containing Object's definition</param>
        public TypeDescriptor(string fullTypeName, string assemblyName, byte[] pkt)
        {
            this.fullTypeName = fullTypeName;
            this.assemblyName = assemblyName;
            this.baseTypeName = null;
            //this.publicKeyToken = pkt;

            this.ComputeFastPKT(pkt);
        }

        /// <summary>
        /// Constructs a TypeDescriptor with the given parameters
        /// </summary>
        /// <param name="fullTypeName">full type name</param>
        /// <param name="assemblyName">assembly file name</param>
        /// <param name="publicKeyToken">pubic key token</param>
        public TypeDescriptor(string fullTypeName, string assemblyName, ulong publicKeyToken) 
        {
            this.fullTypeName = fullTypeName;
            this.assemblyName = assemblyName;
            this.baseTypeName = null;
            this.fastPublicKeyToken = publicKeyToken;
        }
        /// <summary>
        /// Constructs a TypeDescriptor object for the given type.
        /// </summary>
        /// <param name="type">type object</param>
        public TypeDescriptor(Type type)
        {
            System.Reflection.AssemblyName name = type.Assembly.GetName();
            this.fullTypeName = type.FullName;
            this.baseTypeName = type.BaseType.FullName;
            this.assemblyName = name.Name;
            //this.publicKeyToken = name.GetPublicKeyToken();

            this.ComputeFastPKT(name.GetPublicKeyToken());

        }
        /// <summary>
        /// Compares two TypeDescriptor objects for equality.
        /// Two TypeDescriptor are equal if they have the same
        /// full type name, the same assembly name, and the
        /// same public key token
        /// </summary>
        /// <param name="obj">type descriptor instance</param>
        /// <returns>true if the two instances have the same properties</returns>
        public override bool Equals(object obj)
        {
            TypeDescriptor td = obj as TypeDescriptor;
            if (td == null)
            {
                return false;
            }

            return ((td.fullTypeName.CompareTo(this.fullTypeName) == 0) &&
                    (td.baseTypeName.CompareTo(this.baseTypeName) == 0) &&
                    (td.assemblyName.CompareTo(this.assemblyName) == 0) &&
                    (td.fastPublicKeyToken == this.fastPublicKeyToken));

        }

        ///<summary>
        /// Returns the hash code for this instance.
        ///</summary>
        ///<returns>A 32-bit signed integer hash code.</returns>
        public override int GetHashCode()
        {
            return (this.fullTypeName.GetHashCode() *
                    this.BaseTypeName.GetHashCode() *
                    this.assemblyName.GetHashCode() *
                    this.fastPublicKeyToken.GetHashCode());
        }
        /// <summary>
        /// Copies the public key token and puts
        /// it into unsigned long variable. The 
        /// layout of the key is the following:
        /// pkt[0] = msb, pkt[7] = lsb.
        /// </summary>
        private void ComputeFastPKT(byte[] publicKeyToken)
        {
            if ((publicKeyToken == null) || (publicKeyToken.Length == 0))
            {
                this.fastPublicKeyToken = 0;
            }
            else
            {
                for (int ndx = 7; ndx >= 0; ndx--)
                {
                    ulong shift = (ulong)(ndx * 8);
                    this.fastPublicKeyToken |= (ulong)publicKeyToken[ndx] * shift;
                }
            }
        }

        #region ICloneable Members
        /// <summary>
        /// Clones a TypeDescriptor instance.
        /// </summary>
        /// <returns>cloned instance</returns>
        public object Clone()
        {
            TypeDescriptor td = new TypeDescriptor();
            td.fastPublicKeyToken = this.fastPublicKeyToken;
            td.fullTypeName = this.fullTypeName;
            td.baseTypeName = this.baseTypeName;
            td.assemblyName = this.assemblyName;

            return td;
        }

        #endregion
    }

    /// <summary>
    /// Class FieldDescriptor. Describes the information
    /// concerning a field of a class. It merely stores the
    /// type and the name of a field.
    /// </summary>
    [Serializable]
    [DataContract]
    public class FieldDescriptor
    {
        /// <summary>
        /// field name
        /// </summary>
        private string name;
        /// <summary>
        /// gets the field name
        /// </summary>
        [DataMember]
        public string Name
        {
            get
            {
                return this.name;
            }
            set
            {
                this.name = value;
            }
        }

        /// <summary>
        /// Indicates the access type of the field
        /// </summary>
        [Flags]
        public enum AccessType
        {
            ReadOnly = 1,
            WriteOnly = 2,
            ReadWrite = ReadOnly | WriteOnly
        }

        private AccessType accessType;
        [DataMember]
        public AccessType Access
        {
            get
            {
                return this.accessType;
            }
            set
            {
                this.accessType = value;
            }
        }

        /// <summary>
        /// description of the type of the field.
        /// </summary>
        private TypeDescriptor type;
        /// <summary>
        /// Gets the descriptor object of the
        /// type of the field.
        /// </summary>
        [DataMember]
        public TypeDescriptor Type
        {
            get
            {
                return this.type;
            }
            set
            {
                this.type = value;
            }
        }

        public FieldDescriptor() { }

        /// <summary>
        /// Constructs a FieldDescriptor of a field.
        /// </summary>
        /// <param name="name">field name</param>
        /// <param name="type">descriptor object of the the type of the field</param>
        public FieldDescriptor(string name, TypeDescriptor type, AccessType act)
        {
            if (name == null)
                throw new ArgumentNullException("name", "field name cannot be null");
            this.name = name;
            if (type == null)
                throw new ArgumentNullException("type", "type descriptor cannot be null");
            this.type = type;
            this.accessType = act;
        }
        /// <summary>
        /// Constructs a FieldDescriptor of a field.
        /// </summary>
        /// <param name="name">field name</param>
        /// <param name="type">type object of the the type of the field</param>
        public FieldDescriptor(string name, Type type, AccessType act)
        {
            if (name == null)
                throw new ArgumentNullException("name", "field name cannot be null");
            this.name = name;
            if (type == null)
                throw new ArgumentNullException("type", "type information cannot be null");
            this.type = new TypeDescriptor(type);
            this.accessType = act;
        }

        /// <summary>
        /// Compares two field descriptors. A field descriptor
        /// is equivalent to another if they have the same name
        /// and the same type and the same access type.
        /// </summary>
        /// <param name="obj">object to compare to</param>
        /// <returns>true if the two fields have the same name 
        /// and the same type descriptor and the same access type</returns>
        public override bool Equals(object obj)
        {
            FieldDescriptor field = obj as FieldDescriptor;
            if (field != null)
            {
                return ((this.name == field.name) && (this.type == field.type) && (this.accessType == field.Access));
            }
            return false;
        }

        ///<summary>
        /// Returns the hash code for this instance.
        ///</summary>
        ///<returns>A 32-bit signed integer hash code.</returns>
        public override int GetHashCode()
        {
            return (this.accessType.GetHashCode() *
                    this.name.GetHashCode() *
                    this.type.GetHashCode());
        }
    }

    /// <summary>
    /// Class AgentTemplateDescriptor. Describes the structure
    /// of an AgentTemplate derived class. It holds the information
    /// about the knowledge and behaviour types used by this template.
    /// </summary>
    [Serializable]
    [DataContract]
    public class AgentTemplateDescriptor : TypeDescriptor
    {
        /// <summary>
        /// array of knowledge types used by this template
        /// </summary>
        private KnowledgeDescriptor[] knowledges;
        /// <summary>
        /// Gets the array of the knowledge types used
        /// by this template.
        /// </summary>
        [DataMember]
        public KnowledgeDescriptor[] Knowledges
        {
            get
            {
                return this.knowledges;
            }
            set
            {
                this.knowledges = value;
            }
        }
        /// <summary>
        /// array of behaviour types used by this template
        /// </summary>
        private BehaviourDescriptor[] behaviours;
        /// <summary>
        /// Gets the array of behaviour types used by this
        /// template.
        /// </summary>
        [DataMember]
        public BehaviourDescriptor[] Behaviours
        {
            get
            {
                return this.behaviours;
            }
            set
            {
                this.behaviours = value;
            }
        }

        public AgentTemplateDescriptor() : base() { }

        /// <summary>
        /// Constructs an AgentTemplateDescriptor instance.
        /// </summary>
        /// <param name="name">template full type name</param>
        /// <param name="assembly">template defining assembly</param>
        /// <param name="knowledges">array of knowledge types used by this template</param>
        /// <param name="behaviours">array of behaviour types used by this template</param>
        public AgentTemplateDescriptor(string name, string assembly, string basename, KnowledgeDescriptor[] knowledges, BehaviourDescriptor[] behaviours)
            : base(name, assembly, 0)
        {
            this.knowledges = (knowledges == null ? new KnowledgeDescriptor[0] : knowledges);
            this.behaviours = (behaviours == null ? new BehaviourDescriptor[0] : behaviours);
        }

        /// <summary>
        /// Constructs an AgentTemplateDescriptor instance.
        /// </summary>
        /// <param name="type">template type information</param>
        /// <param name="knowledges">array of knowledge types used by this template</param>
        /// <param name="behaviours">array of behaviour types used by this template</param>
        public AgentTemplateDescriptor(Type type, KnowledgeDescriptor[] knowledges, BehaviourDescriptor[] behaviours)
            : base(type)
        {
            this.knowledges = (knowledges == null ? new KnowledgeDescriptor[0] : knowledges);
            this.behaviours = (behaviours == null ? new BehaviourDescriptor[0] : behaviours);
        }

        /// <summary>
        /// Constructs an AgentTemplateDescriptor instance.
        /// </summary>
        /// <param name="type">template type descriptor information</param>
        /// <param name="knowledges">array of knowledge types used by this template</param>
        /// <param name="behaviours">array of behaviour types used by this template</param>
        public AgentTemplateDescriptor(TypeDescriptor type, KnowledgeDescriptor[] knowledges, BehaviourDescriptor[] behaviours)
            : base(type.FullTypeName, type.AssemblyName,type.PublicKeyToken)
        {
            this.knowledges = (knowledges == null ? new KnowledgeDescriptor[0] : knowledges);
            this.behaviours = (behaviours == null ? new BehaviourDescriptor[0] : behaviours);
        }

    }

    /// <summary>
    /// Class KnowledgeDescriptor. Holds information about
    /// the fields of a knowledge instance.
    /// </summary>
    [Serializable]
    [DataContract]
    public class KnowledgeDescriptor : TypeDescriptor
    {
        /// <summary>
        /// knowledge fields array
        /// </summary>
        private FieldDescriptor[] items;
        /// <summary>
        /// Gets the knowledge fields array.
        /// </summary>
        [DataMember]
        public FieldDescriptor[] Items
        {
            get
            {
                return this.items;
            }
            set
            {
                this.items = value;
            }
        }

        public KnowledgeDescriptor() : base() { }

        /// <summary>
        /// Constructs a KnowledgeDescriptor instance.
        /// </summary>
        /// <param name="name">knowledge type full name</param>
        /// <param name="assembly"></param>
        /// <param name="items"></param>
        public KnowledgeDescriptor(string name, string assembly, FieldDescriptor[] items)
            : base(name, assembly, 0)
        {
            if (items == null)
                throw new ArgumentNullException("items", "knowledge field array cannot be null");
            this.items = items;
        }

        /// <summary>
        /// Constructs a KnowledgeDescriptor instance.
        /// </summary>
        /// <param name="type">knowledge type informatino</param>
        /// <param name="items">array of knowledge item descriptors</param>
        public KnowledgeDescriptor(Type type, FieldDescriptor[] items)
            : base(type)
        {
            if (items == null)
                throw new ArgumentNullException("items", "knowledge field array cannot be null");
            this.items = items;
        }

        /// <summary>
        /// Constructs a KnowledgeDescriptor instance.
        /// </summary>
        /// <param name="type">knowledge type descriptor information</param>
        /// <param name="items">array of knowledge item descriptors</param>
        public KnowledgeDescriptor(TypeDescriptor type, FieldDescriptor[] items)
            : base(type.FullTypeName, type.AssemblyName, type.PublicKeyToken)
        {
            if (items == null)
                throw new ArgumentNullException("items", "knowledge field array cannot be null");
            this.items = items;
        }


    }

    /// <summary>
    /// Class BehaviourDescriptor. Describes a particular behaviour type 
    /// and the knowledges it uses.
    /// </summary>
    [Serializable]
    [DataContract]
    public class BehaviourDescriptor : TypeDescriptor
    {
        /// <summary>
        /// array of knowlege field references used
        /// </summary>
        private FieldDescriptor[] knowledges;
        /// <summary>
        /// Gets the array of the knowledge reference
        /// fields used by this behaviour.
        /// </summary>
        [DataMember]
        public FieldDescriptor[] Knowledges
        {
            get
            {
                return this.knowledges;
            }
            set
            {
                this.knowledges = value;
            }
        }

        public BehaviourDescriptor() : base() { }

        /// <summary>
        /// Constructs a BehaviourDescriptor instance.
        /// </summary>
        /// <param name="name">behaviour type full name</param>
        /// <param name="assembly">behaviour type defining assembly</param>
        /// <param name="items">array of knowledge reference fields used by this behaviour</param>
        public BehaviourDescriptor(string name, string assembly, FieldDescriptor[] knowledges)
            : base(name, assembly, 0)
        {
            this.knowledges = (knowledges == null ? new FieldDescriptor[0] : knowledges);
        }

        /// <summary>
        /// Constructs a BehaviourDescriptor instance.
        /// </summary>
        /// <param name="type">behaviour type information</param>
        /// <param name="items">array of knowledge reference fields used by this behaviour</param>
        public BehaviourDescriptor(Type type, FieldDescriptor[] knowledges)
            : base(type)
        {
            this.knowledges = (knowledges == null ? new FieldDescriptor[0] : knowledges);
        }

        /// <summary>
        /// Constructs a BehaviourDescriptor instance.
        /// </summary>
        /// <param name="type">behaviour type descriptor</param>
        /// <param name="items">array of knowledge reference fields used by this behaviour</param>
        public BehaviourDescriptor(TypeDescriptor type, FieldDescriptor[] knowledges)
            : base(type.FullTypeName, type.AssemblyName, type.PublicKeyToken)
        {
            this.knowledges = (knowledges == null ? new FieldDescriptor[0] : knowledges);
        }

    }


}