#region Apache Notice
/*****************************************************************************
 * $Header: $
 * $Revision: $
 * $Date: $
 * 
 * iBATIS.NET Data Mapper
 * Copyright (C) 2004 - Gilles Bayon
 *  
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 ********************************************************************************/
#endregion

#region Using

using System;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Threading;
using System.Xml;
using IBatisNet.Common;
using IBatisNet.Common.Exceptions;
using IBatisNet.Common.Logging;
using IBatisNet.Common.Utilities;
using IBatisNet.Common.Xml;
using IBatisNet.DataAccess.Configuration.Serializers;
using IBatisNet.DataAccess.Interfaces;
using IBatisNet.DataAccess.Scope;

#endregion

namespace IBatisNet.DataAccess.Configuration
{
	/// <summary>
	/// Summary description for DomDaoManagerBuilder.
	/// </summary>
	public class DomDaoManagerBuilder
	{
		#region Constants

		/// <summary>
		/// 
		/// </summary>
		public const string DAO_NAMESPACE_PREFIX = "dao";
		private const string PROVIDERS_NAMESPACE_PREFIX = "provider";
		private const string PROVIDER_XML_NAMESPACE = "http://ibatis.apache.org/providers";
		private const string DAO_XML_NAMESPACE = "http://ibatis.apache.org/dataAccess";

		private const string KEY_ATTRIBUTE = "key";
		private const string VALUE_ATTRIBUTE = "value";
		private const string ID_ATTRIBUTE = "id";

		private readonly object [] EmptyObjects = new object [] {};

		/// <summary>
		/// Key for default config name
		/// </summary>
		public const string DEFAULT_FILE_CONFIG_NAME = "dao.config";
		/// <summary>
		/// Key for default provider name
		/// </summary>
		public const string DEFAULT_PROVIDER_NAME = "_DEFAULT_PROVIDER_NAME";
		/// <summary>
		/// Key for default dao session handler name
		/// </summary>
		public const string DEFAULT_DAOSESSIONHANDLER_NAME = "DEFAULT_DAOSESSIONHANDLER_NAME";

		/// <summary>
		/// Token for xml path to properties elements.
		/// </summary>
		private const string XML_PROPERTIES = "properties";

		/// <summary>
		/// Token for xml path to property elements.
		/// </summary>
		private const string XML_PROPERTY = "property";

		/// <summary>
		/// Token for xml path to settings add elements.
		/// </summary>
		private const string XML_SETTINGS_ADD = "/*/add";

		/// <summary>
		/// Token for xml path to DaoConfig providers element.
		/// </summary>
		private static string XML_CONFIG_PROVIDERS = "daoConfig/providers";

		/// <summary>
		/// Token for providers config file name.
		/// </summary>
		private const string PROVIDERS_FILE_NAME = "providers.config";

		/// <summary>
		/// Token for xml path to provider elements.
		/// </summary>
		private const string XML_PROVIDER = "providers/provider";

		/// <summary>
		/// Token for xml path to dao session handlers element.
		/// </summary>
		private const string XML_DAO_SESSION_HANDLERS = "daoConfig/daoSessionHandlers";

		/// <summary>
		/// Token for xml path to handler element.
		/// </summary>
		private const string XML_HANDLER = "handler";

		/// <summary>
		/// Token for xml path to dao context element.
		/// </summary>
		private const string XML_DAO_CONTEXT = "daoConfig/context";

		/// <summary>
		/// Token for xml path to database provider elements.
		/// </summary>
		private const string XML_DATABASE_PROVIDER = "database/provider";

		/// <summary>
		/// Token for xml path to database source elements.
		/// </summary>
		private const string XML_DATABASE_DATASOURCE = "database/dataSource";

		/// <summary>
		/// Token for xml path to dao session handler elements.
		/// </summary>
		private const string XML_DAO_SESSION_HANDLER = "daoSessionHandler";

		/// <summary>
		/// Token for xml path to dao elements.
		/// </summary>
		private const string XML_DAO = "daoFactory/dao";

		#endregion

		#region Fields

		private static readonly ILog _logger = LogManager.GetLogger( MethodBase.GetCurrentMethod().DeclaringType );

		#endregion 

		#region Constructor (s) / Destructor

