using System;
using System.Collections;
using System.Text;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.EnterpriseLibrary.Data.Configuration;

namespace Test20050504
{
	public enum DatabaseTypeEnum : int
	{
		SqlServer2000=1, 
		Oracle9i=2,
		Unknown=3,
		SqlServer2005=4, 
	}

	#region GetDatabaseForSelectedConnection
	/// <summary>
	/// Summary description for MPAPELDABUtility.
	/// </summary>
	public class MPAPELDABUtility
	{
		public MPAPELDABUtility()
		{
			//
			// TODO: Add constructor logic here
			//
		}

		/// <summary>
		/// Get an MPAPELDAB Database instance from the supplied DbConnectionInfo
		/// </summary>
		/// <param name="info"></param>
		/// <returns></returns>
		private Database GetDatabaseForSelectedConnection(DbConnectionInfo info)
		{
			if (info==null)
			{
				throw new InvalidOperationException("Choose a connection.");
			}
			else
			{
				DatabaseSettings settings = new DatabaseSettings();

				// This maps to <databaseType> element in data config file

				DatabaseTypeData type = new DatabaseTypeData("Sql Server", "Microsoft.Practices.EnterpriseLibrary.Data.Sql.SqlDatabase, Microsoft.Practices.EnterpriseLibrary.Data, Version=1.0.0.0, Culture=neutral, PublicKeyToken=c97b8fb71b56f638");

				settings.DatabaseTypes.Add(type);

				// This maps to <connectionString> element in data config file

				ConnectionStringData connectionString = new ConnectionStringData(info.ConnectionName);

				// Followings map to <parameter> elements in data config file

				connectionString.Parameters.Add(new ParameterData("server", info.ServerName));
				connectionString.Parameters.Add(new ParameterData("database", info.InitialCatalog));
				connectionString.Parameters.Add(new ParameterData("integrated security", info.UseIntegratedSecurity.ToString()));

				if (info.UseIntegratedSecurity==false)
				{
					connectionString.Parameters.Add(new ParameterData("user id", info.UserName));
					connectionString.Parameters.Add(new ParameterData("password", info.Password));
				}

				settings.ConnectionStrings.Add(connectionString);

				// Too bad compiler gets confused InstanceData with System.Diagnostics.InstanceData.  It maps to <instance> element in data config file

				Microsoft.Practices.EnterpriseLibrary.Data.Configuration.InstanceData instance = 
					new Microsoft.Practices.EnterpriseLibrary.Data.Configuration.InstanceData(
					info.ConnectionName, "Sql Server", info.ConnectionName);

				settings.Instances.Add(instance);

				ConfigurationDictionary configurations = new ConfigurationDictionary();

				// This is how to tie DatabaseSettings with ConfigurationDictionary. 
				// It maps to <configurationSection name="dataConfiguration"> element in App.config file

				configurations.Add("dataConfiguration", settings);

				ConfigurationContext context = ConfigurationManager.CreateContext(configurations);

				Database database = new DatabaseProviderFactory(context).CreateDatabase(info.ConnectionName);

				m_database=database;
				m_databaseName=m_dbConnChooser.DbConnectionInfo.ConnectionName;

				return m_database;
			}
		}
	}
	#endregion GetDatabaseForSelectedConnection

	#region DbConnectionInfo
	/// <summary>
	/// Summary description for DbConnectionInfo.
	/// </summary>
	[Serializable]
	public class DbConnectionInfo
	{
		private string m_connectionName=null;

		private DatabaseTypeEnum m_type=DatabaseTypeEnum.SqlServer2000;

		private string m_userName=String.Empty;
		private string m_password=String.Empty;
		private string m_serverName=String.Empty;
		private string m_initialCatalog=String.Empty;
		private bool m_useIntegratedSecurity=true;

		public DbConnectionInfo()
		{
			this.DatabaseType=DatabaseTypeEnum.SqlServer2000;
		}

		public DbConnectionInfo(
			string connectionName, 
			string connectionString)
		{
			if (connectionName==null ||
				connectionString==null)
			{
				throw new ArgumentNullException();
			}
			else
			{
				m_connectionName=connectionName;
				SetConnectionString(connectionString);
			}
		}

		public DbConnectionInfo(
			string connectionName, 
			DatabaseTypeEnum databaseType)
		{
			if (connectionName==null)
			{
				throw new ArgumentNullException();
			}
			else
			{
				m_connectionName=connectionName;
				this.DatabaseType=databaseType;
			}
		}

		public string ConnectionName
		{
			get
			{
				return m_connectionName;
			}
			set
			{
				if (value==null)
				{
					throw new ArgumentNullException();
				}

				m_connectionName=value;
			}
		}

		public string ConnectionString
		{
			get
			{
				return GetConnectionString();
			}
			set
			{
				if (value==null)
				{
					throw new ArgumentNullException();
				}

				SetConnectionString(value);
			}
		}
	
