using System;
using System.Linq;
using System.Xml.Serialization;
using NUnit.Framework;
using OpenTap.Engine.UnitTests;
namespace OpenTap.UnitTests
{
    [TestFixture]
    public class EmbeddedPropertyTests
    {
        public class EmbeddedTest2
        {
            // this should give EmbeddedTest all the virtual properties of DataInterfaceTestClass.
            [Display("Embedded Things")]
            [EmbedProperties(PrefixPropertyName = false)]
            public MemberDataProviderTests.DataInterfaceTestClass EmbeddedThings { get; set; } = new MemberDataProviderTests.DataInterfaceTestClass();
        }

        [Test]
        public void EmbeddedPropertiesReflectionAndAnnotation()
        {
            var obj = new EmbeddedTest2();
            obj.EmbeddedThings.SimpleNumber = 3145.2;
            var type = TypeData.GetTypeData(obj);
            var display = type.GetMembers().First().GetDisplayAttribute();
            Assert.IsTrue(display.Group[0] == "Embedded Things"); // test that the name gets transformed.
            var emba = type.GetMember(nameof(MemberDataProviderTests.DataInterfaceTestClass.SimpleNumber));
            Assert.AreEqual(obj.EmbeddedThings.SimpleNumber, (double)emba.GetValue(obj));
            var embb = type.GetMember(nameof(MemberDataProviderTests.DataInterfaceTestClass.FromAvailable));
            Assert.AreEqual(obj.EmbeddedThings.FromAvailable, (double)embb.GetValue(obj));

            var annotated = AnnotationCollection.Annotate(obj);
            annotated.Read();
            var same = annotated.Get<IMembersAnnotation>().Members.FirstOrDefault(x => x.Get<IMemberAnnotation>().Member == emba);
            Assert.AreEqual("3145.2 Hz", same.Get<IStringValueAnnotation>().Value);
        }



        [Test]
        public void EmbeddedPropertiesSerialization()
        {
            var ts = new TapSerializer();
            var obj = new EmbeddedTest2();
            obj.EmbeddedThings.SimpleNumber = 500;
            var str = ts.SerializeToString(obj);
            obj = (EmbeddedTest2)ts.DeserializeFromString(str);
            Assert.AreEqual(500, obj.EmbeddedThings.SimpleNumber);
        }

        public class EmbA: ValidatingObject
        {
            public double X { get; set; }

            public EmbA()
            {
                Rules.Add(() => X >= 0, "X < 0", nameof(X));
            }
        }

        public class EmbB : ValidatingObject
        {
            [EmbedProperties(PrefixPropertyName = false)]
            public EmbA A { get; set; } = new EmbA();

            [EmbedProperties(Prefix = "A")]
            public EmbA A2 { get; set; } = new EmbA();
            
            public double Y { get; set; }

            public EmbB()
            {
                Rules.Add(()=> Y >= 0, "Y < 0", nameof(Y));
            }
        }

        public class EmbC
        {
            [EmbedProperties]
            public EmbB B { get; set; } = new EmbB();
            
        }
        
        [Test]
        public void NestedEmbeddedTest()
        {
            var c = new EmbC();
            c.B.A2.X = 5;
            c.B.A.X = 35;
            var embc_type = TypeData.GetTypeData(c);

            var members = embc_type.GetMembers();

            var mem = embc_type.GetMember("B.A.X");
            
            Assert.AreEqual(c.B.A2.X, (double)mem.GetValue(c));
            mem.SetValue(c, 20);
            Assert.AreEqual(c.B.A2.X, 20.0);

            var mem2 = embc_type.GetMember("B.X");
            Assert.AreEqual(c.B.A.X, (double)mem2.GetValue(c));

            var ts = new TapSerializer();
            var str = ts.SerializeToString(c);
            var c2 = (EmbC)ts.DeserializeFromString(str);
            Assert.AreNotEqual(c, c2);
            Assert.AreEqual(c.B.A.X, c2.B.A.X);

            Assert.IsTrue(true == string.IsNullOrWhiteSpace(c.B.A2.Error));
            c.B.Y = -5;
            
            var a = AnnotationCollection.Annotate(c);
            var mem_b_y = a.GetMember("B.Y");
            var err1 = mem_b_y.GetAll<IErrorAnnotation>().SelectMany(x => x.Errors).FirstOrDefault();
            Assert.IsTrue(string.IsNullOrWhiteSpace(err1) == false);
            c.B.Y = 5;
            c.B.A2.X = -5;
            var mem_b_a2_x = a.GetMember("A.X");
            var err2 = mem_b_a2_x.GetAll<IErrorAnnotation>().SelectMany(x => x.Errors).FirstOrDefault();
            Assert.IsTrue(string.IsNullOrWhiteSpace(err2) == false);
            
        }

        public class EmbD
        {
            [EmbedProperties]
            public EmbD B { get; set; }
            public int X { get; set; }
        }

        [Test]
        public void RecursiveEmbeddedTest()
        {
            var d = new EmbD();
            var t = TypeData.GetTypeData(d);
            var members = t.GetMembers(); // this will throw a StackOverflowException if the Embedding does not take care of the potential problem.
            Assert.AreEqual(2, members.Count());
        }

        public class OverrideVerdictMixin : ITestStepPostRunMixin
        {
            [Display("Override Verdict")]
            public Verdict OverrideVerdict { get; set; } = Verdict.Pass;
            
