//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using NUnit.Framework;
using System.Xml.Serialization;
using System.Collections.Generic;
using System.Linq;
using OpenTap.EngineUnitTestUtils;

namespace OpenTap.Engine.UnitTests
{
    [TestFixture]
    public class ResultProxyTests 
    {
        
        public class DelegateTestStep : TestStep
        {
            [XmlIgnore]
            public Action<ResultSource> RunAction { get; set; }

            public override void Run()
            {
                RunAction(Results);
            }
        }

        [Test]
        public void LargeValueTest()
        {
            TestPlan plan = new TestPlan();
            DelegateTestStep step = new DelegateTestStep();
            step.RunAction = (Results) =>
            {
                Results.Publish("LargeValueType", new List<string> { "a", "b", "c", "d" }, 0, 9.91e37, 10, 0); // This is the large  value that X-Apps returns when there was no measurement.
            };
            plan.ChildTestSteps.Add(step);
            TestPlanRunner.RunTestPlan(plan);
        }

        [Test]
        public void NaNValueTest()
        {
            TestPlan plan = new TestPlan();
            DelegateTestStep step = new DelegateTestStep();
            step.RunAction = (Results) =>
            {
                Results.Publish("NaNValueType", new List<string> { "a", "b", "c", "d" }, 0, double.NaN, 10, 0);
            };
            plan.ChildTestSteps.Add(step);
            TestPlanRunner.RunTestPlan(plan);
        }

        [Display("My object result")]
        internal class MyResult
        {
            [Display("Testing")]
            public int A { get; set; }

            [Display("Value [dBm]")]
            public double b { get; set; }
        }

        internal class TempResultListener : ResultListener
        {
            public ResultTable LastResult;

            public override void OnResultPublished(Guid stepRunID, ResultTable result)
            {
                base.OnResultPublished(stepRunID, result);
                LastResult = result;
            }
        }

        [Test]
        public void ObjectResultTest()
        {
            TempResultListener rl = new TempResultListener();

            ResultSettings.Current.Add(rl);

            TestPlan plan = new TestPlan();
            DelegateTestStep step = new DelegateTestStep();
            step.RunAction = (Results) =>
            {
                Results.Publish(new MyResult { A = 123, b = -123e-1 });
            };
            plan.ChildTestSteps.Add(step);
            TestPlanRunner.RunTestPlan(plan);

            Assert.IsNotNull(rl.LastResult);
            Assert.AreEqual("My object result", rl.LastResult.Name);
            Assert.AreEqual(2, rl.LastResult.Columns.Length);
            Assert.AreEqual(1, rl.LastResult.Rows);
            Assert.AreEqual("Testing", rl.LastResult.Columns[0].Name);
            Assert.AreEqual("Value [dBm]", rl.LastResult.Columns[1].Name);

            Assert.AreEqual(TypeCode.Int32, rl.LastResult.Columns[0].TypeCode);
            Assert.AreEqual(TypeCode.Double, rl.LastResult.Columns[1].TypeCode);

            Assert.AreEqual(123, rl.LastResult.Columns[0].GetValue<Int32>(0));
            Assert.AreEqual(-123e-1, rl.LastResult.Columns[1].GetValue<double>(0));

            ResultSettings.Current.Remove(rl);
        }

        public class ResultObjectBase
        {
            public double Freq { get; set; }
            public double Power { get; set; }
        }

        public class EvmResultObject : ResultObjectBase
        {
            public double Evm { get; set; }
        }


        [Test]
        public void DerivedObjectResultTest()
        {
            TempResultListener rl = new TempResultListener();

            ResultSettings.Current.Add(rl);

            TestPlan plan = new TestPlan();
            DelegateTestStep step = new DelegateTestStep();
            ResultObjectBase result = new EvmResultObject() { Freq = 1, Power = 2, Evm = 3 };
            step.RunAction = (Results) =>
            {
                Results.Publish(result);
            };
            plan.ChildTestSteps.Add(step);
            TestPlanRunner.RunTestPlan(plan);

            Assert.IsNotNull(rl.LastResult);
            Assert.AreEqual("EvmResultObject", rl.LastResult.Name);
            Assert.AreEqual(3, rl.LastResult.Columns.Length);
            Assert.AreEqual(1, rl.LastResult.Rows);
            Assert.AreEqual("Evm", rl.LastResult.Columns[0].Name);

            ResultSettings.Current.Remove(rl);
        }

        [Test]
        public void AnonymousObjectResultTest()
        {
            TempResultListener rl = new TempResultListener();

            ResultSettings.Current.Add(rl);

            TestPlan plan = new TestPlan();
            DelegateTestStep step = new DelegateTestStep();
            step.RunAction = (Results) =>
            {
                Results.Publish("My object result", new { A = 123, b = -123e-1 });
            };
            plan.ChildTestSteps.Add(step);
            TestPlanRunner.RunTestPlan(plan);

            Assert.IsNotNull(rl.LastResult);
            Assert.AreEqual("My object result", rl.LastResult.Name);
            Assert.AreEqual(2, rl.LastResult.Columns.Length);
            Assert.AreEqual(1, rl.LastResult.Rows);
            Assert.AreEqual("A", rl.LastResult.Columns[0].Name);
            Assert.AreEqual("b", rl.LastResult.Columns[1].Name);

            Assert.AreEqual(TypeCode.Int32, rl.LastResult.Columns[0].TypeCode);
            Assert.AreEqual(TypeCode.Double, rl.LastResult.Columns[1].TypeCode);

            Assert.AreEqual(123, rl.LastResult.Columns[0].GetValue<Int32>(0));
            Assert.AreEqual(-123e-1, rl.LastResult.Columns[1].GetValue<double>(0));

            ResultSettings.Current.Remove(rl);
        }