		/// <summary>
		/// Constructor.
		/// </summary>
		public DomDaoManagerBuilder(){ }

		#endregion

		#region Configure

		/// <summary>
		/// Configure DaoManagers from via the default file config.
		/// (accesd as relative ressource path from your Application root)
		/// </summary>
		public void Configure()
		{
			Configure( DomDaoManagerBuilder.DEFAULT_FILE_CONFIG_NAME );
		}

		/// <summary>
		/// Configure DaoManagers from an XmlDocument.
		/// </summary>
		/// <param name="document">An xml configuration document.</param>
		public void Configure( XmlDocument document )
		{
			BuildDaoManagers( document, false );
		}

		/// <summary>
		/// Configure DaoManagers from a file path.
		/// </summary>
		/// <param name="resource">
		/// A relative ressource path from your Application root 
		/// or a absolue file path file:\\c:\dir\a.config
		/// </param>
		public void Configure(string resource)
		{
			XmlDocument document = null;
			if (resource.StartsWith("file://"))
			{
				document = Resources.GetUrlAsXmlDocument( resource.Remove(0, 7) );	
			}
			else
			{
				document = Resources.GetResourceAsXmlDocument( resource );	
			}			
			BuildDaoManagers( document, false );
		}


		/// <summary>
		///  Configure DaoManagers from a stream.
		/// </summary>
		/// <param name="resource">A stream resource</param>
		public void Configure(Stream resource)
		{
			XmlDocument document = Resources.GetStreamAsXmlDocument( resource );
			BuildDaoManagers( document, false );
		}

		/// <summary>
		///  Configure DaoManagers from a FileInfo.
		/// </summary>
		/// <param name="resource">A FileInfo resource</param>
		/// <returns>An SqlMap</returns>
		public void Configure(FileInfo resource)
		{
			XmlDocument document = Resources.GetFileInfoAsXmlDocument( resource );
			BuildDaoManagers( document, false );
		}

		/// <summary>
		///  Configure DaoManagers from an Uri.
		/// </summary>
		/// <param name="resource">A Uri resource</param>
		/// <returns></returns>
		public void Configure(Uri resource)
		{
			XmlDocument document = Resources.GetUriAsXmlDocument( resource );
			BuildDaoManagers( document, false );
		}

		/// <summary>
		/// Configure and monitor the configuration file for modifications and 
		/// automatically reconfigure  
		/// </summary>
		/// <param name="configureDelegate">
		/// Delegate called when a file is changed to rebuild the 
		/// </param>
		public void ConfigureAndWatch(ConfigureHandler configureDelegate)
		{
			ConfigureAndWatch( DomDaoManagerBuilder.DEFAULT_FILE_CONFIG_NAME, configureDelegate );
		}


		/// <summary>
		/// Configure and monitor the configuration file for modifications and 
		/// automatically reconfigure  
		/// </summary>
		/// <param name="resource">
		/// A relative ressource path from your Application root 
		/// or an absolue file path file://c:\dir\a.config
		/// </param>
		///<param name="configureDelegate">
		/// Delegate called when the file has changed, to rebuild the dal.
		/// </param>
		public void ConfigureAndWatch(string resource, ConfigureHandler configureDelegate)
		{
			XmlDocument document = null;
			if (resource.StartsWith("file://"))
			{
				document = Resources.GetUrlAsXmlDocument( resource.Remove(0, 7) );	
			}
			else
			{
				document = Resources.GetResourceAsXmlDocument( resource );	
			}

			ConfigWatcherHandler.ClearFilesMonitored();
			ConfigWatcherHandler.AddFileToWatch( Resources.GetFileInfo( resource ) );

			BuildDaoManagers( document, true );

			TimerCallback callBakDelegate = new TimerCallback( DomDaoManagerBuilder.OnConfigFileChange );

			StateConfig state = new StateConfig();
			state.FileName = resource;
			state.ConfigureHandler = configureDelegate;

			new ConfigWatcherHandler( callBakDelegate, state );
		}

		
		/// <summary>
		/// Configure and monitor the configuration file for modifications 
		/// and automatically reconfigure SqlMap. 
		/// </summary>
		/// <param name="resource">
		/// A FileInfo to your config file.
		/// </param>
		///<param name="configureDelegate">
		/// Delegate called when the file has changed, to rebuild the dal.
		/// </param>
		/// <returns>An SqlMap</returns>
		public void ConfigureAndWatch( FileInfo resource, ConfigureHandler configureDelegate )
		{
			XmlDocument document = Resources.GetFileInfoAsXmlDocument(resource);

			ConfigWatcherHandler.ClearFilesMonitored();
			ConfigWatcherHandler.AddFileToWatch( resource );

			BuildDaoManagers( document, true );

			TimerCallback callBakDelegate = new TimerCallback( DomDaoManagerBuilder.OnConfigFileChange );

			StateConfig state = new StateConfig();
			state.FileName = resource.FullName;
			state.ConfigureHandler = configureDelegate;

			new ConfigWatcherHandler( callBakDelegate, state );
		}

