//            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 OpenTap.Plugins.BasicSteps;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Tap.Shared;
using OpenTap.Engine.UnitTests.TestTestSteps;

namespace OpenTap.Engine.UnitTests
{
    [TestFixture]
    public class ReflectionHelperTest
    {

        [Test]
        public void EnumerableTest()
        {
            int[] x = new[] { 1, 2, 3, 4 };
            Assert.IsFalse(x.IsLongerThan(4));
            Assert.IsTrue(x.IsLongerThan(3));
            Assert.IsFalse(x.IsLongerThan(400000));

            Assert.AreEqual(x.IndexWhen(y => y == 3), 2);
            int sum = 0;
            x.ForEach(y => sum += y);
            Assert.AreEqual(sum, 10);
        }

        [Test]
        public void ArrayAppendTest()
        {
            int[] items = {0, 1, 2, 3, 4};
            Sequence.Append(ref items, 5, 6);
            for (int i = 0; i < 7; i++)
                Assert.AreEqual(i, items[i]);
        }

        [Test]
        [Platform(Exclude="Unix,Linux,MacOsX")]
        public void TimeoutOperationTest()
        {
            var sem = new System.Threading.Semaphore(0, 1);
            TapThread.Start(() => sem.Release());
            sem.WaitOne();
            {
                bool calledAction = false;
                var operation = TimeoutOperation.Create(TimeSpan.FromMilliseconds(1), () =>
                {
                    calledAction = true;
                    sem.Release();
                });
                sem.WaitOne();
                Assert.IsTrue(calledAction);
            }
            {
                bool calledAction = false;
                var operation = TimeoutOperation.Create(TimeSpan.FromMilliseconds(50), () => calledAction = true);
                operation.Dispose();
                Assert.IsFalse(calledAction);
            }
            {
                bool calledAction = false;
                var operation = TimeoutOperation.Create(TimeSpan.FromMilliseconds(1), () =>
                {
                    calledAction = true;
                });
                operation.Dispose();
                Assert.IsFalse(calledAction);
            }
            {
                bool calledAction = false;
                var operation = TimeoutOperation.Create(TimeSpan.FromMilliseconds(1), () => calledAction = true);
                Assert.IsFalse(calledAction);
                operation.Dispose();
            }
        }

        static int getMurMur(int i)
        {
            switch (i)
            {
                case 0: return 1036651960;
                case 1: return -108976867;
                case 2: return -888838031;
                case 3: return 1867787361;
                case 4: return 531708635;
                case 5: return -687432098;
                case 6: return 182881051;
                case 7: return 1461746781;
                case 8: return 619631658;
                case 9: return 2054570891;
                default:
                    throw new InvalidOperationException();

            }
        }

        [Test]
        public void TestMurmur3()
        {
            var rnd = new Random(100);
            byte[] buffer = new byte[100];
            

            for (int i = 0; i < 10; i++){

                rnd.NextBytes(buffer);
                var hello = MurMurHash3.Hash(buffer);
                Assert.AreEqual(getMurMur(i), hello);
            }

            var test2 = MurMurHash3.Hash("H3wlo World4!!!!");
            Assert.AreEqual(1251584510, test2);

        }

        public class Things
        {
            public Things[] Sub;
            public int Value;
        }

        [Test]
        public void FlattenHeirarchyTest()
        {
            var a = new Things() { Value = 1, Sub = new[] { new Things { Value = 2 }, new Things { Value = 4 } } };
            Assert.AreEqual(7 + 2, Utils.FlattenHeirarchy(new[] { a, a.Sub[0] }, x => x.Sub).Select(x => x.Value).Sum());
            HashSet<Things> set = new HashSet<Things>();
            Utils.FlattenHeirarchyInto(new[] { a, a.Sub[0] }, x => x.Sub, set);
            Assert.AreEqual(7, set.Sum(x => x.Value));
        }

        class BaseTest
        {
            public virtual void Test()
            {

            }
        }

        class BaseTest2 : BaseTest
        {

        }

        class BaseTest3 : BaseTest
        {
            public override void Test()
            {
                base.Test();
            }
        }