        private class ResultValidator : ResultListener
        {
            public List<ResultTable> Results { get; } = new List<ResultTable>();
            public List<(ResultTable,TestStepRun)> Results2 { get; } = new List<(ResultTable, TestStepRun)>();


            Dictionary<Guid, TestStepRun> stepRuns = new Dictionary<Guid, TestStepRun>();
            public override void OnTestStepRunStart(TestStepRun stepRun)
            {
                stepRuns[stepRun.Id] = stepRun;
            }

            public override void OnTestStepRunCompleted(TestStepRun stepRun)
            {
                stepRuns.Remove(stepRun.Id);
            }


            public override void OnResultPublished(Guid stepRunId, ResultTable result)
            {
                Results.Add(result);
                Results2.Add((result,stepRuns[stepRunId]));
            }
        }
        

        [Test]
        public void ResultsProxyTest()
        {
            TestPlan tp = new TestPlan();
            tp.ChildTestSteps.Add(new DelegateTestStep
            {
                RunAction = (r) =>
                {
                    var rand = new Random();

                    IConvertible[] values = new IConvertible[3];
                    values[0] = rand.NextDouble();
                    values[1] = rand.NextDouble();
                    values[2] = rand.NextDouble();

                    r.Publish("Publish1", new List<string> { "a", "b", "c" }, values);
                    r.Publish("Publish2", new List<string> { "a", "b", "c" }, values);
                    r.PublishTable("PublishTable", new List<string> { "a", "b", "c" }, values.Select(v => new IConvertible[1] { v }).ToArray());

                    values[0] = rand.NextDouble();
                    values[1] = rand.NextDouble();
                    values[2] = rand.NextDouble();

                    values[0] = "abc";
                    values[1] = "rand";
                    values[2] = "rand.NextDouble()";
                    r.Publish("PublishStrings", new List<string> { "a", "b", "c" }, values);

                    values[0] = null;
                    values[1] = "rand";
                    values[2] = true;
                    r.Publish("PublishMixed", new List<string> { "a", "b", "c" }, values);
                }
            });

            var rl = new ResultValidator();
            tp.Execute(new List<ResultListener> { rl });

            Assert.AreEqual(5, rl.Results.Count, "Number of results");
            foreach (var res in rl.Results)
            {
                Assert.IsTrue(res.Name.StartsWith("Publish"), "Name of result");
                Assert.AreEqual(3, res.Columns.Length, "Number of columns in " + res.Name);

                Assert.AreEqual(1, res.Columns[0].Data.Length);
                Assert.AreEqual(1, res.Columns[1].Data.Length);
                Assert.AreEqual(1, res.Columns[2].Data.Length);

                Assert.AreEqual("a", res.Columns[0].Name);
                Assert.AreEqual("b", res.Columns[1].Name);
                Assert.AreEqual("c", res.Columns[2].Name);
            }
        }

        public class TestCls<T>
        {
            public class TestCls2<T2>
            {
                public T X { get; set; }
                public T2 Y { get; set; }
            }

            public T X { get; set; }
        }

        [Test]
        public void ResultTableName()
        {
            var rl = new ResultValidator();
            TestPlan tp = new TestPlan();
            tp.ChildTestSteps.Add(new DelegateTestStep
            {
                RunAction = (r) =>
                {
                    r.Publish(new TestCls<double>{ X = 1.0 });
                    r.Publish(new TestCls<double>.TestCls2<int> { X = 1.0, Y = 1 });
                }
            });
            var run = tp.Execute(new[] { rl });
            Assert.AreEqual("TestCls`1", rl.Results.First().Name);
            Assert.AreEqual("TestCls2`1", rl.Results.Last().Name);
            bool anyNullGroup = run.Parameters.Any(x => x.Group == null);
            Assert.IsFalse(anyNullGroup);
        }

        public class CheckNullGroupStep : TestStep
        {
            public override void Run()
            {
                bool anyNull = StepRun.Parameters.Any(x => x.Group == null);
                if (anyNull)
                    UpgradeVerdict(Verdict.Fail);
                else
                    UpgradeVerdict(Verdict.Pass);
            }
        }

        [Test]
        public void NoNullResultGroups()
        {
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new CheckNullGroupStep());
            var run = plan.Execute();
            Assert.AreEqual(Verdict.Pass, run.Verdict);
            Assert.IsTrue(run.Parameters.All(x => x.Group != null));
        }