		/// <summary>
		/// Called when the configuration has been updated. 
		/// </summary>
		/// <param name="obj">The state config.</param>
		public static void OnConfigFileChange(object obj)
		{
			StateConfig state = (StateConfig)obj;
			state.ConfigureHandler(null);
		}


		#endregion

		#region Methods

		/// <summary>
		/// Build DaoManagers from config document.
		/// </summary>
//		[MethodImpl(MethodImplOptions.Synchronized)]
		public void BuildDaoManagers(XmlDocument document, bool useConfigFileWatcher)
		{
			ConfigurationScope configurationScope = new ConfigurationScope();

			configurationScope.UseConfigFileWatcher = useConfigFileWatcher;
			configurationScope.DaoConfigDocument = document;

			configurationScope.XmlNamespaceManager = new XmlNamespaceManager(configurationScope.DaoConfigDocument.NameTable);
			configurationScope.XmlNamespaceManager.AddNamespace(DAO_NAMESPACE_PREFIX, DAO_XML_NAMESPACE);
			configurationScope.XmlNamespaceManager.AddNamespace(PROVIDERS_NAMESPACE_PREFIX, PROVIDER_XML_NAMESPACE);

			try
			{
				GetConfig( configurationScope );
			}
			catch(Exception ex)
			{
				throw new ConfigurationException( configurationScope.ErrorContext.ToString(), ex);
			}
		}

		/// <summary>
		/// Load and build the dao managers.
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		private void GetConfig(ConfigurationScope configurationScope)
		{
			GetProviders( configurationScope );
			GetDaoSessionHandlers( configurationScope );
			GetContexts( configurationScope );
		}

		
		/// <summary>
		/// Load and initialize providers from specified file.
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		private void GetProviders(ConfigurationScope configurationScope)
		{
			Provider provider = null;
			XmlDocument xmlProviders = null;

			configurationScope.ErrorContext.Activity = "Loading Providers config file";

			XmlNode providersNode = null;
			providersNode = configurationScope.DaoConfigDocument.SelectSingleNode( ApplyNamespacePrefix(XML_CONFIG_PROVIDERS), configurationScope.XmlNamespaceManager);

			if (providersNode != null )
			{
				xmlProviders = Resources.GetAsXmlDocument( providersNode, configurationScope.Properties );
			}
			else
			{
				xmlProviders = Resources.GetConfigAsXmlDocument(PROVIDERS_FILE_NAME);
			}

			foreach (XmlNode node in xmlProviders.SelectNodes(ApplyProviderNamespacePrefix(XML_PROVIDER), configurationScope.XmlNamespaceManager ) )
			{
				configurationScope.ErrorContext.Resource = node.InnerXml.ToString();

				provider = ProviderDeSerializer.Deserialize(node);

				if (provider.IsEnabled == true)
				{
					configurationScope.ErrorContext.ObjectId = provider.Name;
					configurationScope.ErrorContext.MoreInfo = "initialize provider";

					provider.Initialize() ;
					configurationScope.Providers.Add(provider.Name, provider);
					if (provider.IsDefault == true)
					{
						if (configurationScope.Providers[DEFAULT_PROVIDER_NAME] == null) 
						{
							configurationScope.Providers.Add(DEFAULT_PROVIDER_NAME, provider);
						} 
						else 
						{
							throw new ConfigurationException(
								string.Format("Error while configuring the Provider named \"{0}\" There can be only one default Provider.",provider.Name));
						}
					}
				}
			}

			configurationScope.ErrorContext.Reset();
		}


