//----------------------------------------------------------------------------
//
// Copyright © 2009-2012, Intel Corporation. All rights reserved.
//
// File:        ConnectionSettings.cs
//
//----------------------------------------------------------------------------

using System;
using System.Windows.Forms;
using System.ComponentModel;
using System.Text.RegularExpressions;
using UCT.Utils;
using System.Collections.Generic;
using System.Security;
using Intel.Management.Wsman;
using Common.Utils;

namespace UCT.Forms
{
    /// <summary>
    /// Form that treat the connection settings
    /// </summary>
    public partial class ConnectionSettings : BaseForm
    {
        #region - Private Members -

        private bool _validHost;
        private bool _validProxyHost;
        private bool _validUserName;
        private bool _validPassword;
        private bool _validCIRA = true;
        private bool _validTLS = true;
        private bool _connectionCancel; // Indicate whether the user cancel the conncetion progress bar
        private string _errorMessage = string.Empty;
        private ProgressBarWindow _progressWindow;
        private ConnectionHistory _history;
        private List<Connection> _historyList;
        private Connection _curConnectionInfo;

        #endregion

        #region - Constructors -

        /// <summary>
        /// Default Constructor
        /// </summary>
        public ConnectionSettings()
        {
            InitializeComponent();

            // Load the history list
            InitializeHistory();

            // Load the saved connection settings 
            LoadDefaultSettings();

            // Disable / Enable the Cira parameters
            EnableCIRAParams(cbCIRA.Checked);

            // Validate the input (Hostname, Username, password)
            ValidateHostName(tbHostName);
            ValidateUserName();
            ValidatePassword();
        }

        private void LoadHistory()
        {
            tbHostName.Items.Clear();
            foreach (Connection con in _historyList)
            {
                tbHostName.Items.Add(con);
                tbHostName.DisplayMember = "HostName";
            }
        }

        /// <summary>
        /// Constructor that get ConnectionInfo object and fill the connection data.
        /// This constructor is used when opening the application via command line and 
        /// specified parameters.
        /// </summary>
        /// <param name="conArgs">ConnectionInfo object that hold the data</param>
        public ConnectionSettings(IWsmanConnection conArgs)
        {
            InitializeComponent();

            InitializeHistory();

            string ipAddress = "";
            if (conArgs.Address.StartsWith("https"))
            {
                ipAddress = conArgs.Address.Substring(8, conArgs.Address.Length - 8);
            }
            else if (conArgs.Address.StartsWith("http"))
            {
                ipAddress = conArgs.Address.Substring(7, conArgs.Address.Length - 7);
            }
            if (ipAddress.Contains(":"))
            {
                int index = ipAddress.IndexOf(":");
                ipAddress = ipAddress.Substring(0, index);
            }

            tbHostName.Text = ipAddress;
            tbUserName.Text = conArgs.Username;
            tbPassword.Text = conArgs.Password.ConvertToString();

            // Validating and filling TLS parameters
            if (!conArgs.Address.Contains("https"))
            {
                rbNoneTLS.Checked = true;
            }
            else
            {
                if (null != conArgs.Options.ClientCertificate)
                {
                    rbMTLS.Checked = true;
                    EnableTLSParams(true);
                    tbCertWithKey.Text = Configuration.CertificateSettings.GetInstance().PersonalCertificate;  //to check
                }
                else
                {
                    rbServerTLS.Checked = true;
                }
            }

            // Validating and filling authentication parameters
            if (conArgs.AuthenticationScheme.CompareTo("Digest") == 0)
            {
                rbDigest.Checked = true;
            }
            else
            {
                rbKerberos.Checked = true;
                ValidateKerberos();
            }

            tbCertWithKey.Text = Configuration.CertificateSettings.GetInstance().PersonalCertificate; //to check

            //Validating and filling proxy parameters
            EnableCIRAParams(cbCIRA.Checked = (!string.IsNullOrEmpty(conArgs.Options.ProxyAddress)));
            if (!string.IsNullOrEmpty(conArgs.Options.ProxyAddress))
            {
                tbProxyHostName.Text = conArgs.Options.ProxyAddress;
                int index = conArgs.Options.ProxyAddress.LastIndexOf(":") + 1;
                string port = conArgs.Options.ProxyAddress.Substring(index, conArgs.Options.ProxyAddress.Length - index);
                tbProxyPort.Text = port;

                tbProxyUserName.Text = !string.IsNullOrEmpty(conArgs.Options.ProxyUser) ? conArgs.Options.ProxyUser : null;

                // Convert password from secure string to comply with wsman dll which supports passwords in SecureString
                // format only.
                tbProxyPassword.Text = !string.IsNullOrEmpty(conArgs.Options.ProxyPassword.ConvertToString()) ? conArgs.Options.ProxyPassword.ConvertToString() : null;

                ValidateCiraParameters();
            }
        }

