using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Xml.Linq;
using NUnit.Framework;
using OpenTap.EngineUnitTestUtils;
using OpenTap.Package;
using OpenTap.Plugins.BasicSteps;
using OpenTap.UnitTests;

namespace OpenTap.Engine.UnitTests
{
    [TestFixture]
    public class SerializerTests
    {
        public class TestPlanWithMetaData : TestPlan
        {
            [MetaData(Name= "X Setting")]
            public string X { get; set; }
            
            [MetaData]
            public string Y { get; set; }
        } 
        [Test]
        public void TestSerializeTestPlanMetaData()
        {
            var plan = new TestPlanWithMetaData();
            var xml = plan.SerializeToString();
            var xdoc = XDocument.Parse(xml);
            Assert.AreEqual("X Setting", xdoc.Root.Element("X").Attribute("Metadata").Value);
            Assert.AreEqual("Y", xdoc.Root.Element("Y").Attribute("Metadata").Value);
        }
        public class PackageVersionTestStep : TestStep
        {
            public PackageVersion[] PackageVersion { get; set; }
            public override void Run()
            {
                
            }
        }

        [Test]
        [TestCase("No Trailing Space")]
        [TestCase("Yes Trailing Space ")]
        public void TestSerializeInstrumentsWithTrailingSpaceInName(string name)
        {
            using var session = Session.Create(SessionOptions.OverlayComponentSettings);
            var ins = new ScpiInstrument() { Name = name };
            var scpiStep1 = new ScpiTestStep() { Instrument = ins };
            InstrumentSettings.Current.Add(ins);
            var plan = new TestPlan()
            {
                ChildTestSteps = { scpiStep1 }
            };

            { // Verify deserialization completed without errors
                var str = plan.SerializeToString();
                var ser = new TapSerializer();
                var plan2 = ser.DeserializeFromString(str) as TestPlan;
                var scpiStep2 = plan2.ChildTestSteps[0] as ScpiTestStep;

                Assert.AreSame(scpiStep1.Instrument, scpiStep2.Instrument);
                Assert.That(ser.Errors.Count(), Is.EqualTo(0));
            }
        }

        [Test]
        public void TestPackageVersionLicenseSerializer()
        {
            var packageVersion = new PackageVersion("pkg", SemanticVersion.Parse("1.0.0"), "Linux", CpuArchitecture.AnyCPU, DateTime.Now, 
                new List<string>()
                {
                    "License 1",
                    "License 2"
                });
            var ser = new TapSerializer();
            var str = ser.SerializeToString(packageVersion);
            var des = ser.DeserializeFromString(str);
            
            Assert.AreEqual(packageVersion, des);
            CollectionAssert.AreEqual(packageVersion.Licenses, ((des as PackageVersion)!).Licenses);
        }

        [Test]
        public void SerializeInputInTestPlanReferenceTest()
        {
            using (Session.Create(SessionOptions.OverlayComponentSettings))
            {
                TestTraceListener tapTraceListener = new TestTraceListener();
                Log.AddListener(tapTraceListener);
                
                const string PlanName = "ParameterizedIfStep.TapPlan";
                { // Create child plan
                    var childPlan = new TestPlan();
                    var ifstep = new IfStep();
                    childPlan.ChildTestSteps.Add(ifstep);
                    var a = AnnotationCollection.Annotate(ifstep);
                    var m = a.GetMember(nameof(ifstep.InputVerdict));
                    var items = m.Get<MenuAnnotation>().MenuItems.ToArray();
                    var icons = items.ToLookup(item =>
                        item.Get<IIconAnnotation>()?.IconName ?? "");
                    var parameterizeOnTestPlan = icons[IconNames.ParameterizeOnTestPlan].First();
                    var method = parameterizeOnTestPlan.Get<IMethodAnnotation>();
                    method.Invoke();
                
                    childPlan.Save(PlanName);
                }

                tapTraceListener.Flush();
                Assert.IsEmpty(tapTraceListener.ErrorMessage);
                
                // Try to load the child plan
                {
                    var plan = new TestPlan()
                    {
                        ChildTestSteps =
                        {
                            new TestPlanReference()
                            {
                                Filepath = new MacroString() { Text = PlanName }
                            }
                        }
                    };
                    
                    tapTraceListener.Flush();
                    Assert.IsEmpty(tapTraceListener.ErrorMessage);

                    var a = AnnotationCollection.Annotate(plan.ChildTestSteps[0]);
                    var m = a.Get<IMembersAnnotation>().Members.First(m => m.Name == "Load Test Plan");
                    var load = m.Get<IMethodAnnotation>();
                    load.Invoke();
                    tapTraceListener.Flush();
                    Assert.IsEmpty(tapTraceListener.ErrorMessage);
                }
            }
        }
        
