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


namespace AgentService.Agent.Runtime
{
    class AMSProxy: MarshalByRefObject, IAMS
    {
        # region Members

        /// <summary>
        /// Reference to the platform AMS
        /// </summary>
        private IAMS ams;

        /// <summary>
        /// Gets a copy of the collection of agents registered with the ams
        /// </summary>
        public AgentDescriptionCollection RegisteredAgents
        {
            get
            {
                return this.ams.RegisteredAgents;
            }
        }

        /// <summary>
        /// Gets the White Pages service.
        /// </summary>
        public IWhitePagesServer WhitePages
        {
            get
            {
                return this.ams.WhitePages;
            }
        }

        # endregion

        #region Constructor

        /// <summary>
        /// AMSProxy Constructor. Set the ams reference to the passed object
        /// </summary>
        /// <param name="obj">the AMS to be referenced</param>
        public AMSProxy(IAMS obj)
        {
            this.ams = obj;
        }
        #endregion

        # region Manage Agent SetUp and Registration

        /// <summary>
        /// Initites and register the created agent with the AMS.
        /// </summary>
        /// <param name="agent">Agent.</param>
        /// <param name="configFile">the configfile of the Agent</param>
        /// <param name="param">List of value to inizialize Agent's attribute</param>
        /// <param name="bPersist">persistence flag</param>
        /// <param name="bDomain">domain flag</param>
        /// <param name="domainName"></param>
        public void Register(AgentService.Agent.IAgent agent, string configFile, bool bPersist)
        {
            this.ams.Register(agent, configFile, bPersist);
        }

        /// <summary>
        /// Starts agent activity
        /// </summary>
        /// <param name="aid">agent identifier to be started</param>
        public void Activate(AID aid)
        {
            this.ams.Activate(aid);
        }

        /// <summary>
        /// Starts the activity of all the registered agents
        /// </summary>
        public void ActivateAll()
        {
            this.ams.ActivateAll();
        }

        /// <summary>
        /// Puts the agent in the previous persisted state.
        /// </summary>
        /// <param name="agent">Agent.</param>
        public void Resume(AgentService.Agent.IAgent agent)
        {
            this.ams.Resume(agent);
        }


        /// <summary>
        /// Deregister a specific Agent. Deregistration
        /// implies the removal of the agent object from 
        /// the collection of managed agents
        /// </summary>
        /// <param name="aid">The Agent's AID</param>
        public bool Deregister(AID aid, bool bDestroy)
        {
            return this.ams.Deregister(aid, bDestroy);
        }


        # endregion

        #region Override

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


        #endregion

        # region Manage Agent State

        /// <summary>
        /// Put Agent in active state after transition
        /// </summary>
        /// <param name="agent">The persisted version of the agent</param>
        public void Execute(AID aid)
        {
            this.ams.Execute(aid);
        }

        // MOD: 21/07/2006 Simone Belotti: changed the Move method to support timeout value 
        /// <summary>
        /// Put Agent in the transit state before its migration
        /// </summary>
        /// <param name="aid">The Agent's AID</param>
        /// <param name="destination">The name of the destination platform</param>
        /// <param name="isSystemRequest">Flag that indicates if the request to move
        ///								  the agent was originated by the platform
        ///								  (i.e. load balancing motivation), or it 
        ///								  was originated by the agent itself</param>
        public void Move(AID aid, string destination,TimeSpan timeout, bool bIsSystemRequest)
        {
            this.ams.Move(aid, destination,timeout, bIsSystemRequest);
        }

        /// <summary>
        /// Put the Agent in the active state after its suspention
        /// </summary>
        /// <param name="aid">The Agent's AID</param>
        /// <returns>true if operation succeds</returns>
        public bool ResumeAgent(AID aid)
        {
            return this.ams.ResumeAgent(aid);
        }

        /// <summary>
        /// Puts Agent in the suspended state
        /// </summary>
        /// <param name="aid">The Agent's AID</param>
        /// <returns>true if operation succeds</returns>
        public bool Suspend(AID aid)
        {
            return this.ams.Suspend(aid);
        }

        /// <summary>
        /// Suspends all the active agents
        /// </summary>
        public void SuspendAll()
        {
            this.ams.SuspendAll();
        }

        /// <summary>
        /// Stops the agent activity
        /// </summary>
        /// <param name="aid">agent identifier</param>
        /// <returns></returns>
        public bool StopAgent(AID aid)
        {
            return this.ams.StopAgent(aid);
        }

        /// <summary>
        /// Kill the Agent putting it in the unknown state
        /// </summary>
        /// <param name="aid">the Agent's AID</param>
        /// <returns>true if operation succeds</returns>
        public bool Destroy(AID aid)
        {
            return this.ams.Destroy(aid);
        }

        /// <summary>
        /// Kill all agents putting it in the unknown state
        /// </summary>
        public void DestroyAll()
        {
            this.ams.DestroyAll();
        }

        /// <summary>
        /// Puts Agent in the active state from the waiting state
        /// </summary>
        /// <param name="aid">The Agent's AID</param>
        /// <returns>True if operation succeds</returns>
        public bool WakeUp(AID aid)
        {
            return this.ams.WakeUp(aid);
        }

        /// <summary>
        /// Put Agent in the active state from the waiting state
        /// </summary>
        public void WakeUpAll()
        {
            this.ams.WakeUpAll();
        }

        # endregion

        #region CallBacks
        /// <summary>
        /// Handler of messages directed to the AMS
        /// </summary>
        /// <param name="msg"></param>
        public void DispatchMessage(AgentMessage msg)
        {
            this.ams.DispatchMessage(msg);
        }

        /// <summary>
        /// Delegate: invoked when the agentTransferred event is raised. It 
        /// creates the received agent and resumes from the persisted version. The
        /// agent is added in the agentsToExecute list. It sends
        /// a message to the remote AMS to inform it of completion of the operation,
        /// either it is succesfull or not.
        /// </summary>
        /// <param name="persistedAgent">Received persisted version of the agent</param>
        /// <param name="ticket">Ticket owned by the transferred agent. Parameter for an internal check</param>
        public void ResumeAgentTransferred(AgentService.Agent.AgentPersistent persistedAgent, int ticket)
        {
            this.ResumeAgentTransferred(persistedAgent, ticket);
        }

        #endregion
    }
}