using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using NUnit.Framework;
using OpenTap.Engine.UnitTests;
using OpenTap.Plugins.BasicSteps;

namespace OpenTap.UnitTests
{
    public class ResultRow
    {
        public string ResultName { get; set; }
        public int ResultValue { get; set; }
    }

    public class PublishResultsSameValues : TestStep
    {

        public int Count { get; set; } = 100;

        public override void Run()
        {
            var resultValue = new Random().Next();
            for (var i = 0; i < Count; i++)
            {
                Results.Publish(new ResultRow
                {
                    ResultName = $"{this.StepRun.TestStepId}",
                    ResultValue = resultValue
                });
            }
        }
    }
    public class PublishResultsSameValues2 : TestStep
    {

        public int Count { get; set; } = 100;
        public override void Run()
        {
            var rnd = new Random();
            var resultValue = rnd.Next();
            var resultValue2 = rnd.NextDouble();
            
            for (var i = 0; i < Count; i++)
                Results.Publish("Test", new List<string> { "X", "Y" }, resultValue, resultValue2);   
        }
    }

    [TestFixture]
    public class Results2
    {
        [TestCase(typeof(PublishResultsSameValues))]
        [TestCase(typeof(PublishResultsSameValues2))]
        public void TestManyResults(Type stepType)
        {
            // this test has been a bit unstable. Repeat a few times to make sure it works.
            for (int i = 0; i < 5; i++) 
            {
                var record = new RecordAllResultListener();
                var plan = new TestPlan();
                var repeat = new RepeatStep
                {
                    Count = 10
                };
                var parallel = new ParallelStep();

                plan.ChildTestSteps.Add(repeat);

                var results1 = (TestStep)Activator.CreateInstance(stepType);
                var results2 = (TestStep)Activator.CreateInstance(stepType);
                parallel.ChildTestSteps.Add(results1);
                parallel.ChildTestSteps.Add(results2);

                repeat.ChildTestSteps.Add(parallel);

                var run = plan.Execute(new IResultListener[]
                {
                    record
                });
                Assert.AreEqual(Verdict.NotSet, run.Verdict);
                foreach (var table in record.Results)
                {
                    foreach (var column in table.Columns)
                    {
                        var distinctCount = column.Data.Cast<object>().Distinct().Count();
                        Assert.AreEqual(1, distinctCount);
                    }
                }
            }
        }
        
        [TestCase(10, 10)]
        [TestCase(50, 50)]
        [TestCase(100, 100)]
        public void TestSetParameterRaceCondition(int threadCount, int paramsPerThread)
        {
            var step = new DelayStep();
            var run = new TestStepRun(step, Guid.NewGuid(), Array.Empty<ResultParameter>());
            var threads = new Task[threadCount];
            var evt = new ManualResetEventSlim(false);
            
            for (int i = 0; i < threadCount; i++)
            {
                int i2 = i;
                threads[i2] = TapThread.StartAwaitable(() =>
                {
                    evt.Wait();
                    int start = i2 * paramsPerThread;
                    foreach (var i1 in Enumerable.Range(start, paramsPerThread))
                    {
                        run.Parameters[i1.ToString()] = i1;
                    }
                });
            }
            
            // Ensure all the threads are started and waiting on the event
            TapThread.Sleep(1000); 
            evt.Set();
            Task.WaitAll(threads);
            
            for (int i = 0; i < threadCount * paramsPerThread; i++)
            {
                var param = run.Parameters[i.ToString()];
                Assert.AreEqual(param, i);
            }
        }

        class ParameterAssigningResultListener : ResultListener
        {
            public List<string> Assignments = new List<string>();
            public override void OnTestStepRunStart(TestStepRun stepRun)
            {
                base.OnTestStepRunStart(stepRun);
                foreach (var assignment in Assignments)
                {
                    stepRun.Parameters[assignment] = assignment;
                }
            }
        }

        [Test]
        public void TestRacyResultListeners()
        {
            using var session = Session.Create(SessionOptions.OverlayComponentSettings);
            var collector = new PlanRunCollectorListener();
            var a1 = new ParameterAssigningResultListener() { Assignments = { "Param1", "Param2", "Param3" } };
            var a2 = new ParameterAssigningResultListener() { Assignments = { "Param4", "Param5", "Param6" } };
            ResultSettings.Current.Add(a1);
            ResultSettings.Current.Add(a2);
            ResultSettings.Current.Add(collector);

            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new DelayStep());
            plan.Execute();

            Assert.AreEqual(collector.StepRunStartEvents[0].Verdict, Verdict.NotSet);
        }
    }
}