        private void InitializeHistory()
        {
            // Create history object
            _history = new ConnectionHistory();
            _historyList = _history.LoadConnections();

            LoadHistory();
        }

        #endregion

        #region - Methods -

        #region SETTINGS AND CONNECTION METHODS

        /// <summary>
        /// Loading the default settings from the setting file
        /// </summary>
        private void LoadDefaultSettings()
        {
            try
            {
                // Write the operation to the log
                LogManager.WriteOperation(LogLevel.DETAILED, Properties.Resources.LOADING_DEFAULT_SETTINGS, LogInteraction.Information);

                // Loading and filling the basic connection parameters 
                tbHostName.Text = Properties.Settings.Default.HOST_NAME;
                tbUserName.Text = Properties.Settings.Default.USER_NAME;
                rbKerberos.Checked = Properties.Settings.Default.KRB_ENABLE;

                //  Loading and filling TLS parameters 
                if (!(rbServerTLS.Checked = Properties.Settings.Default.TLS_ENABLE) &&
                    !(rbMTLS.Checked = Properties.Settings.Default.MTLS_ENABLE))
                {
                    rbNoneTLS.Checked = true;
                }
                tbCertWithKey.Text = Properties.Settings.Default.CLIENT_CERTIFICATE;
                rbDigest.Checked = !Properties.Settings.Default.KRB_ENABLE;
                tbCertWithKey.Text = Properties.Settings.Default.CLIENT_CERTIFICATE;

                //  Loading and filling the basic connection parameters 
                if (Properties.Settings.Default.USE_CIRA)
                {
                    cbCIRA.Checked = true;
                    tbProxyHostName.Text = Properties.Settings.Default.PROXY_HOSTNAME;
                    tbProxyPort.Text = Properties.Settings.Default.PROXY_PORT;
                    tbProxyUserName.Text = Properties.Settings.Default.PROXY_USERNAME;
                }
            }
            catch { }
        }

        /// <summary>
        /// Set the state of "Connect" (Disable/Enable) button according the input validation
        /// </summary>
        private void SetConnectionState()
        {
            if (_validHost && _validCIRA && _validTLS)
            {
                if (rbDigest.Checked)
                {
                    if (_validPassword && _validUserName)
                    {
                        SetButtonStyle(true);
                    }
                    else
                    {
                        SetButtonStyle(false);
                    }
                }
                else // Kerberos Authentication
                {
                    if ((_validPassword && _validUserName) ||
                        (tbPassword.Text == string.Empty && tbUserName.Text == string.Empty))
                    {
                        SetButtonStyle(true);
                    }
                    else
                    {
                        SetButtonStyle(false);
                    }
                }
            }
            else
            {
                SetButtonStyle(false);
            }
        }

        /// <summary>
        /// Set the style of "Connect" button (Change his color when button should be grayed out and vice versa)
        /// </summary>
        /// <param name="isEnable"></param>
        private void SetButtonStyle(bool isEnable)
        {
            btnConnect.Enabled = isEnable;
            if (isEnable)
            {
                btnConnect.ButtonColor = System.Drawing.Color.Black;
            }
            else
            {
                btnConnect.ButtonColor = System.Drawing.Color.FromArgb(64, 64, 64);
            }
        }

