BSEtunes

using System;

using BSE.Configuration;
using System.Globalization;
using BSE.Platten.BO.Properties;

namespace BSE.Platten.BO
{
	/// <summary>
	/// Zusammenfassung f�r CEnvironment.
	/// </summary>
	public class CEnvironment
	{
        #region Konstanten

        private const string m_strApplicationDataPath = "BSE";
        private const string m_strAssemblySettingsPart = "Settings";

        #endregion

        #region FieldsPrivate

        private string m_strUserName;
        private string m_strPassword;
        private string m_strDataBaseHost;
        private int m_iDataBasePort;
        private CUserGrant m_userGrant;
        private CConfiguration m_configuration;
		
		#endregion
		
		#region Properties

        /// <summary>
        /// Setzt den Namen des Benutzers oder ruft diesen ab
        /// </summary>
        public string UserName
        {
            get
            {
                if (String.IsNullOrEmpty(this.m_strUserName) == true)
                {
                    this.m_strUserName = System.Environment.UserName;
                }
                return this.m_strUserName;
            }
            set { this.m_strUserName = value; }
        }
        /// <summary>
        /// Setzt das Passwort des Benutzers oder ruft dieses ab
        /// </summary>
        public string Password
        {
            set { this.m_strPassword = value; }
            get { return this.m_strPassword; }
        }
        /// <summary>
        /// Setzt den Datenbank- Host oder ruft diesen ab
        /// </summary>
        public string DataBaseHost
        {
            get
            {
                if (String.IsNullOrEmpty(this.m_strDataBaseHost) == true)
                {
                    this.m_strDataBaseHost = GetDataBaseHost();
                }
                return this.m_strDataBaseHost;
            }
            set
            {
                this.m_strDataBaseHost = value;
            }
        }
        /// <summary>
        /// Setzt den TCP/IP Port des Datenbankservers bzw. ruft diesen ab
        /// </summary>
        public int DataBasePort
        {
            set { this.m_iDataBasePort = value; }
            get
            {
                if (this.m_iDataBasePort == 0)
                {
                    this.m_iDataBasePort = GetDataBasePort();
                }
                return this.m_iDataBasePort;
            }
        }
        /// <summary>
        /// Setzt die Berechtigungen des Benutzers oder ruft diese ab
        /// </summary>
        public CUserGrant UserGrant
        {
            get { return this.m_userGrant; }
            set { this.m_userGrant = value; }
        }
		#endregion