		/// <summary>
		/// Load and initialize custom DaoSession Handlers.
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		private void GetDaoSessionHandlers(ConfigurationScope configurationScope)
		{
			XmlNode daoSessionHandlersNode = null;

			configurationScope.ErrorContext.Activity = "loading custom DaoSession Handlers";

			daoSessionHandlersNode = configurationScope.DaoConfigDocument.SelectSingleNode( ApplyNamespacePrefix(XML_DAO_SESSION_HANDLERS), configurationScope.XmlNamespaceManager);

			if (daoSessionHandlersNode != null)
			{
				foreach (XmlNode node in daoSessionHandlersNode.SelectNodes( ApplyNamespacePrefix(XML_HANDLER), configurationScope.XmlNamespaceManager))
				{
					configurationScope.ErrorContext.Resource = node.InnerXml.ToString();

					DaoSessionHandler daoSessionHandler = DaoSessionHandlerDeSerializer.Deserialize(node, configurationScope);
				
					configurationScope.ErrorContext.ObjectId = daoSessionHandler.Name;
					configurationScope.ErrorContext.MoreInfo = "build daoSession handler";

					configurationScope.DaoSectionHandlers[daoSessionHandler.Name] = daoSessionHandler.TypeInstance;

					if (daoSessionHandler.IsDefault == true)
					{
						configurationScope.DaoSectionHandlers[DEFAULT_DAOSESSIONHANDLER_NAME] = daoSessionHandler.TypeInstance;
					}
				}
			}

			configurationScope.ErrorContext.Reset();
		}