        [Test]
        public void TestPackageDependencySerializer()
        {
            var plan = new TestPlan()
            {
                ChildTestSteps = { new DelayStep() }
            };
            var packageVersion = new PackageVersion("pkg", SemanticVersion.Parse("1.0.0"), "Linux", CpuArchitecture.AnyCPU, DateTime.Now, new List<string>());

            { // verify that a serialized plan has package dependencies
                var ser = new TapSerializer();
                var str = ser.SerializeToString(plan);   
                CollectionAssert.IsEmpty(ser.Errors);
                var elem = XElement.Parse(str);
                Assert.AreEqual(1, elem.Elements("Package.Dependencies").Count());
            }
            { // verify that a serialized collection of plans has package dependencies
                var ser = new TapSerializer();
                var plans = new TestPlan[]
                {
                    plan,
                    plan
                };
                var str = ser.SerializeToString(plans);
                CollectionAssert.IsEmpty(ser.Errors);
                var elem = XElement.Parse(str);
                Assert.AreEqual(1, elem.Elements("Package.Dependencies").Count());            
            }
            { // verify that a serialized package version does not have package dependencies
                var ser = new TapSerializer();
                var str = ser.SerializeToString(packageVersion);
                CollectionAssert.IsEmpty(ser.Errors);
                var elem = XElement.Parse(str);
                Assert.AreEqual(0, elem.Elements("Package.Dependencies").Count());

                var deserialized = ser.DeserializeFromString(str);
                Assert.AreEqual(packageVersion, deserialized);
            }
            { // verify that a serialized list of package versions does not have package dependencies
                var ser = new TapSerializer();
                var versions = new PackageVersion[] { packageVersion };
                var str = ser.SerializeToString(versions);
                CollectionAssert.IsEmpty(ser.Errors);
                var elem = XElement.Parse(str);
                Assert.AreEqual(0, elem.Elements("Package.Dependencies").Count());

                var deserialized = ser.DeserializeFromString(str);
                if (deserialized is PackageVersion[] versions2)
                {
                    Assert.AreEqual(1, versions2.Count());
                    CollectionAssert.AreEqual(versions, versions2, "Deserialized versions were different from the serialized versions.");
                }
                else
                {
                    Assert.Fail($"Failed to deserialize serialized version array.");
                }
            }
            { // Verify that a test plan still has package dependencies when it contains a PackageVersion property
                var ser = new TapSerializer();
                var plan2 = new TestPlan()
                {
                    ChildTestSteps =
                    {
                        new PackageVersionTestStep()
                        {
                            PackageVersion = new[] { packageVersion }
                        }
                    }
                };
                var str = ser.SerializeToString(plan2);   
                CollectionAssert.IsEmpty(ser.Errors);
                var elem = XElement.Parse(str);
                Assert.AreEqual(1, elem.Elements("Package.Dependencies").Count());
            }
        }

        public interface IPSU : IInstrument
        {
            
        }

        public class InstrA : Instrument, IPSU
        {
            
        }
        public class InstrB : Instrument, IPSU
        {
            
        }

        public class StepA : TestStep
        {
            public IPSU Instr { get; set; }
            public List<IPSU> Instrs { get; set; } = new List<IPSU>();
            
            public override void Run() { }
        }

        [Test]
        public void TestSerializingResourceReferences()
        {
            using (Session.Create())
            {
                InstrumentSettings.Current.Clear();
                var instr = new InstrA {Name = "AABBCC"};
                var instr2 = new InstrB {Name = "AABBCC"};
                var instr3 = new InstrB();
                var instr4 = new InstrB();
                InstrumentSettings.Current.Add(instr);
                var step = new StepA()
                {
                    Instr = instr
                };
                step.Instrs.Add(instr);
                var plan = new TestPlan();
                plan.ChildTestSteps.Add(step);

                var x = plan.SerializeToString();
                InstrumentSettings.Current.Remove(instr);
                InstrumentSettings.Current.AddRange([instr3, instr2, instr4]);
                var serializer = new TapSerializer();
                var plan2 = (TestPlan)serializer.DeserializeFromString(x);
                var step2 = (StepA)plan2.ChildTestSteps[0];
                Assert.AreEqual(instr2, step2.Instr);
                Assert.AreEqual(instr2, step2.Instrs[0]);
                var msg = serializer.XmlMessages.FirstOrDefault();
                StringAssert.Contains("Selected resource 'AABBCC' of type InstrB instead of declared type InstrA.", msg.ToString());
            }
        }

