/*********************************************************************/
/*                                                                   */
/*                     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.Collections.Generic;
using System.Text;

using AgentService.Platform.AMS;
using AgentService.Platform.Modules;

namespace AgentService.Agent.Runtime
{
    /// <summary>
    /// Class LogModuleProxy. Creates a proxy of the LoggingModule
    /// in the current Application Domain, this class is used to
    /// connect logging module clients to the LoggingModule instance
    /// when clients are in a different application domain.
    /// </summary>
    class LogModuleProxy : MarshalByRefObject, ILoggingModule
    {
        #region members


        /// <summary>
        /// the reference to the LoggingModule
        /// </summary>
        private ILoggingModule logmodule;

        /// <summary>
		/// Gets, sets the logging level
		/// </summary>
		public LoggingLevel Level 
		{
			get
            {
                return this.logmodule.Level;
            }
            set
            {
                this.logmodule.Level = value;
            }
		}

		/// <summary>
		/// Gets, sets the logging format.
		/// </summary>
		public string Format 
		{
			get
            {
                return this.logmodule.Format;
            }
			set
            {
                this.logmodule.Format = value;
            }
		}



        /// <summary>
        /// Gets the base logging directory for the log files
        /// of agents
        /// </summary>
        public string BaseLoggingDirectory
        {
            get
            {
                return this.logmodule.BaseLoggingDirectory;
            }
        }

        /// <summary>
        /// Gets the log file extension used
        /// </summary>
        public string LogExtension
        {
            get
            {
                return this.logmodule.LogExtension;
            }
        }
        #endregion

        #region ILoggingModule Members
        /// <summary>
		/// Appends a message to the logging system with the given level.
		/// Note: messages are logged only if the given level is higher
		/// or equal to logging level set with "Level" property
		/// </summary>
		/// <param name="level">Logging level of the message</param>
		/// <param name="message">message content</param>
        public void Append(LoggingLevel level, string message)
        {
            this.logmodule.Append(level, message);
        }

		/// <summary>
		/// Clear all the messages stored in the log.
		/// </summary>
        public void Clear()
        {
            this.logmodule.Clear();
        }

		/// <summary>
		/// Retrieves the collection of messages stored in the logging system.
		/// </summary>
		/// <returns>The collection of messages.</returns>
        public System.Collections.Specialized.StringCollection GetMessages()
        {
            return this.logmodule.GetMessages();
        }

		/// <summary>
		/// Gets true if the module provides a custom client.
		/// </summary>
		public bool HasClient 
		{
            get
            {
                return this.logmodule.HasClient;
            }
		}

		/// <summary>
		/// Creates a client of the logging system for a given agent.
		/// </summary>
		/// <param name="aid">agent identifier.</param>
		/// <param name="aid">session identifier</param>
		/// <returns>client to the logging system.</returns>
        public ILogClient CreateClient(AID aid, int token)
        {
            return this.logmodule.CreateClient(aid, token);
        }
        #endregion

        #region IPlatformModule Members

        /// <summary>
        /// Gets the name of the module
        /// </summary>
        public string Name
        {
            get
            {
                return this.logmodule.Name;
            }
        }

        /// <summary>
        /// Gets a summary description of the module
        /// </summary>
        public string Description 
        {
            get
            {
                return this.logmodule.Description;
            }
        }

        /// <summary>
        /// Gets the belonging category of the module
        /// </summary>
        public ModuleCategory Category
        {
            get
            {
                return this.logmodule.Category;
            }
        }

        /// <summary>
        /// Gets a bool value indicating if the module is
        /// able to perform the main functionality of the 
        /// belonging category. If the bool value is false
        /// the maodule is not a main module. This means that 
        /// in the case of the Messaging Category the module
        /// can be a filter. If the bool value is true insted 
        /// the module can perform all the base functionalities
        /// required by the messaging subsystem
        /// </summary>
        public bool IsMain 
        {
            get
            {
                return this.logmodule.IsMain;
            }
        }



        /// <summary>
        /// Checks wheter the module supports features defined in a given interface.
        /// If the these features are supported the module reference can be subject to 
        /// cast against the requested interface.
        /// </summary>
        /// <param name="capabiltyInterface">full name of the interface that </param>
        /// <returns>true if the specified interface is supported</returns>
        public bool CanSupport(string capabiltyInterface)
        {
            return this.logmodule.CanSupport(capabiltyInterface);
        }


        /// <summary>
        /// Returns the last error occurred in the module, null if there
        /// are no errors to return
        /// </summary>
        /// <returns>Reference to the error.</returns>
        public IModuleError GetLastError()
        {
            return this.logmodule.GetLastError();
        }

        /// <summary>
        /// Attaches the module to the platform. Called by the platform
        /// when the module is loaded.
        /// </summary>
        /// <param name="hostingPlatform">reference to the instance of the hosting platform</param>
        /// <param name="info">installation information of the module</param>
        /// <returns>returns true is the operation has been successfulland with no errors</returns>
        public bool Attach(Platform.IPlatformContext hostingPlatform, ModuleInfo info)
        {
            return this.logmodule.Attach(hostingPlatform, info);
        }

        /// <summary>
        /// Detaches the module from the platform Called by the platform when
        /// the module is unloaded
        /// </summary>
        /// <returns>true if the operation has been successful</returns>
        public bool Detach()
        {
            return this.logmodule.Detach();
        }

        /// <summary>
        /// Installs a the module in the platform.  Called by the pltaform when the module is
        /// installed.
        /// </summary>
        /// <param name="context">platform context, accessible platform data from modules</param>
        /// <param name="info">information about the module</param>
        /// <param name="instInfo">installation info object used to store install information</param>
        /// <returns>true if the installation process has been successful</returns>
        public bool Install(Platform.IPlatformContext context, ModuleInfo info, ref InstallationInfo instInfo)
        {
            return this.logmodule.Install(context, info, ref instInfo);
        }

        /// <summary>
        /// Uninstall the module. Called by the platform when the module is removed permanently
        /// from the platform
        /// </summary>
        /// <param name="instInfo">installation info object used to install the module</param>
        /// <returns>true if the uninstallation process has been successful</returns>
        public bool UnInstall(InstallationInfo instInfo)
        {
            return this.logmodule.UnInstall(instInfo);
        }

        #endregion

        /// <summary>
        /// Creates a LogModuleProxy instance connected
        /// to the logging module.
        /// </summary>
        /// <param name="obj"></param>
        public LogModuleProxy(ILoggingModule obj)
        {
            this.logmodule = obj;
        }
    }
}