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

namespace AgentService.Platform.Commands
{
	#region ManagePlatformCommands

	/// <summary>
	/// Class StartCommand. Command issued to start the platform.
	/// </summary>
	public class StartCommand : PlatformCommand
	{
		/// <summary>
		/// Constructs a StartCommand object.
		/// </summary>
		public StartCommand() : base(PlatformState.Ready, true)
		{

		}
		
		public override void Execute(ICommandContext cmdCtx)
		{
			cmdCtx.StartPlatform();
		}
		
		public override bool ParseArguments(string args)
		{
			// TODO: implements method
			return true;
		}

	}
	
	/// <summary>
	/// Class StopCommand. Stops the AgentService platform.
	/// </summary>
	public class StopCommand : PlatformCommand
	{
		/// <summary>
		/// Constructs a StopCommand object.
		/// </summary>
		public StopCommand() : base(PlatformState.Running, true)
		{
			
		}
		public override void Execute(ICommandContext cmdCtx)
		{
			cmdCtx.RunPlatform();
		}
		
		public override bool ParseArguments(string args)
		{
			// TODO: implements method
			return true;
		}
	}

	/// <summary>
	/// Class CloseCommand. Close a shell session.
	/// </summary>
	public class CloseCommand : PlatformCommand
	{
		/// <summary>
		/// Constructs a CloseCommand object.
		/// </summary>
		public CloseCommand() : base(PlatformState.FailStart,false)
		{
			
		}

		public override void Execute(ICommandContext cmdCtx)
		{
			cmdCtx.BindToInput(null);
		}
		
		public override bool ParseArguments(string args)
		{
			// TODO: implements method
			return true;
		}
	}
	#endregion

