using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Funique.Test
{
    public sealed partial class ManagerTest
    {
        /// <summary>
        /// Testing the utility functionality <br />
        /// ------------------------------------------------ <br />
        /// 測試幫助元件功能
        /// </summary>
        public sealed class UtilityTest
        {
            IToolUtility test_utility => Tool.Instance;
            const string testName1 = "testvideo_3dv_2s.mp4";
            const string testName2 = "testvideo_3dh_3m2s.mp4";
            const string testName3 = "testvideo_mono_5h3m2s.mp4";
            const string testFilterName1 = "testvideo_3dv.mp4";
            const string testFilterName2 = "testvideo_3dh.mp4";
            const string testFilterName3 = "testvideo_mono.mp4";
            const string testTime1 = "2s";
            const string testTime2 = "3m2s";
            const string testTime3 = "5h3m2s";
            Dictionary<string, PlayerInformation> infos;

            [OneTimeSetUp]
            public void Setup()
            {
                infos = new Dictionary<string, PlayerInformation>()
                {
                    { "192.168.0.1", new PlayerInformation(){ IP = "192.168.0.1", ID = 0 } },
                    { "192.168.0.2", new PlayerInformation(){ IP = "192.168.0.2", ID = 1 } },
                    { "192.168.0.3", new PlayerInformation(){ IP = "192.168.0.3", ID = 2 } },
                    { "192.168.0.4", new PlayerInformation(){ IP = "192.168.0.4", ID = 3 } },
                    { "192.168.0.5", new PlayerInformation(){ IP = "192.168.0.5", ID = 4 } },
                };
            }

            [OneTimeTearDown]
            public void TearDown()
            {
                infos.Clear();
            }

            [Order(0)]
            [Test]
            public void EnumCycleTest()
            {
                int count = Enum.GetNames(typeof(CinemaState)).Length;
                int[] answer = new int[count * 2];
                for (int i = 0; i < answer.Length; i++)
                {
                    answer[i] = i % count;
                }
                int v = 0;
                EnumCycle<CinemaState> cycle = new EnumCycle<CinemaState>();
                for (int i = 0; i < answer.Length; i++)
                {
                    Assert.AreEqual(answer[i], v, "Cycle failed to match the answer");
                    v = cycle.Next(v);
                }
            }

            [Order(1)]
            [Test]
            public void CheckSameVideoNameTest()
            {
                VideoInfo[] t1 = new VideoInfo[2]
                {
                    new VideoInfo() { FilterName = "Test 1" },
                    new VideoInfo() { FilterName = "Test 2" },
                };
                Assert.IsTrue(test_utility.CheckSameVideoName(t1, "Test 1"), "List should contain filter name \"Test 1\"");
                Assert.IsFalse(test_utility.CheckSameVideoName(t1, "Test 3"), "List should not contain filter name \"Test 3\"");
            }

            [Order(2)]
            [Test]
            public void FilterNameTest()
            {
                Assert.AreEqual(testFilterName1, test_utility.FilterVideoName(testName1), "Second filter not pass");
                Assert.AreEqual(testFilterName2, test_utility.FilterVideoName(testName2), "Minutes filter not pass");
                Assert.AreEqual(testFilterName3, test_utility.FilterVideoName(testName3), "Hour filter not pass");
            }

            [Order(3)]
            [Test]
            public void FilterTimeTest()
            {
                Assert.AreEqual(2f, test_utility.FilterVideoTime(testName1), "Second filter not pass");
                Assert.AreEqual(182f, test_utility.FilterVideoTime(testName2), "Minutes filter not pass");
                Assert.AreEqual(18182f, test_utility.FilterVideoTime(testName3), "Hour filter not pass");
            }

            [Order(4)]
            [Test]
            public void TranslateTimeTest()
            {
                Assert.AreEqual(2d, test_utility.TranslateTime(testTime1), "Second filter not pass");
                Assert.AreEqual(182d, test_utility.TranslateTime(testTime2), "Minutes filter not pass");
                Assert.AreEqual(18182d, test_utility.TranslateTime(testTime3), "Hour filter not pass");
            }

            [Order(5)]
            [Test]
            public void FilterButtonName()
            {
                Assert.AreEqual(testFilterName1, test_utility.FilterVideoName(testName1), "Second filter not pass");
                Assert.AreEqual(testFilterName2, test_utility.FilterVideoName(testName2), "Minutes filter not pass");
                Assert.AreEqual(testFilterName3, test_utility.FilterVideoName(testName3), "Hour filter not pass");
            }

            [Order(6)]
            [Test]
            public void MergeTimeTest()
            {
                double t1 = 2d;
                double t2 = 182d;
                double t3 = 18182d;
                Assert.AreEqual(testName1, test_utility.MergeTime(testFilterName1, t1), "Second filter not pass");
                Assert.AreEqual(testName2, test_utility.MergeTime(testFilterName2, t2), "Minutes filter not pass");
                Assert.AreEqual(testName3, test_utility.MergeTime(testFilterName3, t3), "Hour filter not pass");
            }

            [Order(7)]
            [Test]
            public void DetectStereoModeTest()
            {
                Assert.AreEqual("3dv", test_utility.DetectStereoMode(testFilterName1), "Second filter not pass");
                Assert.AreEqual("3dh", test_utility.DetectStereoMode(testFilterName2), "Minutes filter not pass");
                Assert.AreEqual("mono", test_utility.DetectStereoMode(testFilterName3), "Hour filter not pass");
            }

            [Order(8)]
            [Test]
            public void RandomIDTest()
            {
                int e = test_utility.RandomID(infos, 10);
                Assert.LessOrEqual(e, 10, "Value must under the limit it gave");
                Assert.GreaterOrEqual(e, 0, "Value must bigger or equal than 0");
                Assert.AreNotEqual(infos.Values.ToList().FindIndex(x => x.ID == e), -1, "It select the ID that is not in the list");
            }

            [Order(9)]
            [Test]
            public void RandomIPTest()
            {
                string r = test_utility.RandomIP(infos, 10);
                Assert.AreEqual(-1, infos.Values.ToList().FindIndex(x => x.IP == r), "It generate the IP that is already exist");
            }

            [Order(10)]
            [Test]
            public void RepeatIPTest()
            {
                bool r1 = infos.Values.ToList().FindIndex(x => x.IP == "192.168.0.1") != -1;
                bool r2 = infos.Values.ToList().FindIndex(x => x.IP == "192.168.1.1") != -1;
                Assert.AreEqual(r1, test_utility.CheckRepeatIP(infos, "192.168.0.1"));
                Assert.AreEqual(r2, test_utility.CheckRepeatIP(infos, "192.168.1.1"));
            }
        }
    }
}