		#region MethodsPublic
        /// <summary>
        /// Konstruktor von CEnvironment
        /// </summary>
		public CEnvironment()
		{
		}
        /// <summary>
        /// Konstruktor von CEnvironment
        /// </summary>
        /// <param name="configuration">Konfiguration der Anwendung als BSE.Configuration.CConfiguration</param>
        public CEnvironment(BSE.Configuration.CConfiguration configuration)
            : this()
        {
            this.m_configuration = configuration;
        }
        /// <summary>
        /// Holt die Konfiguration der Anwendung
        /// </summary>
        /// <returns>Konfiguration als BSE.Configuration.CConfiguration</returns>
        public BSE.Configuration.CConfiguration GetConfiguration()
        {
            CConfiguration configuration = null;
            if (this.m_configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            else
            {
                configuration = this.m_configuration;
            }
            return configuration;
        }
        public int GetDataBasePort()
        {
            if (this.m_configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            return GetDataBasePort(this.m_configuration);
        }
        public static int GetDataBasePort(BSE.Configuration.CConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            
            int iDataBasePort = 3306;
            try
            {
                BSE.Configuration.CVisualObject visualObject = new BSE.Configuration.CVisualObject();
                visualObject.Element = "databaseport";
                visualObject.Description = string.Format(CultureInfo.CurrentCulture,Resources.IDS_ConfigurationNoTcpIpPortLabel);
                visualObject.VisualObjectType = BSE.Configuration.CVisualObjectType.OpenNumericUpDown;
                visualObject.ErrorMessage = string.Format(CultureInfo.CurrentUICulture, Resources.IDS_ConfigurationNoTcpIpPortException, iDataBasePort);

                string strDataBasePort = configuration.GetValue(BSE.Configuration.CConfiguration.VisualObjectsElementName, visualObject).ToString();
                if (String.IsNullOrEmpty(strDataBasePort) == false)
                {
                    iDataBasePort = Convert.ToInt32(strDataBasePort,CultureInfo.InvariantCulture);
                }
                return iDataBasePort;
            }
            catch (BSE.Configuration.CConfigurationValueNotFoundException)
            {
                throw;
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// ruft den Datenbank- Host ab
        /// </summary>
        /// <returns>Name des Datenbankhostes als string</returns>
        public string GetDataBaseHost()
        {
            if (this.m_configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            return GetDataBaseHost(this.m_configuration);
        }
        /// <summary>
        /// ruft den Datenbank- Host ab
        /// </summary>
        /// <param name="configuration">Konfiguration als BSE.Configuration.CConfiguration</param>
        /// <returns>Name des Datenbankhostes als string</returns>
        public static string GetDataBaseHost(BSE.Configuration.CConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            
            string strDataBaseHost = null;
            try
            {
                BSE.Configuration.CVisualObject visualObject = new BSE.Configuration.CVisualObject();
                visualObject.Element = "databasehost";
                visualObject.Description = string.Format(CultureInfo.CurrentCulture,Resources.IDS_ConfigurationNoDataBaseLabel);
                visualObject.VisualObjectType = BSE.Configuration.CVisualObjectType.OpenTextBox;
                visualObject.ErrorMessage = string.Format(CultureInfo.CurrentCulture,Resources.IDS_ConfigurationNoDataBaseException);

                strDataBaseHost = configuration.GetValue(BSE.Configuration.CConfiguration.VisualObjectsElementName, visualObject).ToString();

                return strDataBaseHost;
            }
            catch (BSE.Configuration.CConfigurationValueNotFoundException)
            {
                throw;
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// ruft den Connectionstring zur Datenbank ab
        /// </summary>
        /// <returns>Connectionstring</returns>
        public string GetConnectionString()
        {
            if (this.m_configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            return GetConnectionString(this.m_configuration);
        }
        /// <summary>
        /// ruft den Connectionstring zur Datenbank ab
        /// </summary>
        /// <param name="configuration">Konfiguration als BSE.Configuration.CConfiguration</param>
        /// <returns>Connectionstring</returns>
        public string GetConnectionString(BSE.Configuration.CConfiguration configuration)
        {
            string strConnectionString = null;
            if (String.IsNullOrEmpty(m_strPassword) == true)
            {
                strConnectionString = string.Format(CultureInfo.InvariantCulture,"server={0};user id={1}; password={2}; Port={3}; database=platten; pooling=false;",
                    GetDataBaseHost(configuration),
                    this.UserName,
                    "",
                    GetDataBasePort(configuration));
            }
            else
            {
                strConnectionString = string.Format(CultureInfo.InvariantCulture,"server={0};user id={1}; password={2}; Port={3}; database=platten; pooling=false",
                    this.DataBaseHost,
                    this.UserName,
                    this.Password,
                    this.DataBasePort);
            }
            return strConnectionString;
        }
        /// <summary>
        /// ruft den Root- Verzeichnis f�r die Audiofiles ab
        /// </summary>
        /// <returns>Rootverzeichnis als String</returns>
        public string GetAudioHomeDirectory()
        {
            if (this.m_configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            return GetAudioHomeDirectory(this.m_configuration);
        }
        /// <summary>
        /// ruft den Root- Verzeichnis f�r die Audiofiles ab
        /// </summary>
        /// <param name="configuration">Konfiguration als BSE.Configuration.CConfiguration</param>
        /// <returns>Rootverzeichnis als String</returns>
        public static string GetAudioHomeDirectory(BSE.Configuration.CConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "configuration"));
            }
            
            string strAudioHomeDirectory = null;
            try
            {
                BSE.Configuration.CVisualObject visualObject = new BSE.Configuration.CVisualObject();
                visualObject.Element = "dirmp3";
                visualObject.Description = string.Format(CultureInfo.CurrentCulture,Resources.IDS_ConfigurationNoAudioDirectoryLabel);
                visualObject.VisualObjectType = BSE.Configuration.CVisualObjectType.OpenFolderBrowseDialog;
                visualObject.ErrorMessage = string.Format(CultureInfo.CurrentCulture, Resources.IDS_ConfigurationNoAudioDirectoryException);

                strAudioHomeDirectory = configuration.GetValue(BSE.Configuration.CConfiguration.VisualObjectsElementName, visualObject).ToString();

                if (!strAudioHomeDirectory.EndsWith(System.IO.Path.DirectorySeparatorChar.ToString()))
                {
                    strAudioHomeDirectory += System.IO.Path.DirectorySeparatorChar;
                }
                return strAudioHomeDirectory;
            }
            catch (BSE.Configuration.CConfigurationValueNotFoundException)
            {
                throw;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public static string RemoveInvalidFolderChars(string strFolderName)
        {
            char[] invalidFileChars = System.IO.Path.GetInvalidFileNameChars();

            int iIndex = strFolderName.IndexOfAny(invalidFileChars);
            if (iIndex != -1)
            {
                foreach (char invalidChar in invalidFileChars)
                {
                    strFolderName = strFolderName.Replace(invalidChar.ToString(), "");
                }
            }

            // Entferne alle . am Ende des Strings weil Windows diese sonst automatisch entfernt.
            strFolderName = strFolderName.TrimEnd('.');
            // Entferne alle . am Anfang des Strings weil Windows sonst meckert.
            strFolderName = strFolderName.TrimStart('.');
            
            return strFolderName;
        }

        public static string RemoveInvalidPathChars(string strPath)
        {
            if (strPath == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "strPath"));
            }

            char[] invalidPathChars = System.IO.Path.GetInvalidPathChars();

            int iIndex = strPath.IndexOfAny(invalidPathChars);
            if (iIndex != -1)
            {
                foreach (char invalidChar in invalidPathChars)
                {
                    strPath = strPath.Replace(invalidChar.ToString(), "");
                }
            }
            return strPath;
        }

        public static string ParseOutInvalidFileNameChars(string strPathOrFileName)
        {
            if (strPathOrFileName == null)
            {
                throw new ArgumentNullException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    Resources.IDS_ArgumentException,
                    "strPathOrFileName"));
            }
            
            // die abschliessenden . werden, falls vorhanden entfernt
            int iIndexLastChar = strPathOrFileName.IndexOf(
                '.',
                strPathOrFileName.Length - 1);
            if (iIndexLastChar != -1)
            {
                strPathOrFileName = strPathOrFileName.Remove(
                    iIndexLastChar,
                    1);

                strPathOrFileName = ParseOutInvalidFileNameChars(
                    strPathOrFileName);
            }
            // alle nicht erlaubten Zeichen werden entfernt
            int iIndex = strPathOrFileName.IndexOfAny(
                System.IO.Path.GetInvalidFileNameChars());
            if (iIndex != -1)
            {
                strPathOrFileName = strPathOrFileName.Remove(
                    iIndex,
                    1);

                strPathOrFileName = ParseOutInvalidFileNameChars(
                    strPathOrFileName);
            }

            return strPathOrFileName;
        }

		#endregion

	}
}