		public DatabaseTypeEnum DatabaseType
		{
			get
			{
				return m_type;

				/*
					if (m_provider==null)
					{
						return DatabaseTypeEnum.Unknown;
					}
					else if (m_provider=="sqloledb")
					{
						return DatabaseTypeEnum.SqlServer2000;
					}
					else if (m_provider=="msdaora")
					{
						return DatabaseTypeEnum.Oracle9i;
					}
					else
					{
						return DatabaseTypeEnum.Unknown;
					}
					*/
			}
			set
			{
				m_type=value;
				
				/*
					if (value==DatabaseTypeEnum.Unknown)
					{
						m_provider=String.Empty;
					}
					else if (value==DatabaseTypeEnum.SqlServer2000)
					{
						m_provider="sqloledb";
					}
					else if (value==DatabaseTypeEnum.Oracle9i)
					{
						m_provider="msdaora";
					}
					*/
			}
		}

		public string UserName
		{
			get { return m_userName; }
			set { m_userName = value; }
		}

		public string Password
		{
			get { return m_password; }
			set { m_password = value; }
		}

		public string ServerName
		{
			get { return m_serverName; }
			set { m_serverName = value; }
		}

		public string InitialCatalog
		{
			get { return m_initialCatalog; }
			set { m_initialCatalog = value; }
		}

		public bool UseIntegratedSecurity
		{
			get { return m_useIntegratedSecurity; }
			set { m_useIntegratedSecurity = value; }
		}

		private string GetConnectionString()
		{
			// Data Source=(local);Integrated Security=true;Database=ebcs;

			StringBuilder sb=new StringBuilder();
			
			sb.Append("Data Source=");
			sb.Append(m_serverName);
			sb.Append(";");

			sb.Append("Initial Catalog=");
			sb.Append(m_initialCatalog);
			sb.Append(";");

			if (m_useIntegratedSecurity==false)
			{
				sb.Append("User ID=");
				sb.Append(m_userName);
				sb.Append(";");

				sb.Append("Password=");
				sb.Append(m_password);
				sb.Append(";");
			}
			else
			{
				sb.Append("Integrated Security=SSPI;");
			}

			return sb.ToString();
		}

		private void SetConnectionString(string connstr)
		{
			Hashtable connStringKeys=new Hashtable();

			string[] keysBySemicolon=connstr.Split(';');

			string[] keysByEquals;

			foreach(string keySemicolon in keysBySemicolon)
			{
				keysByEquals=keySemicolon.Split('=');

				if (keysByEquals.Length==0)
				{
					// do nothing
				}
				else if (keysByEquals.Length==1)
				{
					// assume key name but no value

					connStringKeys.Add(keysByEquals[0].ToUpper(), "");
				}
				else 
				{
					connStringKeys.Add(keysByEquals[0].ToUpper(), keysByEquals[1]);
				}
			}

			if (connStringKeys.ContainsKey("DATA SOURCE")==true)
			{
				m_serverName=(string)connStringKeys["DATA SOURCE"];
			}
			else
			{
				m_serverName="";
			}

			if (connStringKeys.ContainsKey("DATABASE")==true)
			{
				m_initialCatalog=(string)connStringKeys["DATABASE"];
			}
			else
			{
				m_initialCatalog="";
			}

			if (connStringKeys.ContainsKey("INITIAL CATALOG")==true)
			{
				m_initialCatalog=(string)connStringKeys["INITIAL CATALOG"];
			}
			else
			{
				m_initialCatalog="";
			}
			
			if (connStringKeys.ContainsKey("USER ID")==true)
			{
				m_userName=(string)connStringKeys["USER ID"];
			}
			else
			{
				m_userName="";
			}

			if (connStringKeys.ContainsKey("PASSWORD")==true)
			{
				m_password=(string)connStringKeys["PASSWORD"];
			}
			else
			{
				m_password="";
			}
			
			if (connStringKeys.ContainsKey("INTEGRATED SECURITY")==true)
			{
				m_useIntegratedSecurity=true;
			}
			else
			{
				m_useIntegratedSecurity=false;
			}



		}


		public override string ToString()
		{
			if (this.DatabaseType==DatabaseTypeEnum.SqlServer2000)
			{
				return m_connectionName + " (SqlServer2000)";
			}
			else if (this.DatabaseType==DatabaseTypeEnum.SqlServer2005)
			{
				return m_connectionName + " (SqlServer2005)";
			}
			else if (this.DatabaseType==DatabaseTypeEnum.Oracle9i)
			{
				return m_connectionName + " (Oracle)";
			}
			else
			{
				return m_connectionName + " (Unknown Database Type)";
			}

		}

	
	} // end of class
	#endregion DbConnectionInfo
}