        public class StepWithLicenseException : TestStep
        {
            public static bool ThrowLicense; 
            public StepWithLicenseException()
            {
                if (ThrowLicense)
                    throw new LicenseException(GetType());
            }
            public override void Run() { }
        }
        

        [Test]
        public void DeserializeLicensedTest()
        {
            TestTraceListener tapTraceListener = new TestTraceListener();

            using (Session.Create(SessionOptions.RedirectLogging))
            {
                Log.AddListener(tapTraceListener);
                var step = new StepWithLicenseException();
                var plan = new TestPlan();
                plan.Steps.Add(step);
                var str = plan.SerializeToString();
                try
                {
                    StepWithLicenseException.ThrowLicense = true;
                    new TapSerializer().DeserializeFromString(str);
                }
                finally
                {
                    StepWithLicenseException.ThrowLicense = false;
                }
            }
            // there should only be one error message (the license error)
            Assert.AreEqual(1, tapTraceListener.ErrorMessage.Count);
            Assert.AreEqual(1,
                tapTraceListener.ErrorMessage.Count(x =>
                    x.Contains("Unable to read StepWithLicenseException. A valid license cannot be granted")));
        }
        
        [AllowAnyChild]
        public class TestSerializerChildSteps : TestStep
        {
            public TestSerializerChildSteps()
            {
                ChildTestSteps.Add(new DelayStep());
                ChildTestSteps.Add(new DelayStep());
                ChildTestSteps.Add(new DelayStep());
                ChildTestSteps.Add(new DelayStep());
            }
            public override void Run()
            {
            }
        }

        [Test]
        public void TestDeserializeStep()
        {
            { // round one
                var s = new TestSerializerChildSteps();
                s.ChildTestSteps.Clear();
                var xml = new TapSerializer().SerializeToString(s);
                var s2 = new TapSerializer().DeserializeFromString(xml) as TestSerializerChildSteps;
                
                Assert.AreEqual(s.ChildTestSteps.Count, s2.ChildTestSteps.Count);
            }
            { // round two
                var chld = new TestSerializerChildSteps();
                var plan = new TestPlan()
                {
                    ChildTestSteps = { chld }
                };

                var expected = chld.ChildTestSteps.Count;

                Assert.AreEqual(expected, plan.ChildTestSteps[0].ChildTestSteps.Count);
                Reload();
                Assert.AreEqual(expected, plan.ChildTestSteps[0].ChildTestSteps.Count);
                while (plan.ChildTestSteps[0].ChildTestSteps.Count > 0)
                {
                    expected = plan.ChildTestSteps[0].ChildTestSteps.Count - 1;
                    plan.ChildTestSteps[0].ChildTestSteps.RemoveAt(0);
                    Reload();
                    Assert.AreEqual(expected, plan.ChildTestSteps[0].ChildTestSteps.Count);
                }

                void Reload()
                {
                    var planXml = new TapSerializer().SerializeToString(plan);
                    plan = new TapSerializer().DeserializeFromString(planXml) as TestPlan;
                }
            }
        }

        public class DynamicDependencySerializerPlugin : TapSerializerPlugin, ITapSerializerPluginDependencyMarker
        {

            public override double Order => 1000;
            HashSet<XElement> visitedNodes = new HashSet<XElement>();
            static XName testPlanName = "TestPlan";
            public override bool Deserialize(XElement node, ITypeData t, Action<object> setter)
            {
                if (node.Name == testPlanName)
                {
                    if (visitedNodes.Add(node))
                        return Serializer.Deserialize(node, setter, t);
                }
                return false;
            }
            public override bool Serialize(XElement node, object obj, ITypeData expectedType)
            {
                if (visitedNodes.Add(node) == false) return false;
                return Serializer.Serialize(node, obj, expectedType, true);
            }
            
            public bool NeededForDeserialization
            {
                get;
                set;
            }
        }

        public class NestedObject2
        {
            public double X { get; set; }
            public double Y { get; set; }
        }
        
        public class NestedObject
        {
            public NestedObject2 A { get; set; } = new NestedObject2() {X = 1, Y = 2};
            public NestedObject2 B { get; set; } = new NestedObject2() {X = 4, Y = 10};
            public List<NestedObject2> Objects { get; set; }= new List<NestedObject2>();
            public double C { get; set; } = 5.0;
        }