            public void OnPostRun(TestStepPostRunEventArgs step)
            {
                step.TestStep.Verdict = OverrideVerdict;
            }
        }
        
        public class TestRepeatMixin : ITestStepPostRunMixin, ITestStepPreRunMixin
        {
            [Display("Repeat Count")]
            public int Count { get; set; } = 1;

            int? it = null; 
            public void OnPostRun(TestStepPostRunEventArgs step)
            {
                if (it == null)
                    it = 1;
                if (it >= Count)
                    it = null;
                else
                {
                    step.TestStep.StepRun.SuggestedNextStep = step.TestStep.Id;
                    it += 1;
                }
            }
            
            public void OnPreRun(TestStepPreRunEventArgs step)
            {
                if (Count == 0) step.SkipStep = true;
            }
        }

        public class TestStepWithMixin : TestStep
        {
            [EmbedProperties]
            public OverrideVerdictMixin OverrideVerdict { get; set; } = new OverrideVerdictMixin();

            [EmbedProperties]
            public TestRepeatMixin Repeat { get; set; } = new TestRepeatMixin();

            internal int Repeats = 0;
            public override void PrePlanRun()
            {
                base.PrePlanRun();
                Repeats = 0;
            }

            public override void Run()
            {
                Repeats++;
                UpgradeVerdict(Verdict.Fail);
            }
        }

        [Test]
        public void TestTestStepMixinsBasic()
        {
            var plan = new TestPlan();
            var step1 = new TestStepWithMixin();
            step1.Repeat.Count = 5;
            plan.ChildTestSteps.Add(step1);
            var run = plan.Execute();
            Assert.AreEqual(step1.OverrideVerdict.OverrideVerdict, run.Verdict);
            Assert.AreEqual(step1.Repeat.Count, step1.Repeats);
            
            // now set the repeat count to 0.
            step1.Repeat.Count = 0;
            var run2 = plan.Execute();
            Assert.AreEqual(Verdict.NotSet, run2.Verdict);
            Assert.AreEqual(step1.Repeat.Count, step1.Repeats);
        }

        public class ResourceMultiMixin : IResourcePreOpenMixin
        {
            public bool PreOpenCalled = false;
            public void OnPreOpen(ResourcePreOpenEventArgs eventArgs)
            {
                PreOpenCalled = true;
            }
        }

        public class ResourceMixinTest : Instrument
        {
            [EmbedProperties]
            public ResourceMultiMixin TestMixin { get; set; } = new ResourceMultiMixin();
        }

        [Test]
        public void TestResourceMixins()
        {
            var resource = new ResourceMixinTest();
            var step = new AnnotationTest.InstrumentStep();
            step.Instrument = resource;
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(step);
            plan.Execute();
            Assert.IsTrue(resource.TestMixin.PreOpenCalled);
        }

        public class EmbeddingClass
        {
            protected bool Equals(EmbeddingClass other)
            {
                return IntMember == other.IntMember && StringMember == other.StringMember;
            }

            public override bool Equals(object obj)
            {
                if (obj is null) return false;
                if (ReferenceEquals(this, obj)) return true;
                if (obj.GetType() != GetType()) return false;
                return Equals((EmbeddingClass)obj);
            }

            public override int GetHashCode() =>  IntMember.GetHashCode() * 12389321 + StringMember.GetHashCode() * 7310632;

            public int IntMember { get; set; }
            public string StringMember { get; set; }
        }

        public class EmbeddedTest3
        {
            // This is the member I want to serialize, but it will never be shown to the user.
            [AnnotationIgnore] public EmbeddingClass[] Objects { get; set; }

            //the index of object can be selected
            public int SelectedObjectIndex { get; set; }

            [EmbedProperties] [XmlIgnore] public EmbeddingClass SelectedObject => Objects[SelectedObjectIndex];
        }

        [Test]
        public void TestXmlIgnoreEmbedding()
        {
            var emb = new EmbeddedTest3()
            {
                SelectedObjectIndex = 1,
                Objects = [new() { IntMember = 0, StringMember = "0" }, new() { IntMember = 1, StringMember = "1" }, new() { IntMember = 2, StringMember = "2" }],
            };
            var ser = new TapSerializer();
            var str = ser.SerializeToString(emb);
            var emb2 = ser.DeserializeFromString(str) as EmbeddedTest3;
            
            
            Assert.That(str, Does.Not.Contain("SelectedObject.IntMember")); 
            Assert.That(emb2, Is.Not.Null);
            
            Assert.That(AnnotationCollection.Annotate(emb).GetMember("Objects"),  Is.Null);
            Assert.That(AnnotationCollection.Annotate(emb2).GetMember("Objects"),  Is.Null); 
            
            Assert.That(emb.SelectedObjectIndex, Is.EqualTo(emb2.SelectedObjectIndex));
            Assert.That(emb.SelectedObject, Is.EqualTo(emb2.SelectedObject));
            CollectionAssert.AreEqual(emb.Objects, emb2.Objects);
            
            verifyEmbedded(emb);
            verifyEmbedded(emb2); 
            void verifyEmbedded(object o)
            {
                var embedded = TypeData.GetTypeData(o).GetMembers().OfType<EmbeddedMemberData>().ToArray(); 
                Assert.That(embedded.Length, Is.EqualTo(2));

                foreach (var emb in embedded)
                {
                    Assert.That(emb.HasAttribute<XmlIgnoreAttribute>(), Is.True);
                }
            }
        }
    }

}