		/// <summary>
		/// Build dao contexts
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		private void GetContexts(ConfigurationScope configurationScope)
		{
			DaoManager daoManager = null;
			XmlAttribute attribute = null;

			// Init
			DaoManager.Reset();

			// Build one daoManager for each context
			foreach (XmlNode contextNode in configurationScope.DaoConfigDocument.SelectNodes(ApplyNamespacePrefix(XML_DAO_CONTEXT), configurationScope.XmlNamespaceManager))
			{
				configurationScope.ErrorContext.Activity = "build daoManager";
				configurationScope.NodeContext = contextNode;

				#region Configure a new DaoManager

				daoManager = DaoManager.NewInstance();

				// name
				attribute = contextNode.Attributes["id"];
				daoManager.Name = attribute.Value;

				configurationScope.ErrorContext.Activity += daoManager.Name;

				// default
				attribute = contextNode.Attributes["default"];
				if (attribute != null)
				{
					if (attribute.Value=="true")
					{
						daoManager.IsDefault = true;
					}
					else
					{
						daoManager.IsDefault= false;
					}
				}
				else
				{
					daoManager.IsDefault= false;
				}
				#endregion 

				#region Properties
				ParseGlobalProperties( configurationScope );
				#endregion

				#region provider
				daoManager.Provider = ParseProvider( configurationScope );

				configurationScope.ErrorContext.Resource = string.Empty;
				configurationScope.ErrorContext.MoreInfo = string.Empty;
				configurationScope.ErrorContext.ObjectId = string.Empty;
				#endregion

				#region DataSource 
				daoManager.DataSource = ParseDataSource( configurationScope );
				daoManager.DataSource.Provider = daoManager.Provider;
				#endregion

				#region DaoSessionHandler

				XmlNode nodeSessionHandler = contextNode.SelectSingleNode( ApplyNamespacePrefix(XML_DAO_SESSION_HANDLER), configurationScope.XmlNamespaceManager);

				configurationScope.ErrorContext.Activity = "configure DaoSessionHandler";

				// The resources use to initialize the SessionHandler 
				IDictionary resources = new Hashtable();
				// By default, add the DataSource
				resources.Add( "DataSource", daoManager.DataSource);
				// By default, add the useConfigFileWatcher
				resources.Add( "UseConfigFileWatcher", configurationScope.UseConfigFileWatcher);

				IDaoSessionHandler sessionHandler = null;
				Type typeSessionHandler = null;

				if (nodeSessionHandler!= null)
				{
					configurationScope.ErrorContext.Resource = nodeSessionHandler.InnerXml.ToString();
					
					typeSessionHandler = configurationScope.DaoSectionHandlers[nodeSessionHandler.Attributes[ID_ATTRIBUTE].Value] as Type;

					// Parse property node
					foreach(XmlNode nodeProperty in nodeSessionHandler.SelectNodes( ApplyNamespacePrefix(XML_PROPERTY), configurationScope.XmlNamespaceManager ))
					{
						resources.Add(nodeProperty.Attributes["name"].Value, 
						              NodeUtils.ParsePropertyTokens(nodeProperty.Attributes["value"].Value, configurationScope.Properties));
					}
				}
				else
				{
					typeSessionHandler = configurationScope.DaoSectionHandlers[DEFAULT_DAOSESSIONHANDLER_NAME] as Type;
				}

				// Configure the sessionHandler
				configurationScope.ErrorContext.ObjectId = typeSessionHandler.FullName;

				try
				{
					sessionHandler =(IDaoSessionHandler)Activator.CreateInstance(typeSessionHandler, EmptyObjects);
				}
				catch(Exception e)
				{
					throw new ConfigurationException(
						string.Format("DaoManager could not configure DaoSessionHandler. DaoSessionHandler of type \"{0}\", failed. Cause: {1}", typeSessionHandler.Name, e.Message),e
						);
				}

				sessionHandler.Configure(configurationScope.Properties,  resources );

				daoManager.DaoSessionHandler = sessionHandler;

				configurationScope.ErrorContext.Resource = string.Empty;
				configurationScope.ErrorContext.MoreInfo = string.Empty;
				configurationScope.ErrorContext.ObjectId = string.Empty;
				#endregion

				#region Build Daos
				ParseDaoFactory(configurationScope, daoManager);
				#endregion

				#region Register DaoManager

				configurationScope.ErrorContext.MoreInfo = "register DaoManager";
				configurationScope.ErrorContext.ObjectId = daoManager.Name;

				DaoManager.RegisterDaoManager(daoManager.Name, daoManager);

				configurationScope.ErrorContext.Resource = string.Empty;
				configurationScope.ErrorContext.MoreInfo = string.Empty;
				configurationScope.ErrorContext.ObjectId = string.Empty;
				#endregion 
			}
		}

		
		/// <summary>
		/// Initialize the list of variables defined in the
		/// properties file.
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		private void ParseGlobalProperties(ConfigurationScope configurationScope)
		{
			XmlNode nodeProperties = configurationScope.NodeContext.SelectSingleNode(ApplyNamespacePrefix(XML_PROPERTIES), configurationScope.XmlNamespaceManager);

			configurationScope.ErrorContext.Activity = "add global properties";

			if (nodeProperties != null)
			{
				if (nodeProperties.HasChildNodes)
				{
					foreach (XmlNode propertyNode in nodeProperties.SelectNodes(ApplyNamespacePrefix(XML_PROPERTY), configurationScope.XmlNamespaceManager))
					{
						XmlAttribute keyAttrib = propertyNode.Attributes[KEY_ATTRIBUTE];
						XmlAttribute valueAttrib = propertyNode.Attributes[VALUE_ATTRIBUTE];

						if ( keyAttrib != null && valueAttrib!=null)
						{
							configurationScope.Properties.Add( keyAttrib.Value,  valueAttrib.Value);
							_logger.Info( string.Format("Add property \"{0}\" value \"{1}\"",keyAttrib.Value,valueAttrib.Value) );
						}
						else
						{
							// Load the file defined by the attribute
							XmlDocument propertiesConfig = Resources.GetAsXmlDocument(propertyNode, configurationScope.Properties); 
							
							foreach (XmlNode node in propertiesConfig.SelectNodes(XML_SETTINGS_ADD))
							{
								configurationScope.Properties[node.Attributes[KEY_ATTRIBUTE].Value] = node.Attributes[VALUE_ATTRIBUTE].Value;
								_logger.Info( string.Format("Add property \"{0}\" value \"{1}\"",node.Attributes[KEY_ATTRIBUTE].Value,node.Attributes[VALUE_ATTRIBUTE].Value) );
							}
						}
					}
				}
				else
				{
					// JIRA-38 Fix 
					// <properties> element's InnerXml is currently an empty string anyway
					// since <settings> are in properties file

					configurationScope.ErrorContext.Resource = nodeProperties.OuterXml.ToString();

					// Load the file defined by the attribute
					XmlDocument propertiesConfig = Resources.GetAsXmlDocument(nodeProperties, configurationScope.Properties); 

					foreach (XmlNode node in propertiesConfig.SelectNodes(XML_SETTINGS_ADD))
					{
						configurationScope.Properties[node.Attributes[KEY_ATTRIBUTE].Value] = node.Attributes[VALUE_ATTRIBUTE].Value;
						_logger.Info( string.Format("Add property \"{0}\" value \"{1}\"",node.Attributes[KEY_ATTRIBUTE].Value,node.Attributes[VALUE_ATTRIBUTE].Value) );
					}					
				}
//				// Load the file defined by the resource attribut
//				XmlDocument propertiesConfig = Resources.GetAsXmlDocument(nodeProperties, configurationScope.Properties); 
//
//				foreach (XmlNode node in propertiesConfig.SelectNodes("/settings/add"))
//				{
//					configurationScope.Properties[node.Attributes["key"].Value] = node.Attributes["value"].Value;
//				}
			}

			configurationScope.ErrorContext.Resource = string.Empty;
			configurationScope.ErrorContext.MoreInfo = string.Empty;
		}


