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

namespace OpenTap.UnitTests
{
    public class TestResource : IInstrument
    {
        public bool HasBeenOpened { get; set; } = false;

        public string Name { get; set; } = nameof(TestResource);

        public void Open()
        {
            IsConnected = true;
            HasBeenOpened = true;
        }

        public void Close()
        {
            IsConnected = false;
        }
        
        public bool IsConnected { get; private set; }
        // Disable 'unused' warnings
#pragma warning disable CS0067
        public event PropertyChangedEventHandler PropertyChanged;
#pragma warning restore CS0067
    }
    public class ResourceTest
    {
        public class ResourceTestStep : TestStep
        {
            [EnabledIf(nameof(ResourceEnabled))]
            public IInstrument MyTestResource { get; set; }
            public bool ResourceEnabled { get; set; }
            public override void Run()
            {
                try
                {
                    if (ResourceEnabled)
                        Assert.IsTrue(MyTestResource.IsConnected);
                }
                catch
                {
                    
                }
            }
        }

        [Test]
        public void TestNoConnectResource([Values(true, false)] bool resourceEnabled)
        {
            using (Session.Create())
            {
                var dummyInstr = new OpenCrash();
                InstrumentSettings.Current.Add(dummyInstr);
                var step = new ResourceTestStep {MyTestResource = dummyInstr, ResourceEnabled = resourceEnabled};
                var plan = new TestPlan();
                plan.Steps.Add(step);
                var run = plan.Execute();
                if(resourceEnabled)
                    Assert.AreEqual(Verdict.Error, run.Verdict);
                else
                    Assert.AreEqual(Verdict.NotSet, run.Verdict);
            }
        }
        
        [AllowAnyChild]
        public class IgnoredResourceStep : TestStep
        {
            [ResourceOpen(ResourceOpenBehavior.Ignore)]
            public TestResource SomeInstrument { get; set; }

            public override void Run()
            {
                Assert.IsFalse(SomeInstrument.IsConnected);
                RunChildSteps();
                Assert.IsFalse(SomeInstrument.IsConnected);
            }
        }

        public class SlowOpenInstrument : IInstrument
        {
            // Disable 'unused' warnings
#pragma warning disable CS0067
            public event PropertyChangedEventHandler PropertyChanged;
#pragma warning restore CS0067
            public string Name { get; set; }
            public void Open()
            {
                var trd = TapThread.Current;
                while (trd != null)
                {
                    if (trd.Name == "Plan Thread")
                        break;
                    trd = trd.Parent;
                }
                Assert.That(trd, Is.Not.Null);
                
                var cancel = new CancellationTokenSource(TimeSpan.FromSeconds(2));
                WasStopped = false;
                int handle = WaitHandle.WaitAny(new[] { TapThread.Current.AbortToken.WaitHandle, cancel.Token.WaitHandle });
                WasStopped = handle == 0;
            }

            public void Close()
            {
                
            }

            public bool IsConnected => true;
            public bool WasStopped { get; set; }
        }

        [Test]
        public void SlowOpenInstrumentTest([Values(false, true)] bool UseLazyResourceManager)
        {
            using var session = Session.Create(SessionOptions.OverlayComponentSettings);
            IResourceManager manager =
                UseLazyResourceManager ? (IResourceManager)new LazyResourceManager() : new ResourceTaskManager();
            EngineSettings.Current.ResourceManagerType = manager;
            
            var instrument = new SlowOpenInstrument();
            var step = new ResourceTestStep {MyTestResource = instrument, ResourceEnabled = true};
            var plan = new TestPlan()
            {
                ChildTestSteps = { step }
            };

            Assert.IsFalse(instrument.WasStopped);
            var abortToken = new CancellationTokenSource(TimeSpan.FromMilliseconds(1000));
            var run = plan.ExecuteAsync(abortToken.Token);
            abortToken.Token.WaitHandle.WaitOne();
            TapThread.Sleep(TimeSpan.FromSeconds(1));
            Assert.IsTrue(instrument.WasStopped);
        }
        
        
        [Test]
        public void ResourceParameterOpenTest()
        {
            var oldResourceManager = EngineSettings.Current.ResourceManagerType;

            try
            {
                foreach (var resourceManager in new IResourceManager[]
                    {new ResourceTaskManager(), new LazyResourceManager()})
                {
                    EngineSettings.Current.ResourceManagerType = resourceManager;
                    var testPlan = new TestPlan();

                    var ignoredResourceStep = new IgnoredResourceStep();
                    var resourceStep = new ResourceTestStep();
                    ignoredResourceStep.ChildTestSteps.Add(resourceStep);
                    testPlan.ChildTestSteps.Add(ignoredResourceStep);

                    ignoredResourceStep = new IgnoredResourceStep();
                    resourceStep = new ResourceTestStep();
                    ignoredResourceStep.ChildTestSteps.Add(resourceStep);
                    testPlan.ChildTestSteps.Add(ignoredResourceStep);

                    testPlan.Execute();
                }
            }
            finally
            {
                EngineSettings.Current.ResourceManagerType = oldResourceManager;
            }
        }
        