	#region ManageModuleCommands
//	/// <summary>
//	/// Class InstallModuleCommand. Command issued when we want ot install a module
//	/// </summary>
//	public class InstallModuleCommand : PlatformCommand
//	{
//		/// <summary>
//		/// full type name of the module
//		/// </summary>
//		private string typeName;
//		/// <summary>
//		/// Gets the full type name of the module
//		/// </summary>
//		public string FullTypeName 
//		{
//			get 
//			{
//				return  this.typeName;
//			}
//		}
//
//		/// <summary>
//		/// path to the assembly where the module is defined
//		/// </summary>
//		private string assemblyPath;
//		/// <summary>
//		/// Gets the path to the assembly where the module is defined
//		/// </summary>
//		public string AssemblyPath 
//		{
//			get 
//			{
//				return  this.assemblyPath;
//			}
//		}
//
//		/// <summary>
//		/// path to the configuration file for the module
//		/// </summary>
//		private string configPath;
//		/// <summary>
//		/// Gets the path to the configuration file for the module
//		/// </summary>
//		public string ConfigPath 
//		{
//			get 
//			{
//				return this.configPath;
//			}
//		}
//
//		/// <summary>
//		/// module category
//		/// </summary>
//		private ModuleCategory category;
//		/// <summary>
//		/// Gets the module category
//		/// </summary>
//		public ModuleCategory Category 
//		{
//			get 
//			{
//				return this.category;
//			}
//		}
//
//		/// <summary>
//		/// Constructs an InstallModuleCommand, for common modules
//		/// </summary>
//		/// <param name="typeName">full name of the type that implements the module</param>
//		/// <param name="assemblyPath">path to the assembly where the module is defined</param>
//		/// <param name="configFilePath">path to the configuration file</param>
//		public InstallModuleCommand(string typeName, string assemblyPath, string configFilePath) : base(Commands.InstallModule, CommandLevel.Ready)
//		{
//			if (typeName == null)
//				throw new ArgumentNullException("typeName", "type name cannot be null");
//
//			if (assemblyPath == null)
//				throw new ArgumentNullException("assemblyPath", "null path to assembly");
//
//			this.typeName = typeName;
//			this.assemblyPath = assemblyPath;
//			this.configPath = configFilePath;
//			this.category = ModuleCategory.Other;
//		}
//	
//		/// <summary>
//		/// Constructs an InstallModuleCommand by specifying the type of the module
//		/// </summary>
//		/// <param name="typeName">full type name of the module</param>
//		/// <param name="assemblyPath">path to the assembly where the module is defined</param>
//		/// <param name="configFilePath">path to configuration file of the module</param>
//		/// <param name="category">type of the module</param>
//		public InstallModuleCommand(string typeName, string assemblyPath, string configFilePath, ModuleCategory categoy)
//		{
//			if (typeName == null)
//				throw new ArgumentNullException("typeName", "type name cannot be null");
//
//			if (assemblyPath == null)
//				throw new ArgumentNullException("assemblyPath", "null path to assembly");
//
//			if (category == ModuleCategory.Core)
//				throw new NotSupportedException("module category Core is not supported");
//
//			this.typeName = typeName;
//			this.assemblyPath = assemblyPath;
//			this.configPath = configPath;
//
//			this.category = category;
//		}
//	}
//
//	/// <summary>
//	/// Class UninstallModuleCommand. Command issued to uninstall a module from the platform
//	/// </summary>
//	public class UninstallModuleCommand : PlatformCommand 
//	{
//		/// <summary>
//		/// full type name of the module
//		/// </summary>
//		private string typeName;
//		/// <summary>
//		/// Gets the full type name of the module
//		/// </summary>
//		public string FullTypeName 
//		{
//			get 
//			{
//				return  this.typeName;
//			}
//		}
//		
//		/// <summary>
//		/// Constructs an UninstallModuleCommand by specifying the type of the module
//		/// </summary>
//		/// <param name="typeName">full type name of the module</param>
//		public UninstallModuleCommand(string typeName) : base(Commands.UninstallModule, CommandLevel.Ready)
//		{
//			if (typeName == null)
//				throw new ArgumentNullException("typeName", "type name cannot be null");
//
//			this.typeName = typeName;
//		}		
//	}
//
//	/// <summary>
//	/// Class AttachModuleCommand. Command issued to attach a module from the platform
//	/// </summary>
//	public class AttachModuleCommand : PlatformCommand
//	{
//		/// <summary>
//		/// full type name of the module
//		/// </summary>
//		private string typeName;
//		/// <summary>
//		/// Gets the full type name of the module
//		/// </summary>
//		public string FullTypeName 
//		{
//			get 
//			{
//				return  this.typeName;
//			}
//		}	
//	
//		/// <summary>
//		/// Constructs an AttachModuleCommand by specifying the type of the module
//		/// </summary>
//		/// <param name="typeName">full type name of the module</param>
//		public AttachModuleCommand(string typeName) : base(Commands.AttachModule, CommandLevel.Ready)
//		{
//			if (typeName == null)
//				throw new ArgumentNullException("typeName", "type name cannot be null");
//
//			this.typeName = typeName;		
//		}
//	}
//
//	/// <summary>
//	/// Class AttachModuleCommand. Command issued to detach a module from the platform
//	/// </summary>
//	public class DetachModuleCommand : PlatformCommand
//	{
//		/// <summary>
//		/// full type name of the module
//		/// </summary>
//		private string typeName;
//		/// <summary>
//		/// Gets the full type name of the module
//		/// </summary>
//		public string FullTypeName 
//		{
//			get 
//			{
//				return  this.typeName;
//			}
//		}	
//	
//		/// <summary>
//		/// Constructs an DetachModuleCommand by specifying the type of the module
//		/// </summary>
//		/// <param name="typeName">full type name of the module</param>
//		public DetachModuleCommand(string typeName) : base(Commands.DetachModule, CommandLevel.Ready)
//		{
//			if (typeName == null)
//				throw new ArgumentNullException("typeName", "type name cannot be null");
//
//			this.typeName = typeName;		
//		}
//	}
	#endregion

	#region ManageAgentCommands
	/// <summary>
	/// Class CreateAgentCommand. Command issued to create an agent
	/// </summary>
	public class CreateAgentCommand : PlatformCommand 
	{
		/// <summary>
		/// Agent Identifier
		/// </summary>
		private AgentService.Agent.AID aid;
		/// <summary>
		/// Gets the unique identifier of the agent
		/// </summary>
		public AgentService.Agent.AID Aid
		{
			get
			{
				return this.aid;
			}
		}
		
		/// <summary>
		/// full type name of the template
		/// </summary>
		private string templateName;
		/// <summary>
		/// Gets the full type name of the template
		/// </summary>
		public string FullTemplateName 
		{
			get 
			{
				return  this.templateName;
			}
		}

		/// <summary>
		/// name of the agent
		/// </summary>
		private string agentName;
		/// <summary>
		/// Gets the name of the agent
		/// </summary>
		public string AgentName 
		{
			get 
			{
				return  this.agentName;
			}
		}
		
		/// <summary>
		/// The full path to the configuration file
		/// </summary>
		private string config;
		/// <summary>
		/// Gets the path to the configuration file
		/// </summary>
		public string Config
		{
			get
			{
				return this.config;
			}
		}