        [Test]
        public void OverriderTest()
        {
            //
            // this test demonstrates the behavior that can be used to test if a 
            // method is overridden or not.
            //
            // This behavior most work otherwise PrePlanRun/PostPlanRun optimizations wont work.
            //
            MethodInfo baseclaseMethod = typeof(BaseTest).GetMethod("Test");
            MethodInfo inheritedButNotOverridden = typeof(BaseTest2).GetMethod("Test");
            MethodInfo inheritedAndOverridden = typeof(BaseTest3).GetMethod("Test");
            Assert.AreEqual(baseclaseMethod.MethodHandle.Value, inheritedButNotOverridden.MethodHandle.Value);
            Assert.AreNotEqual(baseclaseMethod.MethodHandle.Value, inheritedAndOverridden.MethodHandle.Value);


            // delayStep does not override PrePlanRun or PostPlanRun
            var delay = new DelayStep();
            Assert.IsFalse(delay.PrePostPlanRunUsed);

            // TimingTestStep does..
            var timing = new TimingTestStep();
            Assert.IsTrue(timing.PrePostPlanRunUsed);
        }

        [Test]
        public void RemoveIfTest()
        {
            var rnd = new Random();
            var values = Enumerable.Repeat(0, 1000).Select(x => rnd.NextDouble()).ToList();
            Assert.IsTrue(values.IndexWhen(x => x < 0.5) != -1);
            values.RemoveIf(x => x < 0.5); // remove all values < 0.5.
            Assert.IsTrue(values.IndexWhen(x => x < 0.5) == -1);
        }