        class TestLogListener : ILogListener
        {
            public List<Event> EventList { get; } = new List<Event>();
            public void EventsLogged(IEnumerable<Event> Events)
            {
                EventList.AddRange(Events);
            }

            public void Flush()
            {
            }

            public void Clear()
            {
                EventList.Clear();
            }

            private bool Contains(string msg)
            {
                var list = new List<Event>(EventList);
                return list.Any(x => x.Message.ToLower().Contains(msg.ToLower()));
            }

            public void AssertContains(string msg)
            {
                Assert.IsTrue(Contains(msg));
            }

            public void AssertDoesNotContain(string msg)
            {
                Assert.IsFalse(Contains(msg));
            }

            private bool ContainsWarningsOrErrors()
            {
                var list = new List<Event>(EventList);
                return list.Any(x =>
                    x.EventType == (int) LogEventType.Warning || x.EventType == (int) LogEventType.Error);
            }

            public void AssertWarnings()
            {
                Assert.IsTrue(ContainsWarningsOrErrors());
            }

            public void AssertNoWarnings()
            {
                Assert.IsFalse(ContainsWarningsOrErrors());
            }

        }

        static class Messages
        {
            public const string ResourceOpened = @"Resource ""OpenTap.UnitTests.TestResource"" opened.";
            public const string MyTestResourceNotSet = @"Resource setting MyTestResource not set on step";
            public const string ResourceMissingFromBenchSettings = @"Test Plan changed due to resources missing from Bench settings.";
            public const string TestPlanCompleted = @"""Test Plan Reference \ ResourceTestStep"" completed.";
            public const string EnabledIfPropertyMissing = @"Could not find property 'ResourceEnabled'";
        }

        [Test]
        public void EnabledIfResourceWarningTest()
        {
            var listener = new TestLogListener();

            var resource = new TestResource();
            var enabledStep = new ResourceTestStep()
                {ResourceEnabled = true, MyTestResource = resource};
            var disabledStep = new ResourceTestStep()
                {ResourceEnabled = false, MyTestResource = resource};
            

            TestPlanRun ExecutePlan(ResourceTestStep step, bool resourceDisappears)
            {
                InstrumentSettings.Current.Clear();
                InstrumentSettings.Current.Add(resource);

                var serializer = new TapSerializer();
                
                var testPlan = new TestPlan();
                testPlan.ChildTestSteps.Add(step);
                
                testPlan.ExternalParameters.Add(step,
                    TypeData.GetTypeData(step).GetMember(nameof(step.MyTestResource)));
                
                Assert.AreEqual(1, TypeData.GetTypeData(testPlan).GetMembers().OfType<IParameterMemberData>().Count());
                
                testPlan.Save("testTestPlan.TapPlan");

                var realTestPlan = new TestPlan();
                var realTestStep = new TestPlanReference()
                    {Filepath = new MacroString() {Text = testPlan.Path}};
                realTestPlan.ChildTestSteps.Add(realTestStep);
                realTestStep.LoadTestPlan();
                realTestPlan.ChildTestSteps.Add(step);
                
                Assert.AreEqual(1, TypeData.GetTypeData(realTestStep).GetMembers().OfType<IParameterMemberData>().Count());

                var testPlanText = serializer.SerializeToString(realTestPlan);
                
                // Reload the test plan without the resource -- this should cause a warning
                if (resourceDisappears)
                    InstrumentSettings.Current.Clear();
                
                var deserializedTestPlan = (TestPlan)serializer.DeserializeFromString(testPlanText);
                (deserializedTestPlan.ChildTestSteps.First() as TestPlanReference).LoadTestPlan();
                return deserializedTestPlan.Execute();
            }
            
            
            var oldResourceManager = EngineSettings.Current.ResourceManagerType;
            
            try
            {
                Log.AddListener(listener);

                foreach (var resourceManager in new IResourceManager[]
                    {new ResourceTaskManager(), new LazyResourceManager()})
                {
                    EngineSettings.Current.ResourceManagerType = resourceManager;
                    
                    listener.Clear();
                    resource.HasBeenOpened = false;

                    {   /* Resource enabled
                         * Resource is present when reloading the plan */
                        var run = ExecutePlan(enabledStep, false);
                        Assert.IsFalse(run.FailedToStart);
                        Assert.AreEqual(Verdict.NotSet, run.Verdict);

                        Assert.IsTrue(resource.HasBeenOpened);

                        listener.AssertContains(Messages.ResourceOpened);
                        listener.AssertDoesNotContain(Messages.MyTestResourceNotSet);
                        listener.AssertDoesNotContain(Messages.ResourceMissingFromBenchSettings);
                        listener.AssertContains(Messages.TestPlanCompleted);
                        listener.AssertDoesNotContain(Messages.EnabledIfPropertyMissing);
                        listener.AssertNoWarnings();
                    }

                    listener.Clear();
                    resource.HasBeenOpened = false;

                    {   /* Resource disabled
                         * Resource is present when reloading the plan */
                        var run = ExecutePlan(disabledStep, false);
                        Assert.IsFalse(run.FailedToStart);
                        Assert.AreEqual(Verdict.NotSet, run.Verdict);
                        
                        Assert.IsFalse(resource.HasBeenOpened);

                        listener.AssertDoesNotContain(Messages.ResourceOpened);
                        listener.AssertDoesNotContain(Messages.MyTestResourceNotSet);
                        listener.AssertDoesNotContain(Messages.ResourceMissingFromBenchSettings);
                        listener.AssertContains(Messages.TestPlanCompleted);
                        listener.AssertDoesNotContain(Messages.EnabledIfPropertyMissing);
                        listener.AssertNoWarnings();
                    }

                    listener.Clear();
                    resource.HasBeenOpened = false;

                    {   /* Resource disabled
                         * Resource is gone when reloading the plan */
                        var run = ExecutePlan(disabledStep, true);
                        Assert.IsFalse(run.FailedToStart);
                        Assert.AreEqual(Verdict.NotSet, run.Verdict);
                        
                        Assert.IsFalse(resource.HasBeenOpened);

                        listener.AssertDoesNotContain(Messages.ResourceOpened);
                        listener.AssertDoesNotContain(Messages.MyTestResourceNotSet);
                        listener.AssertContains(Messages.ResourceMissingFromBenchSettings);
                        listener.AssertContains(Messages.TestPlanCompleted);
                        listener.AssertDoesNotContain(Messages.EnabledIfPropertyMissing);
                        listener.AssertWarnings();
                    }

                    listener.Clear();
                    resource.HasBeenOpened = false;

                    {   /* Resource enabled
                         * Resource is gone when reloading the plan */
                        var run = ExecutePlan(enabledStep, true);
                        
                        if (resourceManager is LazyResourceManager)
                            Assert.IsFalse(run.FailedToStart);
                        if (resourceManager is ResourceTaskManager)
                            Assert.IsTrue(run.FailedToStart);
                        
                        Assert.AreEqual(Verdict.Error, run.Verdict);
                        
                        Assert.IsFalse(resource.HasBeenOpened);

                        listener.AssertDoesNotContain(Messages.ResourceOpened);
                        listener.AssertContains(Messages.MyTestResourceNotSet);
                        listener.AssertContains(Messages.ResourceMissingFromBenchSettings);
                        listener.AssertDoesNotContain(Messages.TestPlanCompleted);
                        listener.AssertDoesNotContain(Messages.EnabledIfPropertyMissing);
                        listener.AssertWarnings();
                    }
                }
            }
            finally
            {
                EngineSettings.Current.ResourceManagerType = oldResourceManager;
                OpenTap.Log.RemoveListener(listener);
                InstrumentSettings.Current.Clear();
            }
        }
    }
}