        /// <summary>
        /// Trying to connect to AMT machine 
        /// </summary>
        private void Connect()
        {
            try
            {
                _connectionCancel = false;
                LogManager.WriteOperation(LogLevel.BASIC, string.Format(Properties.Resources.CONNECTING_TO, tbHostName.Text), LogInteraction.UserOperation);
                RetrieveConnectionObjFromGUI();
                _progressWindow = new ProgressBarWindow(new ProgressDelegate(ConnectToAMT),
                                                       Properties.Resources.TRYING_TO_CONNECT, null,
                                                       string.Format(Properties.Resources.CONNECTING_TO, tbHostName.Text),
                                                       true, false, false);
                {
                    if (_progressWindow.ShowDialog(this) == DialogResult.Ignore)
                    {
                        _connectionCancel = true;
                    }
                    this.Refresh();
                }
                if (DialogResult != DialogResult.OK)
                {
                    LogManager.WriteOperation(LogLevel.BASIC, string.Format(Properties.Resources.FAILED_TO_CONNECT, tbHostName.Text), LogInteraction.Information);
                    _errorMessage = (_errorMessage.Equals(string.Empty)) ? Properties.Resources.CANCEL_CONNECTION_BY_USER : _errorMessage;
                    LogManager.WriteOperation(LogLevel.DETAILED, string.Format(Properties.Resources.EXCEPTION_WAS_THROWN, _errorMessage), LogInteraction.Error);
                    if (DialogResult != DialogResult.Ignore)
                    {
                        AMT_SW_GUI.MessageManager.ShowMessage(_errorMessage, Properties.Resources.CANCEL_CONNECTION_PROGRESS_BAR_MESSAGE, this);
                    }
                }
                else
                {
                    LogManager.WriteOperation(LogLevel.BASIC, string.Format(Properties.Resources.SUCCESSFULLY_CONNECTED_TO, tbHostName.Text), LogInteraction.Connection);
                    Close();
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message + "Connection Failed");
            }
        }

        /// <summary>
        /// BackgroundWorker - Running progress bar when trying to connect
        /// </summary>
        /// <param name="worker"></param>
        /// <param name="e"></param>
        /// <param name="obj"></param>
        private void ConnectToAMT(BackgroundWorker worker, DoWorkEventArgs e, object[] obj)
        {
            try
            {
                LogManager.WriteOperation(LogLevel.DETAILED, Properties.Resources.SAVING_PARAMETER_FOR_NEXT_EXECUTION, LogInteraction.Information);
                if (Configuration.GetInstance().InitWSManClient() != UCT.ConnectionStatus.Connected)
                {
                    DialogResult = DialogResult.Ignore;
                    return;
                }
                if (!_connectionCancel) // Ensure the connection progress didn't stop
                {
                    if (CertificateUtils.ValidateCertificate())
                    {
                        Utilities.SaveConfigFile(_curConnectionInfo);
                        this.DialogResult = DialogResult.OK;
                    }
                    else
                    {
                        this.DialogResult = DialogResult.Ignore;
                    }
                }
            }
            catch (Exception ex)
            {
                this.DialogResult = DialogResult.Cancel;
                this._errorMessage = ex.Message;
            }
        }

        #endregion

        #region EVENT HANDLER METHODS

        /// <summary>
        /// Validating host name
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbHostName_TextChanged(object sender, EventArgs e)
        {
            _validHost = ValidateHostName(tbHostName);
            SetConnectionState();
        }

        /// <summary>
        /// Validating proxy host name content
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbProxyHostName_TextChanged(object sender, EventArgs e)
        {
            _validProxyHost = ValidateHostName(tbProxyHostName);
            ValidateCiraParameters();
        }

        /// <summary>
        /// Validating user name content
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbUserName_TextChanged(object sender, EventArgs e)
        {
            ValidateUserName();
            SetConnectionState();
        }

        /// <summary>
        /// Validating password content
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbPassword_TextChanged(object sender, EventArgs e)
        {
            ValidatePassword();
            SetConnectionState();
        }

