/*********************************************************************/
/*                                                                   */
/*                     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.Specialized;
using AgentService.Platform.Modules;
// using AgentService.Interface;

namespace AgentService.Platform.Configuration
{

	/// <summary>
	/// Class Configuration. Defines the startup parameters of the platform.
	/// </summary>
    [Serializable]
	public class Configuration
	{

		/// <summary>
		/// true if the platform is started for the first time.
		/// </summary>
		private bool bIsFirstStart;
		/// <summary>
		/// Gets the "first start" flag.
		/// </summary>
		public bool IsFirstStart 
		{
			get 
			{
				return this.bIsFirstStart;
			}
			set
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.bIsFirstStart  = value;
			
			}
		}
		
		/// <summary>
		/// failed modules flag.
		/// </summary>
		private bool bSkipFailedModules;
		/// <summary>
		/// Gets, sets the behavoiur that the platform will use for failed modules.
		/// If false platform will not start if at least one additional module cannot
		/// be loaded.
		/// </summary>
		public bool SkipFailedModules 
		{
			get 
			{
				return this.bSkipFailedModules;
			}
			set 
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.bSkipFailedModules  = value;
			}		
		}

		/// <summary>
		/// error flag.
		/// </summary>
		private bool bHasErrors;
		/// <summary>
		/// Indicates whether the configuration is consistent.
		/// </summary>
		public bool HasErrors 
		{
			get 
			{
				return this.bHasErrors;
			}
		}

		/// <summary>
		/// error message
		/// </summary>
		private string errorMessage;
		/// <summary>
		/// Gets the error message
		/// </summary>
		public string ErrorMessage 
		{
			get 
			{
				return this.errorMessage;
			}
			set
			{
				if (this.bUpdating == false)
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
			
				this.errorMessage  = value;
			}

		}

		/// <summary>
		/// Base dir path for the AgentService platform
		/// </summary>
		protected string baseDirPath;
		/// <summary>
		/// Gets, sets the base dir path for the AgentService
		/// platform
		/// </summary>
		public string BaseDirPath 
		{
			get 
			{
				return this.baseDirPath;
			}
			
			set 
			{
				if (this.bUpdating == false)
					throw new InvalidOperationException("Properties can be modified only in the updating phase");
				this.baseDirPath = value;
			}
		}

		/// <summary>
		/// Repository file name
		/// </summary>
		protected string repositoryFile;
		/// <summary>
		/// Gets, sets the base dir path for the AgentService
		/// platform
		/// </summary>
		public string RepositoryFile
		{
			get 
			{
				return this.repositoryFile;
			}
			
			set 
			{
				if (this.bUpdating == false)
					throw new InvalidOperationException("Properties can be modified only in the updating phase");
				this.repositoryFile = value;
			}
		}

		
		/// <summary>
		/// Description of the platform.
		/// </summary>
		private IPlatformDescription platformDescription;
		/// <summary>
		/// Gets the platform description.
		/// </summary>
		public IPlatformDescription  PlatformDescription 
		{
			get 
			{
				return this.platformDescription;
			}
			set
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.platformDescription  = value;
			}
		}


		/// <summary>
		/// path where the core modules configuration files are stored
		/// </summary>
		private string coreModulesConfPath;
		/// <summary>
		/// Gets, sets the conf path for the core modules.
		/// </summary>
		public string CoreModulesConfPath 
		{
			get 
			{
				return this.coreModulesConfPath;

			}
			set 
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}
				this.coreModulesConfPath = value;;
			}
		}		


		/// <summary>
		/// path where the core modules are stored
		/// </summary>
		private string coreModulesBinPath;
		/// <summary>
		/// Gets, sets the bin path for the core modules.
		/// </summary>
		public string CoreModulesBinPath 
		{
			get 
			{
				return this.coreModulesBinPath;

			}
			set 
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}
				this.coreModulesBinPath = value;;
			}
		}	
		
		/// <summary>
		/// Info about the storage module.
		/// </summary>
		private ModuleInfo storageModule;
		/// <summary>
		/// Gets, sets the storage module loading information.
		/// </summary>
		public ModuleInfo StorageModule 
		{
			get 
			{
				return this.storageModule;
			}
			set
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.storageModule  = value;
			}		
		}

		/// <summary>
		/// Info about the messaging module.
		/// </summary>
		private ModuleInfo messagingModule;
		/// <summary>
		/// Gets, sets the messaging module loading information.
		/// </summary>
		public ModuleInfo MessagingModule 
		{
			get 
			{
				return this.messagingModule;
			}
			set
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.messagingModule  = value;
			}		
		}


		/// <summary>
		/// Info about the persistence module.
		/// </summary>
		private ModuleInfo persistenceModule;
		/// <summary>
		/// Gets, sets the persistence module loading information.
		/// </summary>
		public ModuleInfo PersistenceModule 
		{
			get 
			{
				return this.persistenceModule;
			}
			set
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.persistenceModule  = value;
			}		
		}

		/// <summary>
		/// Info about the logging module.
		/// </summary>
		private ModuleInfo loggingModule;
		/// <summary>
		/// Gets, sets the logging module loading information.
		/// </summary>
		public ModuleInfo LoggingModule 
		{
			get 
			{
				return this.loggingModule;
			}
			set
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.loggingModule  = value;
			}		
		}


		/// <summary>
		/// path where the additional modules configuration files are stored
		/// </summary>
		private string additionalModulesConfPath;
		/// <summary>
		/// Gets, sets the conf path for the additional modules.
		/// </summary>
		public string AdditionalModulesConfPath 
		{
			get 
			{
				return this.additionalModulesConfPath;

			}
			set 
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}
			    this.additionalModulesConfPath = value;
			}
		}

		/// <summary>
		/// path where the additional modules are stored
		/// </summary>
		private string additionalModulesBinPath;
		/// <summary>
		/// Gets, sets the bin path for the additional modules.
		/// </summary>
		public string AdditionalModulesBinPath 
		{
			get 
			{
				return this.additionalModulesBinPath;

			}
			set 
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}
				this.additionalModulesBinPath = value;
			}
		}

		/// <summary>
		/// Additional modules information.
		/// </summary>
		private ModuleInfo[] additionalModules;
		/// <summary>
		/// Gets, sets the loading information about the additional modules.
		/// </summary>
		public ModuleInfo[] AdditionalModules 
		{
			get 
			{
				return this.additionalModules;
			}
			set
			{
				if (this.bUpdating == false) 
				{
					throw new InvalidOperationException("Properties can be modified only in the reading phase");
				}

				this.additionalModules  = value;
			}			
		}
        /// <summary>
        /// Additional properties
        /// </summary>
        private StringDictionary properties;
        /// <summary>
        /// Gets, sets the additional properties.
        /// </summary>
        public StringDictionary Properties 
        {
            get 
            {
                return this.properties;
            }
            set 
            {
                if (this.bUpdating == false)
                {
                    throw new InvalidOperationException("Properties can be modified only in the reading phase");
                }

                this.properties = value;
            }
        }

		/// <summary>
		/// true while the configuration object is built. 
		/// bUpdating is set to true by calling BeginUpdate, 
		/// while is set to false by calling  EndUpdate
		/// </summary>
		private bool bUpdating;
		/// <summary>
		/// Gets true is the configuration object is updating
		/// </summary>
		public bool IsUpdating 
		{
			get 
			{
				return this.bUpdating;
			}
		}

		/// <summary>
		/// Begins the update process, and sets the Updating property to true.
		/// </summary>
		public void BeginUpdate() 
		{
			this.bUpdating = true;
		}

		/// <summary>
		/// Terminates the update process and sets the Updating property to false.
		/// </summary>
		public void EndUpdate() 
		{
			this.bUpdating = false;
		}

		/// <summary>
		/// Sets the HasErrors property to true during updating. Calling this method
		/// outside the updating process will throw an InvalidOperation exception.
		/// </summary>
		public void SetError() 
		{
			if (this.bUpdating)
				this.bHasErrors = true;
			else
				throw new InvalidOperationException("Cannot notify errors while configuration is not in the updating phase.");
		}

		/// <summary>
		/// Clears the HasErrors flag. 
		/// </summary>
		public void ResetError() 
		{
			this.bHasErrors = false;
		}

		/// <summary>
		/// Adds a new module to the configuration. 
		/// Note: the new module will be recognized at the next platform startup
		/// </summary>
		/// <param name="modInfo">module information of the module that is going to be installed</param>
		public void AddModule(ModuleInfo modInfo) 
		{

			modInfo.State = ModuleInfoState.New;
			ModuleInfo[] backing = new ModuleInfo[this.additionalModules.Length + 1];
			int ndx = 0;
			for(; ndx<this.additionalModules.Length; ndx++) 
			{
				backing[ndx] = this.additionalModules[ndx];
			}
			
			backing[ndx] = modInfo;

			this.additionalModules = backing;
		}



		/// <summary>
		/// Removes a module from the configuration.
		/// </summary>
		/// <param name="modInfo">module to Remove</param>
		public void RemoveModule(ModuleInfo modInfo) 
		{
			foreach(ModuleInfo mi in this.additionalModules) 
			{
				if (mi == modInfo) 
				{
					mi.State = ModuleInfoState.Removed;	
				}
			}
		}
		
	}
}