using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using Microsoft.VisualStudio.TestTools.WebTesting;
using Microsoft.VisualStudio.TestTools.LoadTesting;
using System.IO;
using System.ComponentModel;
using System.Text.RegularExpressions;
using System.Security.Cryptography.X509Certificates;

namespace LIL_VSTT_Plugins
{


    /// <summary>
    /// Datasource Unique Once
    /// </summary>
    [DisplayName("Datasource Unique Once")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nOBS! Läs hela! Styr datasource selection till att endast göras en gång per VU. Du måste ändra i din datasource Access Metod till Do Not Move Automatically! WebTestUserId används för att välja rad. Använder de datasources som finns definerade i webtestet. Använd test mix based on users starting tests samt 0 percent new users.")]
    public class UniqueOnce : WebTestPlugin
    {
        string dataSourceName;
        string dataTableName;
        int offset;

        [DisplayName("Datakällans namn")]
        [Description("Ange namnet på datakällan i ditt webtest, tex DataSource1")]
        [DefaultValue("DataSource1")]
        public string DataSourceName
        {
            get { return dataSourceName; }
            set { dataSourceName = value; }
        }

        [DisplayName("Tabellens namn")]
        [Description("Ange namnet på den tabell som ska användas, tex Userdata#csv")]
        public string DataSourceTableName
        {
            get { return dataTableName; }
            set { dataTableName = value; }
        }

        [DisplayName("Offset")]
        [Description("Används för att hoppa över ett visst antal rader från början på datakällan så de inte används.")]
        [DefaultValue(0)]
        public int Offset
        {
            get { return offset; }
            set { offset = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);
            int index = e.WebTest.Context.WebTestUserId + offset;
            e.WebTest.MoveDataTableCursor(dataSourceName, dataTableName, index);
            e.WebTest.AddCommentToResult("Selected row number " + index + " from datasource " + dataSourceName + " and table " + dataTableName + ".");
        }
    }

    /// <summary>
    /// Filtrar bort oönskade objekt från sidor.
    /// Samtliga objekt vars URL börjar med den angivna strängen kommer ignoreras och inte laddas ner.
    /// </summary>
    [DisplayName("Dynamisk URL Regex filter")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFilter för att ignorera vissa objekt på websidor så de inte laddas ner automatiskt.")]
    public class WebTestDependentRegexFilter : WebTestPlugin
    {
        string m_regex;
        bool m_exclude = true;

        /// <summary>
        /// Fullständig URL (inkl http://) som börjar med FilterString kommer att ignoreras.

        [DisplayName("RegEx")]
        [Description("Dynamiska (dependent) request kommer att filtreras om de matchar detta uttryck.\r\nTex: www.adsite.com eller *.png")]
        public string FilterString
        {
            get { return m_regex; }
            set { m_regex = value; }
        }

        [DisplayName("Exclude")]
        [DefaultValue(true)]
        [Description("Om satt till true kommer matchande requests att tas bort/exkluderas. Om satt till false kommer alla request utom de som matchar att tas bort/exkluderas")]
        public bool Exclude
        {
            get { return m_exclude; }
            set { m_exclude = value; }
        }

        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            if (!string.IsNullOrEmpty(m_regex))
            {
                WebTestRequestCollection depsToRemove = new WebTestRequestCollection();
                Regex regex = new Regex(m_regex);

                foreach (WebTestRequest r in e.Request.DependentRequests)
                {
                    // Disable parsing on dependents since we cannot filter those
                    r.ParseDependentRequests = false;
                    if (m_exclude)
                    {
                        if (regex.IsMatch(r.Url))
                        {
                            depsToRemove.Add(r);
                        }
                    }
                    else
                    {
                        if (!regex.IsMatch(r.Url))
                        {
                            depsToRemove.Add(r);
                        }
                    }
                }
                foreach (WebTestRequest r in depsToRemove)
                {
                    e.Request.DependentRequests.Remove(r);
                }
            }
        }
    }

    /// <summary>
    /// Filtrar bort oönskade objekt från sidor.
    /// Samtliga objekt vars URL börjar med den angivna strängen kommer ignoreras och inte laddas ner.
    /// </summary>
    [DisplayName("Dynamisk URL exclude filter")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFilter för att ignorera vissa objekt på websidor så de inte laddas ner automatiskt.")]
    public class WebTestDependentFilter : WebTestPlugin
    {
        string m_startsWith;

        /// <summary>
        /// Fullständig URL (inkl http://) som börjar med FilterString kommer att ignoreras.
        
        [DisplayName("URL börjar med")]
        [Description("Dynamiska (dependent) objekt som hittas kommer endast att laddas ner om de INTE börjar med denna sträng.\r\nTex: https://www.excludedsite.com")]
        public string FilterString
        {
            get { return m_startsWith; }
            set { m_startsWith = value; }
        }
        
        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            WebTestRequestCollection depsToRemove = new WebTestRequestCollection();
            Boolean hasRun = false;

            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                // Disable parsing on dependents since we cannot filter those
                r.ParseDependentRequests = false;
                if (!string.IsNullOrEmpty(m_startsWith) &&
                    r.Url.StartsWith(m_startsWith))
                {
                    depsToRemove.Add(r);
                    hasRun = true;
                }
            }
            foreach (WebTestRequest r in depsToRemove)
            {
                e.Request.DependentRequests.Remove(r);
            }

            if (hasRun)
            {
                //e.WebTest.AddCommentToResult("WebTestDependentFilter has run");
            }
        }
    }

