/*********************************************************************/
/*                                                                   */
/*                     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 AgentService.Platform;
using AgentService.Platform.DF;
using AgentService.Platform.AMS;
using AgentService.Platform.MTS;
using AgentService.Platform.Modules;

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


namespace AgentService.Agent.Runtime
{
    /// <summary>
    /// Class AgentProxy. Proxy the agent class used
    /// for accessing software agent instances that 
    /// are located in another domain.
    /// </summary>
    public class AgentProxy : MarshalByRefObject,  IAgent
    {
        /// <summary>
        /// Constructor, creates an agentproxy and an Agent in it. It also bind it to Runtime
        /// </summary>
        /// <param name="bPersist">persistence flag, put true for persistent agents</param>
        /// <param name="TemplateName">full type name of the template that characterize the agent </param>
        /// <param name="assemblyFile">name of the assembly in which is the agent to Create</param>
        /// <param name="aid">agent identifier</param>
        /// <param name="plat">reference to the platform</param>
        /// <param name="mtsp">reference to the MTS</param>
        /// <param name="logp">reference to the LoggingModule</param>
        /// <param name="ypsp">reference to the YellowPagesServer</param>
        /// <param name="wpsp">reference to the WhitePagesServer</param>
        /// <param name="amsp">reference to the AMS</param>
        /// <returns>agent object</returns>

        public AgentProxy(bool bPersist, string TemplateName, string assemblyFile,AID aid, Platform.IPlatform plat, Platform.MTS.IMTSGateway mtsp, Platform.Modules.ILoggingModule logp, IYellowPagesServer ypsp, IWhitePagesServer wpsp, IAMS amsp)
        {
            try
            {
                this.platform = plat;
                this.mts = mtsp;
                this.log = logp;
                this.yps = ypsp;
                this.wps = wpsp;
                this.ams = amsp;
                string basedir = System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(assemblyFile));
                System.Reflection.Assembly assembly = System.Reflection.Assembly.LoadFrom(assemblyFile);

                object zombie = assembly.CreateInstance(TemplateName,
                                                        true,
                                                        System.Reflection.BindingFlags.CreateInstance,
                                                        null,
                                                        new object[0] { },
                                                        System.Globalization.CultureInfo.CurrentCulture,
                                                        null);
                AgentTemplate template = zombie as AgentTemplate;
                if (template != null)
                {
                    this.agent = new Agent(bPersist);
                    this.agent.SetTemplate(template);
                    this.agent.AID = aid;
                    this.Bind(null);
                    this.platform.Console.WriteLineMessage("Created agent [Name: " + aid.Name + "] in AppDomain [" + System.Threading.Thread.GetDomain().FriendlyName + "]");
                }
            }
            catch(Exception e)
            {
                // TODO: Fix with Debug.WriteLine("[AgentProxy]" + e.Message + "\n" + e.StackTrace);
                // System.Console.WriteLine("[AgentProxy]" + e.Message + "\n" + e.StackTrace);
                throw (e);
            }

        }


        #region Members

        /// <summary>
        /// the Agent in the Domain
        /// </summary>
        private IAgent agent;

        private Platform.MTS.IMTSGateway mts;

        private Platform.Modules.ILoggingModule log;

        private IYellowPagesServer yps;

        private IWhitePagesServer wps;

        private Platform.AMS.IAMS ams;

        private Platform.IPlatform platform;

        #region Agent Related events

        /// <summary>
        /// Thrown when the agent is activated.
        /// </summary>
        public event AgentDelegate OnActivateAgent
        {
            add
            {
                this.agent.OnActivateAgent += value;
            }
            remove
            {
                this.agent.OnActivateAgent -= value;
            }
        }

        /// <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
        {
            add
            {
                this.agent.OnReleaseAgent += value;
            }
            remove
            {
                this.agent.OnReleaseAgent -= value;
            }
        }

        /// <summary>
        /// thrown when the agent is stopped
        /// </summary>
        public event AgentDelegate OnStopAgent
        {
            add
            {
                this.agent.OnStopAgent += value;
            }
            remove
            {
                this.agent.OnStopAgent -= value;
            }
        }

        /// <summary>
        /// thrown when the agent terminates its execution
        /// </summary>
        public event AgentDelegate OnTerminateAgent
        {
            add
            {
                this.agent.OnTerminateAgent += value;
            }
            remove
            {
                this.agent.OnTerminateAgent -= value;
            }
        }

        /// <summary>
        /// thrown by a persistent agent, when its internal data 
        /// change
        /// </summary>
        public event PersistAgentDelegate OnPersistAgent
        {
            add
            {
                this.agent.OnPersistAgent += value;
            }
            remove
            {
                this.agent.OnPersistAgent -= value;
            }
        }

        #endregion

        #region Behaviour related events

        /// <summary>
        /// Fires every time a new behaviour is created.
        /// </summary>
        public event BehaviourDelegate OnNewBehaviour
        {
            add
            {
                this.agent.OnNewBehaviour += value;
            }
            remove
            {
                this.agent.OnNewBehaviour -= value;
            }
        }

        /// <summary>
        /// Fires every time a behaviour is started.
        /// </summary>
        public event BehaviourDelegate OnStartBehaviour
        {
            add
            {
                this.agent.OnStartBehaviour += value;
            }
            remove
            {
                this.agent.OnStartBehaviour -= value;
            }
        }
        /// <summary>
        /// Fires every time a behaviour is terminated.
        /// </summary>
        public event BehaviourDelegate OnTerminateBehaviour
        {
            add
            {
                this.agent.OnTerminateBehaviour += value;
            }
            remove
            {
                this.agent.OnTerminateBehaviour -= value;
            }
        }
        /// <summary>
        /// Fires every time a behaviour is suspended.
        /// </summary>
        public event BehaviourDelegate OnSuspendBehaviour
        {
            add
            {
                this.agent.OnSuspendBehaviour += value;
            }
            remove
            {
                this.agent.OnSuspendBehaviour -= value;
            }
        }
        /// <summary>
        /// Fires every time a behaviour is woken up.
        /// </summary>
        public event BehaviourDelegate OnWakeUpBehaviour
        {
            add
            {
                this.agent.OnWakeUpBehaviour += value;
            }
            remove
            {
                this.agent.OnWakeUpBehaviour -= value;
            }
        }

        #endregion

        #region IAgent Members

        public AID AID
        {
            get
            {
                return this.agent.AID;
            }
            set
            {
                this.agent.AID = value;
            }
        }

        public AgentState State
        {
            get
            {
                return this.agent.State;
            }
            set
            {
                this.agent.State = value;
            }
        }

        public bool IsPersistent
        {
            get
            {
                return this.agent.IsPersistent;
            }
        }

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

        public KnowledgeCollection Knowledges
        {
            get
            {
                return this.agent.Knowledges;
            }
        }

        /// <summary>
        /// Collection of Behaviour objects belonging to the Agent.
        /// </summary>		
        public BehaviourCollection Behaviours
        {
            get
            {
                return this.agent.Behaviours;
            }
        }

        /// <summary>
        /// Collection of Knowledge type objects handled by the agent.
        /// </summary>
        public TypeDescriptorCollection KnowledgeTypes
        {
            get
            {
                return this.agent.KnowledgeTypes;
            }
        }

        /// <summary>
        /// Collection of Behaviour type objects handled by the agent.
        /// </summary>
        public TypeDescriptorCollection BehaviourTypes
        {
            get
            {
                return this.agent.BehaviourTypes;
            }
        }

        /// <summary>
        /// Profile of the agent
        /// </summary>
        public AgentProfile Profile
        {
            get
            {
                return this.agent.Profile;
            }
        }

        /// <summary>
        /// Name of agent's config file
        /// </summary>
        public string ConfigFileName
        {
            get
            {
                return this.agent.ConfigFileName;
            }
        }

        #endregion

        #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)
        {
            this.agent.Initiate(configFile);
        }

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

        /// <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.agent.SetTemplate(template);
        }

        /// <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)
        {
            this.agent.CommitMove(bIsSourceInstance);
        }

        # 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(IRuntimeEx fake)
        {
            /* by now this function is not supported in AppDomain
            IMsgClient msgClient = null;
            if (this.platform.Messaging.HasClient == true)
            {
                msgClient = this.platform.Messaging.CreateClient(this.agent.AID);
            }
            else*/
            // Todo: think about that
            IMsgClient msgClient = new DefaultMsgClient(this.agent,this.mts);
            ILogClient logClient = new DefaultLogClient(this.agent.AID, this.log, this.agent.GetHashCode()); //this.platform.Logging.CreateClient(this.agent.AID, this.agent.GetHashCode());
            IPersistenceClient persistenceClient = new DefaultPersistenceClient();
            IYellowPagesClient ypClient = new DefaultYellowPagesClient(this.agent.AID, this.yps);
            IWhitePagesClient wpClient = new DefaultWhitePagesClient(this.agent.AID, this.wps);
            IAgentConsole platformConsole = this.platform.Console.BlackBoard;
            // CHANGE 30/01/2006: added support to the mobility client
            IMobilityClient mobilityClient = new DefaultMobilityClient(this.ams);
            ConsoleProxy console = new ConsoleProxy(this.agent.AID.Name, platformConsole);

            IRuntimeEx runtime = new DefaultRuntime(this.agent,
                msgClient,
                persistenceClient,
                logClient,
                ypClient, 
                wpClient,
                // CHANGE 30/01/2006: added support to the mobility client
                mobilityClient,
                console);
  					
            this.agent.Bind(runtime);

            // registers the platform to the agent events
            agent.OnPersistAgent += new PersistAgentDelegate(this.platform.persistAgent);
            agent.OnActivateAgent += new AgentDelegate(this.platform.onActivateAgent);
            agent.OnTerminateAgent += new AgentDelegate(this.platform.onTerminateAgent);
           
        }

        /// <summary>
        /// Loads agent data from its persisted version.
        /// </summary>
        /// <param name="agentPersistent">persisted version of the agent</param>
        public void ResumeFrom(AgentPersistent agentPersistent)
        {
            this.agent.ResumeFrom(agentPersistent);
        }

        /// <summary>
        /// Creates the persistent version of the agent.
        /// </summary>
        /// <returns>persisted version of the agent</returns>
        public AgentPersistent GetPersistent()
        {
            return this.agent.GetPersistent();
        }


        #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)
        {
            this.agent.SubmitBehaviour(behaviour, bStart);
        }

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

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

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

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

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

        /// <summary>
        /// Removes all behaviours instances.
        /// </summary> 
        public void RemoveAllBehaviours()
        {
            this.agent.RemoveAllBehaviours();
        }

        /// <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)
        {
            this.agent.StartBehaviours(behaviourNames);
        }

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

        /// <summary>
        /// Kills all the threads belonging to the agent.
        /// </summary>
        public void Stop()
        {
            this.agent.Stop();
        }
        /// <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)
        {
            this.agent.Stop(bAbort);
        }

        # 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(Behaviour.Behaviour lockingBehaviour, params Knowledge.Knowledge[] myKnowledgeList)
        {
            this.agent.LockKnowledge(lockingBehaviour, myKnowledgeList);
        }

        /// <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)
        {
            this.agent.PersistChanges(sender);
        }

        /// <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(Behaviour.Behaviour releaseBehaviour)
        {
            this.agent.ReleaseKnowledge(releaseBehaviour);
        }
        /// <summary>
        /// Finalizes the activity of the agent.
        /// </summary>
        public void Terminate()
        {
            this.agent = null;
        }

        # endregion
    }
}