        public class AdvancedResultsStep : TestStep
        {
            public class ResultCommentAttribute : Attribute, IParameter
            {
                public string Name => "Comment";

                public string ObjectType => "string";

                public string Group => "";

                public IConvertible Value { get; }
                public ResultCommentAttribute(string comment) => Value = comment;
            }
            
            [ResultComment("ResultCommentTest")]
            [Display("XY")]
            public class AdvancedResult
            {
                [Unit("s")]
                [Display("X", "This axis denotes some time spent.")]
                public double X { get; set; }
                [Unit("W")]
                [Display("Y", "This axis denotes some power.")]
                [ResultComment("ResultCommentTest2")]
                public double Y { get; set; }

                public static AdvancedResult New(double x, double y)
                {
                    return new AdvancedResult() {X = x, Y = y};
                }
            }
            public override void Run()
            {
                var c1 = new ResultColumn("X", Enumerable.Range(0, 10).ToArray(), new UnitAttribute("s"));
                var c2 = new ResultColumn("Y", Enumerable.Range(0, 10).ToArray(), new UnitAttribute("W"));
                var results = new ResultTable("XY", new []{c1, c2}, new []{new ResultParameter("Comment", "Test Result")});
                
                Results.Publish(results);
                Results.Publish(Enumerable.Range(0, 10).Select( x => AdvancedResult.New(x,x)));
            }
        }

        [Test]
        public void ResultTableAndColumnParameters()
        {
            var step = new AdvancedResultsStep();
            var plan = new TestPlan();
            plan.Steps.Add(step);
            var rl = new ResultValidator();
            plan.Execute(new[] {rl});

            void validatedResult(ResultTable t, string comment)
            {
                Assert.AreEqual(comment, t.Parameters["Comment"]);
                Assert.AreEqual("XY", t.Name);
                Assert.AreEqual(2, t.Columns.Length);
                Assert.AreEqual(10, t.Rows);
                var x = t.Columns[0];
                var y = t.Columns[1];

                Assert.AreEqual("X", x.Name);
                Assert.AreEqual("Y", y.Name);
                Assert.AreEqual(1, x.Data.GetValue(1));
                Assert.AreEqual(9, y.Data.GetValue(9));
                Assert.AreEqual("s", x.Parameters["Unit"]);
                Assert.AreEqual("W",y.Parameters["Unit"]);
                Assert.AreEqual("s", x.Parameters["OpenTap.Unit"]);
                
            }
            
            Assert.AreEqual(2, rl.Results2.Count);
            
            //verify that the same results were generated in two different ways
            validatedResult(rl.Results[0], "Test Result");
            validatedResult(rl.Results[1], "ResultCommentTest");
        }

        [Test]
        public void ResultOptimizerTest()
        {
            ResultColumn createColumn<T>(string name)
            {
                return new ResultColumn("x", new T[2]);
            }

            {
                var rc1x = createColumn<int>("X");
                var rc1y = createColumn<int>("Y");
                var rt1 = new ResultTable("XY", new[] {rc1x, rc1y});

                var rc2x =  createColumn<int>("X");
                var rc2y = createColumn<int>("X");
                var rt2 = new ResultTable("XY", new[] {rc2x, rc2y});
                Assert.IsTrue(ResultTableOptimizer.CanMerge(rt1, rt2));
                var merged = ResultTableOptimizer.MergeTables(new []{rt1, rt2});
                Assert.AreEqual(4, merged.Columns[0].Data.Length);
            }
            {
                var rc1x = createColumn<int>("X");
                var rc1y = createColumn<int>("Y");
                var rt1 = new ResultTable("XY", new[] {rc1x, rc1y});

                var rc2x =  createColumn<int>("X");
                var rc2y = createColumn<int>("X");
                rc2y = rc2y.AddParameters(new ResultParameter("Unit", "X"));
                var rt2 = new ResultTable("XY", new[] {rc2x, rc2y});
                Assert.IsTrue(ResultTableOptimizer.CanMerge(rt1, rt2) == false);
            }
        }
        
        // an issue inside ResultTableOptimizer caused it to
        // think that two tables were 'mergable' even though they had different
        // column types. In this test, one is bool and the other is int.
        [Test]
        public void TestResultTableMergeBug()
        {
            var boolColumnTable = new ResultTable("X", new[] {new ResultColumn("A", new bool[1])});
            var boolColumnTable2 = new ResultTable("X", new[] {new ResultColumn("A", new bool[1])});
            var intColumnTable = new ResultTable("X", new[] {new ResultColumn("A", new int[1])});
            var intColumnTable2 = new ResultTable("X", new[] {new ResultColumn("A", new int[1])});
            Assert.IsTrue(ResultTableOptimizer.CanMerge(intColumnTable, intColumnTable2), "These columns should be mergeable.");
            Assert.IsTrue(ResultTableOptimizer.CanMerge(boolColumnTable, boolColumnTable2), "These columns should be mergeable.");
            Assert.IsFalse(ResultTableOptimizer.CanMerge(boolColumnTable, intColumnTable), "It should not be possible to merge an int column and bool column.");
            
            
        }
    }
}