        /// <summary>
        /// Validating proxy parameters
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ProxyParameters_TextChanged(object sender, EventArgs e)
        {
            ValidateCiraParameters();

            if (!String.IsNullOrEmpty(tbProxyPort.Text))
            {
                try
                {
                    ushort port = ushort.Parse(tbProxyPort.Text);
                }
                catch (Exception)
                {
                    errorProvider.SetError(tbProxyPort, Properties.Resources.ILLEGAL_PORT_FORMAT);
                    _validCIRA = false;
                }
            }
            SetConnectionState();
        }

        /// <summary>
        /// Use CIRA check box - checked change event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbCIRA_CheckedChanged(object sender, EventArgs e)
        {
            if (((CheckBox)sender).Checked)
            {
                EnableCIRAParams(true);
                ValidateCiraParameters();
            }
            else
            {
                EnableCIRAParams(false);

                tbProxyHostName.Clear();
                tbProxyPort.Clear();
                tbProxyUserName.Clear();
                tbProxyPassword.Clear();

                errorProvider.SetError(tbProxyHostName, String.Empty);
                errorProvider.SetError(tbProxyUserName, String.Empty);
                errorProvider.SetError(tbProxyPort, String.Empty);
                errorProvider.SetError(tbProxyPort, String.Empty);
                _validCIRA = true;
            }
            SetConnectionState();
        }

        /// <summary>
        /// Use TLS check box - checked change event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbTLS_CheckedChanged(object sender, EventArgs e)
        {
            if (rbMTLS.Checked)
            {
                EnableTLSParams(true);
                cbAcceptSelfSignedCert.Enabled = true;
            }
            else
            {
                EnableTLSParams(false);
                errorProvider.SetError(tbCertWithKey, String.Empty);
                tbCertWithKey.Text = String.Empty;
                _validTLS = true;
                if (rbServerTLS.Checked)
                {
                    cbAcceptSelfSignedCert.Enabled = true;
                }
                else
                {
                    cbAcceptSelfSignedCert.Enabled = false;
                }
            }
            SetConnectionState();
        }

        /// <summary>
        /// "Kerberos" radio button - checked
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbKerberos_CheckedChanged(object sender, EventArgs e)
        {
            if (rbKerberos.Checked)
            {
                tbUserName.MaxLength = 512;
                if (!String.IsNullOrEmpty(tbHostName.Text))
                {
                    ValidateHostName(tbHostName);
                }
                ValidateKerberos();
            }
            else
            {
                tbUserName.MaxLength = 16;
                ValidateUserName();
                ValidatePassword();
            }
            SetConnectionState();
        }

        /// <summary>
        /// "Cancel" button - click event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCancel_Click(object sender, EventArgs e)
        {
            LogManager.WriteOperation(LogLevel.BASIC, Properties.Resources.APPLICATION_WAS_TERMINATED_BY_THE_USER, LogInteraction.Information);
            this.Close();
        }

        /// <summary>
        /// "Connect" button click event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                AddConnectionToHistoryList();

                Configuration.BasicSettings.GetInstance().AmtHost = tbHostName.Text;
                Configuration.BasicSettings.GetInstance().AmtPassword = tbPassword.Text.ConvertToSecureString();
                Configuration.BasicSettings.GetInstance().AmtUsername = tbUserName.Text;
                Configuration.BasicSettings.GetInstance().KerberosEnable = rbKerberos.Checked;

                // TLS parameters
                Configuration.BasicSettings.GetInstance().TlsEnable = !rbNoneTLS.Checked;
                Configuration.CertificateSettings.GetInstance().PersonalCertificate = rbMTLS.Checked ? tbCertWithKey.Text : string.Empty;

                // CIRA parameters
                Configuration.GetInstance().Basic.CIRAEnable = cbCIRA.Checked;
                Configuration.ProxySettings.GetInstance().ProxyHostHttp = cbCIRA.Checked ? tbProxyHostName.Text : string.Empty;
                Configuration.ProxySettings.GetInstance().ProxyPortHttp = cbCIRA.Checked ? ushort.Parse(tbProxyPort.Text) : ushort.MinValue;
                Configuration.ProxySettings.GetInstance().ProxyUsernameHttp = cbCIRA.Checked ? tbProxyUserName.Text : string.Empty;
                Configuration.ProxySettings.GetInstance().ProxyPasswordHttp = cbCIRA.Checked ? tbProxyPassword.Text.ConvertToSecureString() : null;

