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 PluginLib
{
    [DisplayName("Set Parameter In Context")]
    [Description("Sätter en parameter i testcontextet för alla eller vissa tester i mixen hämtat från en CSV fil")]
    public class SetTestUser : 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 bool myUseRandom = true;
        private bool myUseUnique = false;
        private bool myUseUniqueIteration = false;
        private bool myLogToFile = false;
        private bool mySeqLoop = false;
        private StringCollection myParams = new StringCollection();
        private Random random = new Random();
        private LoadTest m_loadTest;

        [DisplayName("Endast dessa Tester")]
        [Description("Ange de tester som ska få denna parameter. Lämna blankt för alla tester. Testets namn måste annars finnas i denna sträng för att få parametervärdet.")]
        [DefaultValue("")]
        public string Test_Names
        {
            get { return myTestNames; }
            set { myTestNames = value.ToLower(); }
        }

        [DisplayName("Sökväg till CSV fil")]
        [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("Context Parameter Namn")]
        [Description("Ange namnet på parametern som vi ska lägga till i TestContext")]
        [DefaultValue("UserName")]
        public string Parameter_Name
        {
            get { return myParameterName; }
            set { myParameterName = value; }
        }

        [DisplayName("Logga fungerande till")]
        [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")]
        [CategoryAttribute("Loggning")]
        public string LogFilePathString
        {
            get { return myLogFileString; }
            set { myLogFileString = 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)]
        [CategoryAttribute("Loggning")]
        public bool Log_To_File
        {
            get { return myLogToFile; }
            set { myLogToFile = value; }
        }

        public void Initialize(LoadTest loadTest)
        {
            // Vi bör läsa in alla värden här
            this.initUserArray(myConnectionString);

            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)
            {
                File.AppendAllText(myLogFileString, e.UserContext[myParameterName].ToString() + "\r\n");
            }
        }

        void loadTestStartingRandom(object sender, TestStartingEventArgs e)
        {
            // Check that its the right script
            if (myTestNames.Length > 0 && !myTestNames.Contains(e.TestName.ToLower())) return;

            // Add a context parameter to the starting test
            string user = this.getRandomUser();
            e.TestContextProperties.Add(myParameterName, user);
            e.UserContext[myParameterName] = user;
        }

        void loadTestStartingSeq(object sender, TestStartingEventArgs e)
        {
            // Check that its the right script
            if (myTestNames.Length > 0 && !myTestNames.Contains(e.TestName.ToLower())) return;

            // Add a context parameter to the starting test
            string user = this.getSeqUser(e.UserContext.CompletedTestCount);
            e.TestContextProperties.Add(myParameterName, user);
            e.UserContext[myParameterName] = user;
        }

        void loadTestStartingUnique(object sender, TestStartingEventArgs e)
        {
            // Check that its the right script
            if (myTestNames.Length > 0 && !myTestNames.Contains(e.TestName.ToLower())) return;

            // Add a context parameter to the starting test
            string user = this.getSeqUser(e.UserContext.UserId);
            e.TestContextProperties.Add(myParameterName, user);
            e.UserContext[myParameterName] = user;
        }

        void loadTestStartingUniqueIteration(object sender, TestStartingEventArgs e)
        {
            // Check that its the right script
            if (myTestNames.Length > 0 && !myTestNames.Contains(e.TestName.ToLower())) return;

            // Add a context parameter to the starting test
            string user = this.getSeqUser(e.TestIterationNumber - 1);
            e.TestContextProperties.Add(myParameterName, user);
            e.UserContext[myParameterName] = user;
        }

        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)
        {
            if (path.Length > 0)
            {
                StreamReader re = File.OpenText(path);
                string input = null;
                while ((input = re.ReadLine()) != null)
                {
                    myParams.Add(input);
                }
                re.Close();
                return true;
            }
            else return false;
        }
    }
}