    /// <summary>
    /// Filtrar bort oönskade objekt från sidor.
    /// Samtliga objekt vars URL börjar med den angivna strängen kommer ignoreras och inte laddas ner.
    /// </summary>
    [DisplayName("Dynamisk URL include filter")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFilter för att ignorera vissa objekt på websidor så de inte laddas ner automatiskt.")]
    public class WebTestDependentIncludeFilter : WebTestPlugin
    {
        string m_startsWith;

        /// <summary>
        /// Fullständig URL (inkl http://) som börjar med FilterString kommer att ignoreras.

        [DisplayName("URL börjar med")]
        [Description("Alla dynamiska (dependent) objekt som hittas kommer endast att laddas ner OM DE BÖRJAR med denna sträng.\r\nTex: https://www.onlythissite.com")]
        public string FilterString
        {
            get { return m_startsWith; }
            set { m_startsWith = value; }
        }

        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            WebTestRequestCollection depsToRemove = new WebTestRequestCollection();
            Boolean hasRun = false;

            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                // Disable parsing on dependents since we cannot filter those
                r.ParseDependentRequests = false;
                if (!string.IsNullOrEmpty(m_startsWith) &&
                    !r.Url.StartsWith(m_startsWith))
                {
                    depsToRemove.Add(r);
                    hasRun = true;
                }
            }
            foreach (WebTestRequest r in depsToRemove)
            {
                e.Request.DependentRequests.Remove(r);
            }

            if (hasRun)
            {
                //e.WebTest.AddCommentToResult("WebTestDependentFilter has run");
            }
        }
    }

    /// <summary>
    /// Ignorerar status koder under 500.
    /// </summary>
    [DisplayName("Ignore 4xx status codes")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nDetta plugin ändrar alla request så de inte går fel på grund av 4xx status koder i svaret samt ignorerar statuskoden helt på alla dependent requests")]
    public class WebTestIgnore4xx : WebTestPlugin
    {
        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            
            if (e.ResponseExists && (int)e.Response.StatusCode >= 500) e.Request.Outcome = Outcome.Fail;
            WebTestRequestCollection depsToRemove = new WebTestRequestCollection();

            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                r.IgnoreHttpStatusCode = true;
            }
        }
       
        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            e.Request.IgnoreHttpStatusCode = true;
        }
    }

    /// <summary>
    /// Ignorerar status koder under 500.
    /// </summary>
    [DisplayName("Ignore Dependent Results")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nDependent requests kommer laddas ner men ej mätas individuellt. Alla kommer enbart mätas gemensamt som [dependent]")]
    public class WebTestIgnoreDependentResults : WebTestPlugin
    {
        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                r.ReportingName = "[dependent request]";
            }
        }
    }

    /// <summary>
    /// Service Manager Plugin
    /// </summary>
    [DisplayName("Service Manager Config")]
    [Description("(C) Copyright 2015 LIGHTS IN LINE AB\r\nSätter config värden i Service Manager instansen för hela testet, finns även som loadtest plugin och gäller då hela loadtestet.")]
    public class ServiceManagerWebTestPlugin : WebTestPlugin
    {
        [DisplayName("Use Expect 100 Behaviour"), DefaultValue(true)]
        public bool exp100 { get; set; }

        [DisplayName("Max Connection Idle Time"), DefaultValue(100)]
        public int maxIdle { get; set; }

        [DisplayName("TCP Keep Alive"), DefaultValue(false)]
        public bool keepAlive { get; set; }

        [DisplayName("TCP Keep Alive Timeout (ms)"), DefaultValue(5000)]
        public int timeOut { get; set; }

        [DisplayName("TCP Keep Alive Interval"), DefaultValue(1000)]
        public int interVal { get; set; }

        [DisplayName("Use Nagle Algorithm"), DefaultValue(false)]
        public bool useNagle { get; set; }

        [DisplayName("Force TLS 1.2"), DefaultValue(false)]
        [Description("Kräver .NET 4.5 samt att TLS1.2 är aktiverat i SChannel (använd bifogad schannel_high.reg)")]
        public bool useTls12 { get; set; }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);
            System.Net.ServicePointManager.Expect100Continue = exp100;
            System.Net.ServicePointManager.MaxServicePointIdleTime = maxIdle;
            System.Net.ServicePointManager.SetTcpKeepAlive(keepAlive, timeOut, interVal);
            System.Net.ServicePointManager.UseNagleAlgorithm = useNagle;
            if(useTls12) System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
        }

    }

    /// <summary>
    /// WebTest Plugin Template
    /// </summary>
    [DisplayName("Randomize each page")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nVäljer en ny slumpmässig rad i din datasource vid varje sida/page i skriptet.")]
    public class randomOnEachPage : WebTestPlugin
    {
        string dataSourceName;
        string dataTableName;
        int datasourceSize = 0;
        Random RandomNumber = new Random(System.DateTime.Now.Millisecond);

        [DisplayName("Datakällans namn")]
        [Description("Ange namnet på datakällan i ditt webtest, tex DataSource1")]
        [DefaultValue("DataSource1")]
        public string DataSourceName
        {
            get { return dataSourceName; }
            set { dataSourceName = value; }
        }

        [DisplayName("Tabellens namn")]
        [Description("Ange namnet på den tabell som ska användas, tex Userdata#csv")]
        public string DataSourceTableName
        {
            get { return dataTableName; }
            set { dataTableName = value; }
        }

        public override void PrePage(object sender, PrePageEventArgs e)
        {
            base.PrePage(sender, e);
            if (datasourceSize == 0) {
                int size = e.WebTest.GetDataTableRowCount(dataSourceName, dataTableName);
                if(size > 0) 
                    datasourceSize = size;
                else
                    return;
            }
            if (datasourceSize > 0)
            {
                int index = RandomNumber.Next(0, datasourceSize - 1);
                e.WebTest.MoveDataTableCursor(dataSourceName, dataTableName, index);
                //e.WebTest.AddCommentToResult("Selected row number " + index + " from datasource " + dataSourceName + " and table " + dataTableName + ".");
            }
        }
    }

    ///<summary>
    ///WebTest Plugin Data Generator
    ///</summary>
    [DisplayName("Data Generator Integer")]
    [Description("(C) Copyright 2016 LIGHTS IN LINE AB\r\nGenererar en slumpad integer som context parameter")]
    public class dataGenInteger : WebTestPlugin
    {
        Random RandomNumber = new Random(System.DateTime.Now.Millisecond);

        private string paramName;
        [DisplayName("Parameter namn")]
        [Description("Ange namnet på parametern i ditt webtest, tex IntParameter1")]
        [DefaultValue("IntegerParameter1")]
        public string ParamNameVal
        {
            get { return paramName; }
            set { paramName = value; }
        }

        private int intMin;
        [DisplayName("Integer Min")]
        [Description("Ange minsta värdet för parametern i ditt webtest, tex 0")]
        [DefaultValue(0)]
        public int IntegerMin
        {
            get { return intMin; }
            set { intMin = value; }
        }

        private int intMax;
        [DisplayName("Integer Max")]
        [Description("Ange högsta värdet för parametern i ditt webtest, tex 100")]
        [DefaultValue(100)]
        public int IntegerMax
        {
            get { return intMax; }
            set { intMax = value; }
        }

        private bool prePage = false;
        [DisplayName("Uppdatera på varje Page")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny sida som laddas i testet.")]
        [DefaultValue(false)]
        public bool PrePageVal
        {
            get { return prePage; }
            set { prePage = value; }
        }

        private bool preTrans = false;
        [DisplayName("Uppdatera på varje Transaktion")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny transaktion i testet.")]
        [DefaultValue(false)]
        public bool PreTransactionVal
        {
            get { return preTrans; }
            set { preTrans = value; }
        }

        private bool preReq = false;
        [DisplayName("Uppdatera på varje Request")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje nytt request i testet.")]
        [DefaultValue(false)]
        public bool PreRequestVal
        {
            get { return preReq; }
            set { preReq = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            update(e.WebTest.Context);
            base.PreWebTest(sender, e);
        }

        public override void PrePage(object sender, PrePageEventArgs e)
        {
            if (prePage) update(e.WebTest.Context);
            base.PrePage(sender, e);
        }

        public override void PreRequestDataBinding(object sender, PreRequestDataBindingEventArgs e)
        {
            if (preReq) update(e.WebTest.Context);
            base.PreRequestDataBinding(sender, e);
        }

        public override void PreTransaction(object sender, PreTransactionEventArgs e)
        {
            if (preTrans) update(e.WebTest.Context);
            base.PreTransaction(sender, e);
        }

        private void update(WebTestContext context)
        {
            context[paramName] = RandomNumber.Next(intMin, intMax);
        }
    }

    ///<summary>
    ///WebTest Plugin Data Generator
    ///</summary>
    [DisplayName("Data Generator Timestamp")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nGenererar en timestamp som context parameter")]
    public class dataGenTimestamp : WebTestPlugin
    {
        private string paramName;
        [DisplayName("Parameter namn")]
        [Description("Ange namnet på parametern i ditt webtest, tex TimeStampParameter1")]
        [DefaultValue("TimeStampParameter1")]
        public string ParamNameVal
        {
            get { return paramName; }
            set { paramName = value; }
        }

        private bool millis = false;
        [DisplayName("Använd millisekunder")]
        [Description("Sätt till true om du vill ha värdet i millisekunder istället för sekunder.")]
        [DefaultValue(false)]
        public bool MillisecondsVal
        {
            get { return millis; }
            set { millis = value; }
        }

        private bool prePage = false;
        [DisplayName("Uppdatera på varje Page")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny sida som laddas i testet.")]
        [DefaultValue(false)]
        public bool PrePageVal
        {
            get { return prePage; }
            set { prePage = value; }
        }

        private bool preTrans = false;
        [DisplayName("Uppdatera på varje Transaktion")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny transaktion i testet.")]
        [DefaultValue(false)]
        public bool PreTransactionVal
        {
            get { return preTrans; }
            set { preTrans = value; }
        }

        private bool preReq = false;
        [DisplayName("Uppdatera på varje Request")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje nytt request i testet.")]
        [DefaultValue(false)]
        public bool PreRequestVal
        {
            get { return preReq; }
            set { preReq = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            update(e.WebTest.Context);
            base.PreWebTest(sender, e);
        }

        public override void PrePage(object sender, PrePageEventArgs e)
        {
            if (prePage) update(e.WebTest.Context);
            base.PrePage(sender, e);
        }

        public override void PreRequestDataBinding(object sender, PreRequestDataBindingEventArgs e)
        {
            if (preReq) update(e.WebTest.Context);
            base.PreRequestDataBinding(sender, e);
        }

        public override void PreTransaction(object sender, PreTransactionEventArgs e)
        {
            if (preTrans) update(e.WebTest.Context);
            base.PreTransaction(sender, e);
        }

        private void update(WebTestContext context)
        {
            TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc));
            if (millis) context[paramName] = ((Int64) span.TotalMilliseconds).ToString();
            else context[paramName] = ((Int64) span.TotalSeconds).ToString();
        }
    }

    /// <summary>
    /// WebTest Client Certificate
    /// </summary>
    [DisplayName("Client Certificate")]
    [Description("(C) Copyright 2016 LIGHTS IN LINE AB\r\nSätter webtestet att använda ett specifikt client cert för SSL. Certifikatet behöver inte installeras i certstore först.")]
    public class ClientCertificatePlugin : WebTestPlugin
    {
        [DisplayName("Certificate Path")]
        [Description("Sökvägen till certifikatfilen (.P12/.PFX/.PEM med privat nyckel)")]
        [DefaultValue("")]
        public string pCertificatePath { get; set; }

        [DisplayName("Certificate Path Parameter")]
        [Description("Ange namn på parameter som ska användas för sökvägen till certifikatfilen (.P12/.PFX/.PEM). Om parametern saknas eller är tom används Certificate Path")]
        [DefaultValue("")]
        public string pCertificatePathParameter { get; set; }

        [DisplayName("Certificate Password")]
        [Description("Ange lösenordet för att öppna certifikatfilen")]
        [DefaultValue("")]
        public string pCertificatePassword { get; set; }

        [DisplayName("Certificate Password Parameter")]
        [Description("Ange namn på parameter som ska användas för lösenordet till certifikatfilen. Om parametern saknas eller är tom används Certificate Password")]
        [DefaultValue("")]
        public string pCertificatePasswordParameter { get; set; }

        [DisplayName("Log Debug Info")]
        [Description("Sätt till True om extra info ska loggas i början av varje test")]
        [DefaultValue(false)]
        public bool pDebug { get; set; }

        [DisplayName("Install trusted certificates")]
        [Description("Sätt till True om certifikat ska installeras automatiskt om det är giltigt")]
        [DefaultValue(false)]
        public bool pInstallTrusted { get; set; }

        [DisplayName("Install untrusted certificates")]
        [Description("Sätt till True om ogiltiga som giltiga certifikat ska installeras automatiskt")]
        [DefaultValue(false)]
        public bool pInstallUntrusted { get; set; }

        private bool haveCert = false;
        private X509Certificate myClientCert;
        private X509Certificate2 myClientCertAndKey;

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);
            String certPath, certPass;
            // Ladda in certifikatet och sätt CertPolicy

            if (!String.IsNullOrWhiteSpace(pCertificatePathParameter) && e.WebTest.Context.ContainsKey(pCertificatePathParameter) && !String.IsNullOrWhiteSpace(e.WebTest.Context[pCertificatePathParameter].ToString()) )
            {
                certPath = e.WebTest.Context[pCertificatePathParameter].ToString();
            } else
            {
                certPath = pCertificatePath;
            }

            if (!String.IsNullOrWhiteSpace(pCertificatePasswordParameter) && e.WebTest.Context.ContainsKey(pCertificatePasswordParameter) && !String.IsNullOrWhiteSpace(e.WebTest.Context[pCertificatePasswordParameter].ToString()))
            {
                certPass = e.WebTest.Context[pCertificatePasswordParameter].ToString();
            }
            else
            {
                certPass = pCertificatePassword;
            }

            if(string.IsNullOrWhiteSpace(certPath))
            {
                // Cant continue, cert  is missing
                if (pDebug) e.WebTest.AddCommentToResult("No certificate loaded, since both Certificate Path and Certificate Path Parameter are empty");
                return;
            }

            // Check what type of container we have. All files are treated as PEM unless the extension is .pfx or .p12
            // Read certificate and private key depending on type
            if (certPath.ToLower().EndsWith(".pfx") || certPath.ToLower().EndsWith(".p12"))
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate file is treated as PFX/PKCS12");
                try
                {
                    myClientCertAndKey = new X509Certificate2(certPath, certPass, X509KeyStorageFlags.PersistKeySet);
                    myClientCert = new X509Certificate(myClientCertAndKey);
                }
                catch (Exception ex)
                {
                    e.WebTest.AddCommentToResult("Error during loading of certificate: " + certPath + " Message: " + ex.Message);
                    return;
                }
            } else
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate file is treated as PEM/PKCS8");

                // Use Bouncy Castle to read the certificate and key, then convert to .NET X509Certificate2 and X509Certificate
                String text;
                try {
                    text = File.ReadAllText(certPath);
                } catch (Exception ex)
                {
                    e.WebTest.AddCommentToResult("Error opening PEM file: " + certPath + " Message: " + ex.Message);
                    return;
                }

                // Find the key and certificate in file and load them
                int keyTextBeginPos = text.IndexOf("-----BEGIN");
                int keyTextEndPos = text.IndexOf("-----END");
                Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair bcKey = null;
                Org.BouncyCastle.X509.X509Certificate bcCert = null;

                while (keyTextBeginPos != -1)
                {
                    text = text.Substring(keyTextBeginPos);
                    object obj;
                    try
                    {
                        Org.BouncyCastle.OpenSsl.PemReader bc = new Org.BouncyCastle.OpenSsl.PemReader(new StringReader(text), new PasswordHelper(certPass));
                        obj = bc.ReadObject();
                    }
                    catch (Org.BouncyCastle.Crypto.InvalidCipherTextException ex)
                    {
                        e.WebTest.AddCommentToResult("Error during reading of PEM file: " + certPath + " Wrong password? Message: " + ex.Message);
                        return;
                    }
                    catch (Exception ex)
                    {
                        e.WebTest.AddCommentToResult("Error during reading of PEM file: " + certPath + " Message: " + ex.GetType().FullName + ":" + ex.Message);
                        return;
                    }
                    if (obj != null)
                    {
                        if (pDebug) e.WebTest.AddCommentToResult("Found PEM Object of type " + obj.GetType().FullName);
                        if(obj is Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair)
                        {
                            // We have a keypair
                            bcKey = (Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair)obj;
                        }
                        if(obj is Org.BouncyCastle.X509.X509Certificate)
                        {
                            // We have a certificate
                            bcCert = (Org.BouncyCastle.X509.X509Certificate)obj;
                        }
                    }
                    keyTextBeginPos = text.IndexOf("-----BEGIN", keyTextEndPos);
                }
                if (bcKey == null || bcCert == null)
                {
                    e.WebTest.AddCommentToResult("Error: PEM file has to contain both certificate and private key");
                    return;
                }
                try {
                    myClientCert = Org.BouncyCastle.Security.DotNetUtilities.ToX509Certificate(bcCert);
                    myClientCertAndKey = new X509Certificate2(myClientCert);
                    myClientCertAndKey.PrivateKey = Org.BouncyCastle.Security.DotNetUtilities.ToRSA(bcKey.Private as Org.BouncyCastle.Crypto.Parameters.RsaPrivateCrtKeyParameters);
                } catch (Exception ex)
                {
                    e.WebTest.AddCommentToResult("Error during loading of PEM file: " + certPath + " Message: " + ex.Message);
                    return;
                }
            }

            // Check that we have a certificate
            if (myClientCert == null)
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate File " + certPath + " could not be loaded.");
                return;
            }
            else
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate File " + certPath + " loaded successfully.");
            }

            // Check that it seems okey
            if (string.IsNullOrWhiteSpace(myClientCert.GetCertHashString()))
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate File " + certPath + " contains no SHA1 hash. Not using it.");
                return;
            }
            if (pDebug) e.WebTest.AddCommentToResult("Loaded client certificate for Subject: [" + myClientCert.Subject + "] Issued by: [" + myClientCert.Issuer + "] Expires: [" + myClientCert.GetExpirationDateString() + "]");

            // Check if the certificate is trusted (i.e. chain can be validated)
            bool myCertTrusted = false;
            if (myClientCertAndKey.Verify())
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate is TRUSTED");
                myCertTrusted = true;
            } else
            {
                e.WebTest.AddCommentToResult("Warning: Certificate is NOT TRUSTED by client. Might not be trusted on server either. Check that the Issuer/CA root and intermediary certificates are installed on the client and server.");
                myCertTrusted = false;
            }

            // Check if it is expired or about to expire
            if(myClientCertAndKey.NotAfter < DateTime.Now)
            {
                e.WebTest.AddCommentToResult("Warning: Client Certificate has expired. Might not be trusted on server. Expired " + myClientCertAndKey.NotAfter.ToString());
            } else if (myClientCertAndKey.NotBefore > DateTime.Now)
            {
                e.WebTest.AddCommentToResult("Warning: Client Certificate is not valid yet. Might not be trusted on server. Valid " + myClientCertAndKey.NotBefore.ToString());
            } else if (myClientCertAndKey.NotAfter < DateTime.Now.AddDays(14))
            {
                e.WebTest.AddCommentToResult("Warning: Client Certificate will expire in less than 14 days. Better renew it soon. Expires " + myClientCertAndKey.NotAfter.ToString());
            }

            // Check if we have a private key
            if (!myClientCertAndKey.HasPrivateKey)
            {
                // Cant use it without private key
                e.WebTest.AddCommentToResult("Error: Certificate HAS NO PRIVATE KEY, cannot use it without one.");
                return;
            } else
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate HAS PRIVATE KEY");
            }

            // Check that the certificate exists in the cert store
            X509Store cuStore = new X509Store();
            cuStore.Open(OpenFlags.ReadWrite);
            if(cuStore.Certificates.Contains(myClientCertAndKey)) {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate already INSTALLED in Current User Windows Certificate Store");
            } else
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate is NOT INSTALLED");
                if(pInstallTrusted && myCertTrusted || pInstallUntrusted)
                {
                    // Try to install certificate
                    if (myCertTrusted || !myCertTrusted)
                    {
                        // Install in user store
                        try {
                            myClientCertAndKey.FriendlyName = "VSTT";
                            cuStore.Add(myClientCertAndKey);
                            if (pDebug) e.WebTest.AddCommentToResult("Certificate HAS BEEN INSTALLED in the Current User Windows Certificate Store with Friendly Name: VSTT");
                        } catch (Exception ex)
                        {
                            e.WebTest.AddCommentToResult("Error: COULD NOT INSTALL in the Current User Windows Certificate Store, Message: " + ex.Message);
                            return;
                        }
                    }
                }
            }

            // Set the PreRequest method to add the certificate on requests
            haveCert = true;
            if (pDebug) e.WebTest.AddCommentToResult("Certificate will be ADDED TO REQUESTS");
        }

        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            base.PreRequest(sender, e);
            if (haveCert)
            {
                if (!e.Request.ClientCertificates.Contains(myClientCert))
                {
                    e.Request.ClientCertificates.Add(myClientCert);
                }
                e.WebTest.Context["Client Certificate"] = myClientCert.Subject;
            } else
            {
                e.WebTest.Context["Client Certificate"] = "No certificate was added";
            }
        }
    }

    public class PasswordHelper : Org.BouncyCastle.OpenSsl.IPasswordFinder
    {
        private string pwd = "";
        public PasswordHelper(String password)
        {
            this.pwd = password;
        }
        public char[] GetPassword()
        {
            return pwd.ToArray();
        }
    }

    /*
    /// <summary>
    /// WebTest Plugin Template
    /// </summary>
    [DisplayName("Plugin Namn")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFörklaring")]
    public class myPlugin : WebTestPlugin
    {
        private string paramName;
        [DisplayName("Parameter namn")]
        [Description("Ange namnet på parametern i ditt webtest, tex TimeStampParameter1")]
        [DefaultValue("TimeStampParameter1")]
        public string ParamNameVal
        {
            get { return paramName; }
            set { paramName = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);
            e.WebTest.Context.CookieContainer = new myCookieContainer();
        }
    }
    */

}