        [Test]
        public void TestCheckOperatingSystem()
        {
            // we can use RuntimeInformation to check that our OperatingSystem implementation works.
            if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows))
            {
                Assert.AreEqual(OperatingSystem.Windows, OperatingSystem.Current);
            }
            else if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX))
            {
                Assert.AreEqual(OperatingSystem.MacOS, OperatingSystem.Current);
            }
            else
            {
                Assert.AreEqual(OperatingSystem.Linux, OperatingSystem.Current);
            }
        }

        [Test]
        public void TestDirSearch()
        {
            var opentapdir = Path.GetDirectoryName(typeof(TestPlan).Assembly.Location);
            var opentapfile = Path.GetFileName(typeof(TestPlan).Assembly.Location);
            var files = PathUtils.IterateDirectories(opentapdir, "*.dll", SearchOption.AllDirectories).ToArray();
            var opentapdll = files.FirstOrDefault(x => Path.GetFileName(x) == opentapfile);
            Assert.IsNotNull(opentapdll);
        }

        [Test]
        public void MemorizerValidationTest()
        {
            int globalData = 1;
            var mem = new Memorizer<int, string>(i => (i * globalData).ToString())
            {
                Validator = x => x + globalData
            };
            
            Assert.AreEqual("4", mem[4]);
            globalData = 2;
            Assert.AreEqual("8", mem[4]);
            globalData = 3;
            Assert.AreEqual("12", mem[4]);
            globalData = 4;
            Assert.AreEqual("16", mem[4]);
        }

        [Flags]
        enum TestFlags
        {
            None = 0,
            Value1 = 1,
            [Display("Value 2")]
            Value2 = 2,
            [Display("Value 4")]
            Value4 = 4
            
        }

        const EngineSettings.AbortTestPlanType blankAbortType = 0;
        [TestCase(EngineSettings.AbortTestPlanType.Step_Error | EngineSettings.AbortTestPlanType.Step_Fail, "Break On Fail | Break On Error")]
        [TestCase(EngineSettings.AbortTestPlanType.Step_Error, "Break On Error")]
        [TestCase(EngineSettings.AbortTestPlanType.Step_Fail, "Break On Fail")]
        [TestCase(blankAbortType, "")]
        [TestCase(Verdict.Pass, "Pass")]
        [TestCase(Verdict.NotSet, "Not Set")]
        
        [TestCase(TestFlags.None, "None")]
        [TestCase(TestFlags.None | TestFlags.Value1, "Value1")]
        [TestCase(TestFlags.Value2 | TestFlags.Value1, "Value1 | Value 2")]
        [TestCase(TestFlags.Value2 | TestFlags.Value1 | TestFlags.Value4, "Value1 | Value 2 | Value 4")]
        public void TestEnumToString(Enum testValue, string expectedString)
        {
            var actualString = Utils.EnumToReadableString(testValue);
            Assert.AreEqual(expectedString, actualString);
        }

        [Test]
        public void TestInvalidEnumToString()
        {
            TestEnumToString((Verdict) 111, "111");
            // 1 and 2 are included in 111, so actually these flags are set.
            TestEnumToString((EngineSettings.AbortTestPlanType) 111, "Break On Fail | Break On Error | Break On Inconclusive | Break On Pass");
        }


        [TestCase(1000, "1.00 kB")]
        [TestCase(0, "0 B")]
        [TestCase(110, "110 B")]
        [TestCase(1500, "1.50 kB")]
        [TestCase(15000, "15.00 kB")]
        [TestCase(150000, "150.00 kB")]
        [TestCase(1500000, "1.50 MB")]
        [TestCase(1000000, "1.00 MB")]
        [TestCase(15500000, "15.50 MB")]
        [TestCase(155550000, "155.55 MB")]
        [TestCase(1550000000, "1.55 GB")]
        [TestCase(2000000000, "2.00 GB")]
        [TestCase(20500000000, "20.50 GB")]
        public void TestBytesToReadable(long number, string expected)
        {
            var str = Utils.BytesToReadable(number);
            Assert.AreEqual(expected, str);
        }
        
        [Test]
        public void TrySelectUnwrapTest()
        {
            var x = new int[] { 1, 0, 3, 0 };
            int exceptionsCaught = 0;
            var inv1 = x.TrySelect(x => 1 / x, (e, x) => exceptionsCaught++).ToArray();
            var inv2 = x.TrySelect(x => 1 / x, e => exceptionsCaught++).ToArray();
            Assert.IsTrue(inv1.SequenceEqual(new[] { 1, 0 }));
            Assert.IsTrue(inv1.SequenceEqual(inv2));
            Assert.AreEqual(4, exceptionsCaught);
        }

        [Test]
        public void TestTimeFromSeconds()
        {
            Assert.AreEqual(TimeSpan.Zero, Time.FromSeconds(0));
            Assert.AreEqual(TimeSpan.MaxValue, Time.FromSeconds(double.PositiveInfinity));
            Assert.Throws<ArithmeticException>(() => Time.FromSeconds(double.NaN));
            Assert.AreEqual(TimeSpan.MaxValue, Time.FromSeconds(1000000000000000000000000000.0));
            Assert.AreEqual(TimeSpan.MinValue, Time.FromSeconds(-1000000000000000000000000000.0));
        }

        [Test]
        public void BatchingTest()
        {
            var inv = Enumerable.Range(0, 1000).Batch(32).OrderByDescending(x => x).ToArray();
            Assert.IsTrue(inv.SequenceEqual(Enumerable.Range(0, 1000).OrderByDescending(x => x)));
        }

        [Test]
        public void CompareAndExchangeTest()
        {
            object X = 1;
            object Y = 2;
            Utils.InterlockedSwap(ref X, () => 3);
            Utils.InterlockedSwap(ref Y, () => 4);
            Assert.AreEqual(3, X);
            Assert.AreEqual(4, Y);

            X = 0;
            Y = 0;
            int cnt = 5;
            int adds = 10000;
            var tasks = new Task[cnt];

            for (int i = 0; i < cnt; i++)
            {
                tasks[i] = TapThread.StartAwaitable(() =>
                {
                    for (int i = 0; i < adds; i++)
                    {
                        Utils.InterlockedSwap(ref X, () => ((int)X + 1));
                        Utils.InterlockedSwap(ref Y, () => ((int)Y + 2));
                    }
                });
            }
            for (int i = 0; i < cnt; i++)
            {
                tasks[i].Wait();
            }
            Assert.AreEqual(X, cnt * adds);
            Assert.AreEqual(Y, cnt * adds * 2);
        }

        [Test]
        public void TestRetryUtil()
        {
            int counter = 0;
            var x = Utils.Retry(() =>
            {
                if (counter < 5)
                {
                    counter += 1;
                    throw new IOException();
                }

                return counter;
            }, typeof(IOException), sleepBaseMs: 0, maxRetries: 10);
            Assert.AreEqual(x, 5);
        }
        
        [Test]
        public void TestRetryFailure()
        {
            int counter = 0;
            
            Assert.Throws<IOException>(() => Utils.Retry(() =>
            {
                if (counter < 10)
                {
                    counter += 1;
                    throw new IOException();
                }

                return counter;
            }, typeof(IOException), sleepBaseMs: 0, maxRetries: 3));
        }
    }
}