        [Test]
        public void TestSerializeNestedObject()
        {
            var obj0 = new NestedObject();
            obj0.C = 10;
            obj0.A = new NestedObject2 {X = 3, Y = 3};
            obj0.B = new NestedObject2 {X = 10, Y = 11};
            obj0.Objects.Add(new NestedObject2 {X = 1, Y = -1});
            var serializer = new TapSerializer();
            var xml = serializer.SerializeToString(obj0);
            var obj1 = (NestedObject) serializer.DeserializeFromString(xml);
            
            Assert.AreEqual(10.0, obj1.C);
            Assert.AreEqual(3.0, obj1.A.X);
            Assert.AreEqual(3.0, obj1.A.Y);
            Assert.AreEqual(10.0, obj1.B.X);
            Assert.AreEqual(11.0, obj1.B.Y);

            Assert.AreEqual(1, obj1.Objects.Count);
            Assert.AreEqual(1, obj1.Objects[0].X);
            Assert.AreEqual(-1, obj1.Objects[0].Y);

        }

        [TestCase(true)]
        [TestCase(false)]
        public void SerializerMaybeUsedType(bool addSerializerPluginDependency)
        {
            var serializer = new TapSerializer();
            var obj = new TestPlan();
            serializer.GetSerializer<DynamicDependencySerializerPlugin>().NeededForDeserialization = addSerializerPluginDependency;
            serializer.SerializeToString(obj);
            var usedTypes = serializer.GetUsedTypes();
            var wasUsed = usedTypes.Contains(TypeData.FromType(typeof(DynamicDependencySerializerPlugin)));
            if (addSerializerPluginDependency)
            {
                Assert.IsTrue(wasUsed);
            }
            else
            {
                Assert.IsFalse(wasUsed);
            }
        }

        public class ObjectWithNullable
        {
            // if the value is 0x1337 means it has not been set. If its deliberately set to null
            // we should not treat it as default.
            public double? NullableDouble { get; set; } = 0x1337;
        }
        
        [Test]
        public void TestSerializerDeferOrder()
        {
            var ser = new TapSerializer();
            int count = 0;

            Action Assertion(int expected)
            {
                return () =>
                {
                    count++;
                    Assert.That(expected, Is.EqualTo(count));
                };
            }

            // Even though this defer is inserted first, it should run last
            ser.DeferLoad(Assertion(7), TapSerializer.DeferredLoadOrder.ExternalParameter);
            // This defer should run after all normal Defers
            ser.DeferLoad(Assertion(5), TapSerializer.DeferredLoadOrder.ParameterMemberDataSetter);
            // These defers should run first although they are inserted late
            ser.DeferLoad(Assertion(1), TapSerializer.DeferredLoadOrder.Normal);
            ser.DeferLoad(Assertion(2), TapSerializer.DeferredLoadOrder.Normal);
            ser.DeferLoad(Assertion(3), TapSerializer.DeferredLoadOrder.Normal);
            
            ser.DeferLoad(() =>
            {
                // The defer inserted in this defer should run before parameter defers
                ser.DeferLoad(Assertion(4), TapSerializer.DeferredLoadOrder.Normal);
            }, TapSerializer.DeferredLoadOrder.Normal);
            
            ser.DeferLoad(() =>
            {
                // This defer is inserted during the parameter defer phase, and is expected to run before the external parameter defers
                ser.DeferLoad(Assertion(6), TapSerializer.DeferredLoadOrder.Normal);
            }, TapSerializer.DeferredLoadOrder.ParameterMemberDataSetter);
            
            Assert.That(count, Is.EqualTo(0));
            ser.Flush();
            Assert.That(count, Is.EqualTo(7));
        }

        [Test]
        public void SerializeDeserializePropertyWithNullable()
        {
            var a = new ObjectWithNullable
            {
                NullableDouble = 5
            };
            var b = new ObjectWithNullable()
            {
                NullableDouble = null
            };

            // The problem only occurs if the type is not explicit. Note in the future we will probably
            // not require explicit type since it can be inferred through reflection, so this should work without.
            var aXml = new TapSerializer().SerializeToString(a).Replace("type=\"System.Double\"", "");
            var bXml = new TapSerializer().SerializeToString(b).Replace("type=\"System.Double\"", "");
            var a2 = (ObjectWithNullable)new TapSerializer().DeserializeFromString(aXml);
            var b2 = (ObjectWithNullable)new TapSerializer().DeserializeFromString(bXml);
            Assert.AreEqual(a.NullableDouble, a2.NullableDouble);
            Assert.AreEqual(b.NullableDouble, b2.NullableDouble);



        }
    }
}