		/// <summary>
		/// Initialize the provider
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		/// <returns>A provider</returns>
		private Provider ParseProvider(ConfigurationScope configurationScope)
		{
			XmlAttribute attribute = null;
			XmlNode node = configurationScope.NodeContext.SelectSingleNode( ApplyNamespacePrefix(XML_DATABASE_PROVIDER), configurationScope.XmlNamespaceManager);

			configurationScope.ErrorContext.Activity = "configure provider";

			if (node != null)
			{
				configurationScope.ErrorContext.Resource = node.OuterXml.ToString();
				// name
				attribute = node.Attributes["name"];

				configurationScope.ErrorContext.ObjectId = attribute.Value;

				if (configurationScope.Providers.Contains(attribute.Value) == true)
				{
					return (Provider)configurationScope.Providers[attribute.Value];
				}
				else
				{
					throw new ConfigurationException(
						string.Format("Error while configuring the Provider named \"{0}\" in the Context named \"{1}\".",
						attribute.Value, configurationScope.NodeContext.Attributes["name"].Value));
				}
			}
			else
			{
				if(configurationScope.Providers.Contains(DEFAULT_PROVIDER_NAME) == true)
				{
					return (Provider) configurationScope.Providers[DEFAULT_PROVIDER_NAME];
				}
				else
				{
					throw new ConfigurationException(
						string.Format("Error while configuring the Context named \"{0}\". There is no default provider.",
						configurationScope.NodeContext.Attributes["name"].Value));
				}
			}
		}