                //Using Self-Signed certificate
                Configuration.acceptSelfSignedCert = cbAcceptSelfSignedCert.Checked;
                Connect();

            }
            catch(Exception ex)
            {
                LogManager.WriteOperation(LogLevel.BASIC, string.Format(Properties.Resources.FAILED_TO_CONNECT, tbHostName.Text), LogInteraction.Error);
                AMT_SW_GUI.MessageManager.ShowErrorMessage(ex.Message, "Connection Failed", this);
            }
        }

        /// <summary>
        /// Add the new machine settings to the history list
        /// </summary>
        private void AddConnectionToHistoryList()
        {
            try
            {
                ushort port = 0;
                if (tbProxyPort.Text != string.Empty)
                    port = (ushort)Convert.ToInt32(tbProxyPort.Text);

                Connection con = new Connection(tbHostName.Text, tbUserName.Text, rbKerberos.Checked, rbServerTLS.Checked, rbMTLS.Checked,
                                                tbCertWithKey.Text, cbCIRA.Checked, tbProxyHostName.Text, port, tbProxyUserName.Text, tbProxyPassword.Text);

                if (_history.CheckExistingConnectionInfo(con))
                {
                    if (AMT_SW_GUI.MessageManager.ShowQuestionMessage("The history list already contains settings for this host.\n" +
                                                                      "Would you like to replace the existing settings?",
                                                                      "Confirm Settings Replace") == DialogResult.Yes)
                    {
                        _history.ReplaceConnectionInfo(con);
                    }
                }
                LoadHistory();
            }
            catch(Exception ex)
            {
                throw new Exception(ex.Message + "Failed to add connection to history list");
            }
        }

        /// <summary>
        /// "About user consent tool" link - click event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void linkLabelAboutUCT_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            (new AboutUCT()).ShowDialog(this);
        }

        /// <summary>
        /// Button help click
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnHelp_Click(object sender, EventArgs e)
        {
            Utilities.DisplayHelpDocument(this);
        }

        /// <summary>
        /// Handel selected index change of the host name combobox
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbHostName_SelectedIndexChanged(object sender, EventArgs e)
        {
            Connection curCon = _historyList[tbHostName.SelectedIndex];
            tbUserName.Text = curCon.UserName;
            rbKerberos.Checked = curCon.KerberosEnable;

            //  Loading and filling TLS parameters 
            if (!(rbServerTLS.Checked = curCon.TLSEnable) &&
                !(rbMTLS.Checked = curCon.MTLSEnable))
            {
                rbNoneTLS.Checked = true;
            }
            tbCertWithKey.Text = curCon.ClientCertificate;
            rbDigest.Checked = !curCon.KerberosEnable;

            //  Loading and filling the basic connection parameters 
            cbCIRA.Checked = curCon.CiraEnable;
            tbProxyHostName.Text = (curCon.CiraEnable) ? curCon.ProxyHost : string.Empty;
            tbProxyPort.Text = (curCon.CiraEnable) ? curCon.ProxyPort.ToString() : string.Empty;
            tbProxyUserName.Text = (curCon.CiraEnable) ? curCon.ProxyUserName : string.Empty;
        }

        /// <summary>
        /// Handel click event on the clear all field button
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnClearFields_Click(object sender, EventArgs e)
        {
            tbHostName.Text = tbUserName.Text = tbPassword.Text =
            tbCertWithKey.Text = tbProxyPassword.Text = tbProxyPort.Text =
            tbProxyUserName.Text = tbProxyHostName.Text = string.Empty;
            rbDigest.Checked = rbNoneTLS.Checked = true;
            cbCIRA.Checked = false;
        }

        private delegate void GetParamsFromGUI_D();

        private void RetrieveConnectionObjFromGUI()
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new GetParamsFromGUI_D(RetrieveConnectionObjFromGUI));
            }
            else
            {
                ushort port = 0;
                if (tbProxyPort.Text != string.Empty)
                    port = (ushort)Convert.ToInt32(tbProxyPort.Text);

                _curConnectionInfo = new Connection(tbHostName.Text, tbUserName.Text,
                                      rbKerberos.Checked, rbServerTLS.Checked, rbMTLS.Checked,
                                      tbCertWithKey.Text, cbCIRA.Checked, tbProxyHostName.Text,
                                      port, tbProxyUserName.Text, tbProxyPassword.Text);

            }
        }

        #endregion

        #region INPUT VALIDATION

        /// <summary>
        /// Validate the host name parameter
        /// </summary>
        /// <param name="host"></param>
        /// <returns>Indicate if the host name is valid or not</returns>
        private bool ValidateHostName(Control host)
        {
            bool validHost = true;
            if (string.IsNullOrEmpty(host.Text.Trim()))
            {
                errorProvider.SetError(host, string.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.HOST_STRING));
                validHost = false;
            }
            else
            {
                if (!Utilities.IsValidFQDN(host.Text) && !Utilities.IsValidIPV4(host.Text) && !Utilities.IsValidIPV6(host.Text))
                {
                    errorProvider.SetError(host, Properties.Resources.ILLEGAL_ADDRESS_ERROR);
                    validHost = false;
                }
                else
                {
                    errorProvider.SetError(host, String.Empty);
                    validHost = true;
                }
            }
            return validHost;
        }

        /// <summary>
        /// Validate the user name parameter
        /// </summary>
        private void ValidateUserName()
        {
            if (rbKerberos.Checked)
            {
                ValidateKerberos();
                return;
            }
            if (string.IsNullOrEmpty(tbUserName.Text.Trim()))
            {
                errorProvider.SetError(tbUserName, string.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.USER_NAME_STRING));
                _validUserName = false;
            }
            else
            {
                if (!Utilities.IsValidUserName(tbUserName.Text))
                {
                    errorProvider.SetError(tbUserName, Properties.Resources.ILLEGAL_USERNAME_ERROR);
                    _validUserName = false;
                }
                else
                {
                    errorProvider.SetError(tbUserName, String.Empty);
                    _validUserName = true;
                }
            }
            SetConnectionState();
        }

        /// <summary>
        /// Validate the password parameter
        /// </summary>
        private void ValidatePassword()
        {
            if (string.IsNullOrEmpty(tbPassword.Text.Trim()))
            {
                if (rbKerberos.Checked)
                {
                    ValidateKerberos();
                }
                else
                {
                    if (rbDigest.Checked)
                    {
                        errorProvider.SetError(tbPassword, string.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.PASSWORD_STRING));
                        _validPassword = false;
                    }
                    else
                    {
                        errorProvider.SetError(tbPassword, String.Empty);
                    }
                }
            }
            else
            {
                if (!Utilities.IsStrongPassword(tbPassword.Text))
                {
                    errorProvider.SetError(tbPassword, Properties.Resources.ILLEGAL_PASSWORD_ERROR);
                    _validPassword = false;
                }
                else
                {
                    errorProvider.SetError(tbPassword, String.Empty);
                    _validPassword = true;
                }
            }
            SetConnectionState();
        }

        /// <summary>
        /// Validate the kerberos parameter
        /// </summary>
        private void ValidateKerberos()
        {
            if (!String.IsNullOrEmpty(tbUserName.Text) && String.IsNullOrEmpty(tbPassword.Text))
            {
                errorProvider.SetError(tbPassword, string.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.PASSWORD_STRING));
                _validPassword = false;
            }
            else
            {
                errorProvider.SetError(tbPassword, String.Empty);
            }
            if (String.IsNullOrEmpty(tbUserName.Text) && !String.IsNullOrEmpty(tbPassword.Text))
            {
                errorProvider.SetError(tbUserName, string.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.USER_NAME_STRING));
                _validUserName = false;
            }
            else
            {
                errorProvider.SetError(tbUserName, String.Empty);
            }
            if (!String.IsNullOrEmpty(tbUserName.Text.Trim()))
            {

                if (!Regex.IsMatch(tbUserName.Text, Properties.Resources.HOST_NAME_FORMAT))
                {
                    errorProvider.SetError(tbUserName, Properties.Resources.ILLEGAL_KERBEROS_HOST_NAME);
                    _validUserName = false;
                }
                else
                {
                    errorProvider.SetError(tbUserName, String.Empty);
                    _validUserName = true;
                }
            }
            SetConnectionState();
        }

        /// <summary>
        /// Validate the TLS parameter
        /// </summary>
        private void ValidateTLSParams()
        {
            _validTLS = true;
            errorProvider.SetError(tbCertWithKey, String.Empty);
            SetConnectionState();
        }

        /// <summary>
        /// Validate the CIRA parameter
        /// </summary>
        private void ValidateCiraParameters()
        {
            _validCIRA = true;

            // Validating CIRA parameters
            if (String.IsNullOrEmpty(tbProxyHostName.Text.Trim()))
            {
                errorProvider.SetError(tbProxyHostName, String.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.PROXY_HOST_NAME_STRING));
                _validCIRA = false;
            }
            else
            {
                errorProvider.SetError(tbProxyHostName, String.Empty);
            }
            if (String.IsNullOrEmpty(tbProxyPort.Text.Trim()))
            {
                errorProvider.SetError(tbProxyPort, String.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.PROXY_PORT_STRING));
                _validProxyHost = ValidateHostName(tbProxyHostName);
                _validCIRA = false;
            }
            else
            {
                errorProvider.SetError(tbProxyPort, String.Empty);
            }
            if (!String.IsNullOrEmpty(tbProxyUserName.Text.Trim()) && String.IsNullOrEmpty(tbProxyPassword.Text.Trim()))
            {
                errorProvider.SetError(tbProxyPassword, String.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.PROXY_PASSWORD_STRING));
                _validCIRA = false;
            }
            else
            {
                errorProvider.SetError(tbProxyPassword, String.Empty);
            }
            if (String.IsNullOrEmpty(tbProxyUserName.Text) && !String.IsNullOrEmpty(tbProxyPassword.Text))
            {
                errorProvider.SetError(tbProxyUserName, String.Format(Properties.Resources.EMPTY_FIELD_ERROR, Properties.Resources.PROXY_USER_NAME_STRING));
                _validCIRA = false;
            }
            else
            {
                errorProvider.SetError(tbProxyUserName, String.Empty);
            }
            if (!String.IsNullOrEmpty(tbProxyUserName.Text) && !String.IsNullOrEmpty(tbProxyPassword.Text))
            {
                if (!Utilities.IsValidUserName(tbProxyUserName.Text))
                {
                    errorProvider.SetError(tbProxyUserName, Properties.Resources.ILLEGAL_USERNAME_ERROR);
                    _validCIRA = false;
                }
                else
                {
                    errorProvider.SetError(tbProxyUserName, String.Empty);
                }
                if (!Utilities.IsStrongPassword(tbProxyPassword.Text))
                {
                    errorProvider.SetError(tbProxyPassword, Properties.Resources.ILLEGAL_PASSWORD_ERROR);
                    _validCIRA = false;
                }
                else
                {
                    errorProvider.SetError(tbProxyPassword, String.Empty);
                }
            }
            SetConnectionState();
        }

        /// <summary>
        /// Change the TLS controls (e.g certificate text box) to enable/disable
        /// </summary>
        /// <param name="enable">Indicate the state of the controls</param>
        private void EnableTLSParams(bool enable)
        {
            lblCertWithKey.Enabled = enable;
            tbCertWithKey.Enabled = enable;
        }

        /// <summary>
        /// Change the CIRA controls (e.g certificate text box) to enable/disable
        /// </summary>
        /// <param name="enable">Indicate the state of the controls</param>
        private void EnableCIRAParams(bool enable)
        {
            lblCIRAHostName.Enabled = enable;
            lblCIRAPassword.Enabled = enable;
            lblCIRAPort.Enabled = enable;
            lblCIRAUserName.Enabled = enable;

            tbProxyHostName.Enabled = enable;
            tbProxyPort.Enabled = enable;
            tbProxyPassword.Enabled = enable;
            tbProxyUserName.Enabled = enable;
        }

        #endregion

        #endregion
    }
}