using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.VisualStudio.TestTools.LoadTesting;
using System.ComponentModel;
using System.IO;
using System.Collections.Specialized;

namespace LIL_VSTT_Plugins
{

    /// <summary>
    /// LoadTest Context Copy
    /// </summary>
    [DisplayName("LoadTest Context Copy")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nKopierar context parametrar satta i loadtestet till alla test context i test mixen.")]
    public class LoadTestPluginCopier : ILoadTestPlugin
    {
        //store the load test object.  
        LoadTest mLoadTest;

        public void Initialize(LoadTest loadTest)
        {
            mLoadTest = loadTest;

            //connect to the TestStarting event.
            mLoadTest.TestStarting += new EventHandler<TestStartingEventArgs>(mLoadTest_TestStarting);
        }


        void mLoadTest_TestStarting(object sender, TestStartingEventArgs e)
        {
            //When the test starts, copy the load test context parameters to 
            //the test context parameters
            foreach (string key in mLoadTest.Context.Keys)
            {
                e.TestContextProperties.Add(key, mLoadTest.Context[key]);
            }
        }
    }

    /// <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.")]
    public class ServiceManagerPlugin : ILoadTestPlugin
    {
        [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; }

        public void Initialize(LoadTest loadTest)
        {
            System.Net.ServicePointManager.Expect100Continue = exp100;
            System.Net.ServicePointManager.MaxServicePointIdleTime = maxIdle;
            System.Net.ServicePointManager.SetTcpKeepAlive(keepAlive, timeOut, interVal);
            System.Net.ServicePointManager.UseNagleAlgorithm = useNagle;
            //System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls; Needs .net 4.5 in order to enable high security protocols
        }

    }

    [DisplayName("Set Test Context Parameters")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nSätter parametrar i testcontextet för tester i mixen hämtat från en CSV fil")]
    public class SetTestParameter : ILoadTestPlugin
    {
        // Summary:
        //     Initializes the load test plug-in.
        //
        // Parameters:
        //   loadTest:
        //     The load test to be executed.

        private string myConnectionString = "";
        private string myLogFileString = "";
        private string myParameterName = "";
        private string myTestNames = "";
        private string myScenarioNames = "";
        private string myAgentNames = "";
        private string myColNames = "";
        private bool myUseRandom = true;
        private bool myUseUnique = false;
        private bool myUseUniqueIteration = false;
        private bool myLogToFile = false;
        private bool myLogAppendID = false;
        private bool myLogAppendName = false;
        private bool mySeqLoop = false;
        private bool myHasColName = false;
        private bool myUseAutoSplit = false;
        
        private StringCollection myParams = new StringCollection();
        private Random random = new Random();
        private LoadTest m_loadTest;

        [DisplayName("CSV filens sökväg")]
        [Description("Ange den fullständiga sökvägen till CSV filen. Observera att filen behöver finnas på alla agenterna också om du inte kör lokalt.")]
        [DefaultValue("C:\\Userdata.csv")]
        public string Connection_String
        {
            get { return myConnectionString; }
            set { myConnectionString = value; }
        }

        [DisplayName("CSV filen har kolumnamn")]
        [Description("Ange om csv filen har rubriker i form av kolumnnamn. Om du sätter True kommer kolmnens rubrik att användas som parameternamn istället.")]
        [DefaultValue(false)]
        public bool Has_col_name
        {
            get { return myHasColName; }
            set { myHasColName = value; }
        }

        [DisplayName("CSV Autosplit per agent")]
        [Description("Ange True om du vill att filen automatiskt ska splittas mellan alla aktiva agenter.")]
        [DefaultValue(false)]
        public bool Autosplit
        {
            get { return myUseAutoSplit; }
            set { myUseAutoSplit = value; }
        }

        [DisplayName("Context Parameter Namn")]
        [Description("Ange namnet på parametern som vi ska lägga till i TestContext, om det är flera använd CSV format.")]
        [DefaultValue("UserName")]
        public string Parameter_Name
        {
            get { return myParameterName; }
            set { myParameterName = value; }
        }

        [DisplayName("Loggfilens namn")]
        [Description("Ange den fullständiga sökvägen till logg filen. Om filen finns kommer den inte skrivas över utan läggas till i slutet.")]
        [DefaultValue("C:\\Temp\\Fungerande.log")]
        public string LogFilePathString
        {
            get { return myLogFileString; }
            set { myLogFileString = value; }
        }

        [DisplayName("Loggfilens namn: Lägg till ID")]
        [Description("Ange True om du vill att Agent ID samt VU ID läggs till automatiskt i slutet på filnamnet.")]
        [DefaultValue(false)]
        public bool LogFileAppendID
        {
            get { return myLogAppendID; }
            set { myLogAppendID = value; }
        }

        [DisplayName("Loggfilens namn: Lägg till Namn")]
        [Description("Ange True om du vill att Scenario Name samt Test Name läggs till automatiskt i slutet på filnamnet.")]
        [DefaultValue(false)]
        public bool LogFileAppendName
        {
            get { return myLogAppendName; }
            set { myLogAppendName = value; }
        }

        [DisplayName("Välj slumpmässigt?")]
        [Description("Ange True om du vill välja en slumpmässig användare. False går igenom listan sekventiellt.")]
        [DefaultValue(true)]
        public bool Use_Random
        {
            get { return myUseRandom; }
            set { myUseRandom = value; }
        }

        [DisplayName("Välj unikt per VU?")]
        [Description("Ange True om du vill att varje LoadTest VU ska ha sitt eget unika värde och återanvända detta i varje iteration. Stänger av slumpmässigt val.")]
        [DefaultValue(false)]
        public bool Use_Unique
        {
            get { return myUseUnique; }
            set { myUseUnique = value; }
        }

        [DisplayName("Välj unikt per Iteration?")]
        [Description("Ange True om du vill att varje LoadTest VU ska ha sitt eget unika värde för varje iteration, dvs aldrig återanvändas av någon under testet.")]
        [DefaultValue(false)]
        public bool Use_UniqueIteration
        {
            get { return myUseUniqueIteration; }
            set { myUseUniqueIteration = value; }
        }

        [DisplayName("Välj sekventiell loop?")]
        [Description("Ange true om du vill börja om från början om sekventiell läsning får slut på värden. Gäller även Unik läsning.")]
        [DefaultValue(false)]
        public bool Use_Loop
        {
            get { return mySeqLoop; }
            set { mySeqLoop = value; }
        }

        [DisplayName("Logga fungerande till fil?")]
        [Description("Ange True om du vill att poster vars tester slutar i Pass ska loggas till fil (c:\\fungerande.log). Om filen redan finns läggs de till i slutet.")]
        [DefaultValue(false)]
        public bool Log_To_File
        {
            get { return myLogToFile; }
            set { myLogToFile = value; }
        }

        [DisplayName("Endast dessa Tester")]
        [Description("Parametrar sätts endast på tester i test mixen där namnet eller del av namnet för testet finns i denna lista. Lämna blankt för att sätta i alla tester.")]
        [DefaultValue("")]
        public string Test_Names
        {
            get { return myTestNames; }
            set { myTestNames = value; }
        }

        [DisplayName("Endast dessa Scenarios")]
        [Description("Parametrar sätts endast på Scenarion där namnet eller del av namnet för scenariot finns i denna lista. Lämna blankt för att sätta i alla scenarion.")]
        [DefaultValue("")]
        public string Scenario_Names
        {
            get { return myScenarioNames; }
            set { myScenarioNames = value; }
        }
        
        [DisplayName("Endast dessa Agenter")]
        [Description("Parametrar sätts endast på Agenter där namnet eller del av namnet för agenten finns i denna lista. Lämna blankt för att sätta i alla agenter.")]
        [DefaultValue("")]
        public string Agent_Names
        {
            get { return myAgentNames; }
            set { myAgentNames = value; }
        }
        
        public void Initialize(LoadTest loadTest)
        {
            // Only run on specific agents if specified
            if (myAgentNames.Length > 0 && !myAgentNames.ToLower().Contains(loadTest.Context.AgentName.ToLower())) return;

            // Vi bör läsa in alla värden här
            this.initUserArray(myConnectionString, loadTest.Context.AgentCount, loadTest.Context.AgentId);

            if (myParams.Count > 0)
            {
                m_loadTest = loadTest;
                if (myUseUniqueIteration)
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingUniqueIteration);
                else if (myUseUnique)
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingUnique);
                else if (myUseRandom)
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingRandom);
                else
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingSeq);
            }
            if (myLogToFile)
            {
                m_loadTest.TestFinished += new EventHandler<TestFinishedEventArgs>(loadTestEndLogger);
            }
        }

        void loadTestEndLogger(object sender, TestFinishedEventArgs e)
        {
            // Log the user to logfile if the test is passed
            if (e.Result.Passed && shouldRun(e))
            {
                string fileName = myLogFileString;
                if (myLogAppendID) fileName = fileName + ".Agent" + m_loadTest.Context.AgentId + ".Vu" + e.UserContext.UserId;
                if (myLogAppendName) fileName = fileName + "." + e.UserContext.ScenarioName + "." + e.TestName;
                string[] allNames;
                if (myHasColName) allNames = myColNames.Split(','); else allNames = myParameterName.Split(',');
                string row = "";
                foreach (string name in allNames)
                {
                    if(e.UserContext.Keys.Contains(name)) {
                        if (row.Length == 0)
                            row += e.UserContext[name];
                        else
                            row += "," + e.UserContext[name];
                    }
                }
                File.AppendAllText(fileName + ".csv", row + "\r\n");
            }
        }

        void loadTestStartingRandom(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getRandomUser(), e);
        }

        void loadTestStartingSeq(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getSeqUser(e.UserContext.CompletedTestCount), e);
        }

        void loadTestStartingUnique(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getSeqUser(e.UserContext.UserId), e);
        }

        void loadTestStartingUniqueIteration(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getSeqUser(e.TestIterationNumber - 1), e);
        }

        void setParameters(string user, TestStartingEventArgs e)
        {
            if (shouldRun(e))
            {
                // Add context parameters to the starting test
                int numParams = 1;
                if (myHasColName == true && myColNames.Contains(',')) numParams = countColumns(myColNames);
                if (myHasColName == false && myParameterName.Contains(',')) numParams = countColumns(myParameterName);
                //e.TestContextProperties.Add("LIL_LogValue", user);
                //e.UserContext["LIL_LogValue"] = user;
                string[] allParams = user.Split(',');
                string[] allNames;
                if (myHasColName) allNames = myColNames.Split(','); else allNames = myParameterName.Split(',');
                for (int i = 0; i < numParams; i++)
                {
                    e.TestContextProperties.Add(allNames[i], allParams[i]);
                    e.UserContext[allNames[i]] = allParams[i];
                }
            }
        }

        int countColumns(string input)
        {
            int count = 1;
            for (int i = 0; i < input.Length; i++)
            {
                if (input[i] == ',') count++;
            }
            return count;
        }

        bool shouldRun(TestStartingEventArgs e)
        {
            bool doRun = true;
            if (myTestNames.Length > 0 && !myTestNames.ToLower().Contains(e.TestName.ToLower())) doRun = false;
            if (myScenarioNames.Length > 0 && !myScenarioNames.ToLower().Contains(e.ScenarioName.ToLower())) doRun = false;
            return doRun;
        }

        bool shouldRun(TestFinishedEventArgs e)
        {
            bool doRun = true;
            if (myTestNames.Length > 0 && !myTestNames.ToLower().Contains(e.TestName.ToLower())) doRun = false;
            if (myScenarioNames.Length > 0 && !myScenarioNames.ToLower().Contains(e.ScenarioName.ToLower())) doRun = false;
            return doRun;
        }

        string getRandomUser()
        {
            int randomIndex = random.Next(myParams.Count - 1);
            return myParams[randomIndex];
        }

        string getSeqUser(int seqIndex)
        {
            if (seqIndex < myParams.Count)
                return myParams[seqIndex];
            else
            {
                if (mySeqLoop)
                    return myParams[seqIndex % myParams.Count];
                else
                    return myParams[myParams.Count - 1];
            }
        }

        bool initUserArray(string path, int agentCount, int agentId)
        {
            if (path.Length > 0)
            {
                //StreamReader re = File.OpenText(path);
                StreamReader re = new StreamReader(path, System.Text.Encoding.Default);
                string input = null;
                int lineNum = 0;
                int dataNum = 0;
                while ((input = re.ReadLine()) != null)
                {
                    lineNum++;
                    if (lineNum == 1 && myHasColName == true)
                    {
                        // First line is column names
                        myColNames = input.TrimEnd();
                    }
                    else
                    {
                        if (myUseAutoSplit)
                        {
                            int ifAgentId = 0;
                            if (dataNum >= agentCount) ifAgentId = (dataNum % agentCount) + 1;
                            else ifAgentId = dataNum + 1;
                            if (ifAgentId == agentId)
                            {
                                myParams.Add(input.TrimEnd());
                            }
                            dataNum++;
                        }
                        else
                        {
                            myParams.Add(input.TrimEnd());
                        }
                    }
                }
                re.Close();
                return true;
            }
            else { 
                return false; 
            }
        }
    }
}