		//		/// <summary>
//		/// Build a provider
//		/// </summary>
//		/// <param name="node"></param>
//		/// <returns></returns>
//		/// <remarks>
//		/// Not use, I use it to test if it faster than serializer.
//		/// But the tests are not concluant...
//		/// </remarks>
//		private static Provider BuildProvider(XmlNode node)
//		{
//			XmlAttribute attribute = null;
//			Provider provider = new Provider();
//
//			attribute = node.Attributes["assemblyName"];
//			provider.AssemblyName = attribute.Value;
//			attribute = node.Attributes["default"];
//			if (attribute != null)
//			{
//				provider.IsDefault = Convert.ToBoolean( attribute.Value );
//			}
//			attribute = node.Attributes["enabled"];
//			if (attribute != null)
//			{
//				provider.IsEnabled = Convert.ToBoolean( attribute.Value );
//			}
//			attribute = node.Attributes["connectionClass"];
//			provider.ConnectionClass = attribute.Value;
//			attribute = node.Attributes["UseParameterPrefixInSql"];
//			if (attribute != null)
//			{
//				provider.UseParameterPrefixInSql = Convert.ToBoolean( attribute.Value );
//			}
//			attribute = node.Attributes["useParameterPrefixInParameter"];
//			if (attribute != null)
//			{
//				provider.UseParameterPrefixInParameter = Convert.ToBoolean( attribute.Value );
//			}
//			attribute = node.Attributes["usePositionalParameters"];
//			if (attribute != null)
//			{
//				provider.UsePositionalParameters = Convert.ToBoolean( attribute.Value );
//			}
//			attribute = node.Attributes["commandClass"];
//			provider.CommandClass = attribute.Value;
//			attribute = node.Attributes["parameterClass"];
//			provider.ParameterClass = attribute.Value;
//			attribute = node.Attributes["parameterDbTypeClass"];
//			provider.ParameterDbTypeClass = attribute.Value;
//			attribute = node.Attributes["parameterDbTypeProperty"];
//			provider.ParameterDbTypeProperty = attribute.Value;
//			attribute = node.Attributes["dataAdapterClass"];
//			provider.DataAdapterClass = attribute.Value;
//			attribute = node.Attributes["commandBuilderClass"];
//			provider.CommandBuilderClass = attribute.Value;
//			attribute = node.Attributes["commandBuilderClass"];
//			provider.CommandBuilderClass = attribute.Value;
//			attribute = node.Attributes["name"];
//			provider.Name = attribute.Value;
//			attribute = node.Attributes["parameterPrefix"];
//			provider.ParameterPrefix = attribute.Value;
//
//			return provider;
//		}


		/// <summary>
		/// Build the data source object
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		/// <returns>A DataSource</returns>
		private DataSource ParseDataSource(ConfigurationScope configurationScope)
		{
			DataSource dataSource = null;
			XmlNode node = configurationScope.NodeContext.SelectSingleNode( ApplyNamespacePrefix(XML_DATABASE_DATASOURCE), configurationScope.XmlNamespaceManager);

			configurationScope.ErrorContext.Resource = node.InnerXml.ToString();
			configurationScope.ErrorContext.MoreInfo = "configure data source";

			dataSource = DataSourceDeSerializer.Deserialize( node );
//				(DataSource)serializer.Deserialize(new XmlNodeReader(node));

			dataSource.ConnectionString = NodeUtils.ParsePropertyTokens(dataSource.ConnectionString, configurationScope.Properties);
			
			configurationScope.ErrorContext.Resource = string.Empty;
			configurationScope.ErrorContext.MoreInfo = string.Empty;
			
			return dataSource;
		}


		/// <summary>
		/// Parse dao factory tag
		/// </summary>
		/// <param name="configurationScope">The scope of the configuration</param>
		/// <param name="daoManager"></param>
		private void ParseDaoFactory(ConfigurationScope configurationScope, DaoManager daoManager)
		{
			Dao dao = null;

			configurationScope.ErrorContext.MoreInfo = "configure dao";
			
			foreach (XmlNode node in configurationScope.NodeContext.SelectNodes(ApplyNamespacePrefix(XML_DAO), configurationScope.XmlNamespaceManager ))
			{
				dao = DaoDeSerializer.Deserialize(node, configurationScope);
					//(Dao) serializer.Deserialize(new XmlNodeReader(node));
				
				configurationScope.ErrorContext.ObjectId = dao.Implementation;

				dao.Initialize(daoManager);
				daoManager.RegisterDao(dao);
			}

			configurationScope.ErrorContext.Resource = string.Empty;
			configurationScope.ErrorContext.MoreInfo = string.Empty;
			configurationScope.ErrorContext.ObjectId = string.Empty;
		}

		/// <summary>
		/// Apply an XML NameSpace
		/// </summary>
		/// <param name="elementName"></param>
		/// <returns></returns>
		public string ApplyNamespacePrefix( string elementName )
		{
			return DAO_NAMESPACE_PREFIX+ ":" + elementName.
				Replace("/","/"+DAO_NAMESPACE_PREFIX+":");
		}

		/// <summary>
		/// Apply the provider namespace prefix
		/// </summary>
		/// <param name="elementName"></param>
		/// <returns></returns>
		public string ApplyProviderNamespacePrefix( string elementName )
		{
			return PROVIDERS_NAMESPACE_PREFIX+ ":" + elementName.
				Replace("/","/"+PROVIDERS_NAMESPACE_PREFIX+":");
		}
		#endregion

	}
}