		/// <summary>
		/// Flag that controls the persistene of the agent
		/// </summary>
		private bool bPersist;
		/// <summary>
		/// Gets the persistence flag of the agent
		/// </summary>
		public bool IsPersistent
		{
			get
			{
				return this.bPersist;
			}
		}

		/// <summary>
		/// Constructs a CreateAgentCommand object by specifying the agent name and the template type
		/// </summary>
		/// <param name="agentName">name of the agent</param>
		/// <param name="templateName">full type name of the template</param>
		public CreateAgentCommand(string agentName, string templateName): base(PlatformState.Running, true)
		{
			if ((agentName == null) || (agentName == String.Empty))
				throw new ArgumentNullException("agentName", "agent name cannot be null or empty");

			if (templateName == null)
				throw new ArgumentNullException("templateName", "null template name?");

			this.agentName = agentName;
			this.templateName = templateName;
			
		}

		public override void Execute(ICommandContext cmdCtx)
		{
			this.aid = cmdCtx.CreateAgent(this.agentName,this.FullTemplateName,this.config,this.bPersist);
		}
		
		public override bool ParseArguments(string args)
		{
			// TODO: implements method
			return false;
		}
	}

	/// <summary>
	/// Class TerminateAgentCommand. Command issued to terminate an agent
	/// </summary>
	public class TerminateAgentCommand : PlatformCommand
	{

		/// <summary>
		/// name of the agent
		/// </summary>
		private string agentName;
		/// <summary>
		/// Gets the name of the agent
		/// </summary>
		public string AgentName 
		{
			get 
			{
				return  this.agentName;
			}
		}

		/// <summary>
		/// Constructs a TerminateAgentCommand object by specifying the agent name and the template type
		/// </summary>
		/// <param name="agentName">name of the agent</param>
		public TerminateAgentCommand(string agentName) : base(PlatformState.Running,true)
		{
			if ((agentName == null) || (agentName == String.Empty))
				throw new ArgumentNullException("agentName", "agent name cannot be null or empty");

			this.agentName = agentName;

		}

		public override void Execute(ICommandContext cmdCtx)
		{
			cmdCtx.KillAgent(this.agentName);
		}
		
		public override bool ParseArguments(string args)
		{
			// TODO: implements method
			return false;
		}
	}
	#endregion

	#region ManageAssemblyCommand
	/// <summary>
	/// Class LoadAssemblyCommand. Command issued to load an assembly into the platform
	/// </summary>
	public class UpLoadAssemblyCommand : PlatformCommand
	{
		/// <summary>
		/// path to the assembly to load
		/// </summary>
		private string assemblyPath;
		/// <summary>
		/// Gets the path to the assembly to load
		/// </summary>
		public string AssemblyPath 
		{
			get 
			{
				return  this.assemblyPath;
			}
		}
		
		/// <summary>
		/// Constructs a LoadAssemblyCommand by specifying the assembly path
		/// </summary>
		/// <param name="assemblyPath"></param>
		public UpLoadAssemblyCommand(string assemblyPath) : base(PlatformState.Ready,false)
		{
			if (assemblyPath == null)
				throw new ArgumentNullException("assemblyPath", "null path to assembly");

			this.assemblyPath = assemblyPath;
		}

		public override void Execute(ICommandContext cmdCtx)
		{
			//TODO: implements method
		}
		
		public override bool ParseArguments(string args)
		{
			// TODO: implements method
			return false;
		}
	}

	/// <summary>
	/// Class RemoveAssemblyCommand. Command issued to remove an assembly into the platform
	/// </summary>
	public class RemoveAssemblyCommand : PlatformCommand
	{
		/// <summary>
		/// name of the assembly to remove
		/// </summary>
		private string assemblyFile;
		/// <summary>
		/// Gets the name of the assembly to remove
		/// </summary>
		public string AssemblyFile 
		{
			get 
			{
				return  this.assemblyFile;
			}
		}
		
		/// <summary>
		/// Constructs a LoadAssemblyCommand by specifying the assembly name
		/// </summary>
		/// <param name="assemblyFile">name of the assembly file to remove</param>
		public RemoveAssemblyCommand(string assemblyFile) : base(PlatformState.Ready,true)
		{
			if (assemblyFile == null)
				throw new ArgumentNullException("assemblyPath", "null path to assembly");

			this.assemblyFile = assemblyFile;
		}

		public override void Execute(ICommandContext cmdCtx)
		{
			// TODO: implements method
		}
		
		public override bool ParseArguments(string args)
		{
			// TODO: implements method
			return false;
		}
	}
	#endregion
}