using System;
using System.Collections.Generic;
using UnitTestSharp;

namespace Blacklight.Core.UnitTests
{
    public class GraphicsAdapterManagerTests : TestFixture
    {
        public class FakeAdapter : IModule
        {
            public VerticalSyncMode VerticalSync { get; set; }

            public int Priority { get; set; }

            public virtual bool DrawsToScreen => true;

            public virtual bool IsSupported => true;

            public WindowHandle CreateDrawableSurfaceOnWindow(IntPtr handle)
            {
                return new NullWindowHandle();
            }

            public void Load() { }

            public void Unload() { }
        }

        public class LowAdapter : FakeAdapter
        {
            public LowAdapter()
            {
                Priority = 10;
            }
        }

        public class HighAdapter : FakeAdapter
        {
            public HighAdapter()
            {
                Priority = 20;
            }
        }

        public class TiedAdapter : FakeAdapter
        {
            public TiedAdapter()
            {
                Priority = 20;
            }
        }

        public class StandInAdapter : FakeAdapter
        {
            public StandInAdapter()
            {
                Priority = 1000;
            }

            public override bool DrawsToScreen => false;
        }

        public class UnsupportedAdapter : FakeAdapter
        {
            public UnsupportedAdapter()
            {
                Priority = 1000;
            }

            public override bool IsSupported => false;
        }

        public const string Low = "Blacklight.Core.UnitTests.LowAdapter";
        public const string High = "Blacklight.Core.UnitTests.HighAdapter";
        public const string Tied = "Blacklight.Core.UnitTests.TiedAdapter";
        public const string StandIn = "Blacklight.Core.UnitTests.StandInAdapter";
        public const string Unsupported = "Blacklight.Core.UnitTests.UnsupportedAdapter";

        public static GraphicsAdapterManager ManagerWith(params Type[] adapters)
        {
            var returnMe = new GraphicsAdapterManager();
            returnMe.AddModuleTypes(adapters);

            return returnMe;
        }

        public class DrawingModulesTests : TestFixture
        {
            public void NoAdapters_IsEmpty()
            {
                CheckEqual(0, ManagerWith().DrawingModules.Count);
            }

            public void HigherPriorityComesFirst()
            {
                var manager = ManagerWith(typeof(LowAdapter), typeof(HighAdapter));

                CheckEqual(new List<string> { High, Low }, manager.DrawingModules);
            }

            public void EqualPriorities_SortByName()
            {
                var manager = ManagerWith(typeof(TiedAdapter), typeof(HighAdapter));

                CheckEqual(new List<string> { High, Tied }, manager.DrawingModules);
            }

            public void LeavesOutAdaptersThatDoNotDraw()
            {
                var manager = ManagerWith(typeof(StandInAdapter), typeof(LowAdapter));

                CheckEqual(new List<string> { Low }, manager.DrawingModules);
            }

            public void LeavesOutUnsupportedAdapters()
            {
                var manager = ManagerWith(typeof(UnsupportedAdapter), typeof(LowAdapter));

                CheckEqual(new List<string> { Low }, manager.DrawingModules);
            }

            public void ChangingAPriority_ReordersTheList()
            {
                var manager = ManagerWith(typeof(LowAdapter), typeof(HighAdapter));

                manager.GetModule(Low).Priority = 30;

                CheckEqual(new List<string> { Low, High }, manager.DrawingModules);
            }
        }

        public class PreferredModuleFromTests : TestFixture
        {
            public void NoArguments_ReturnsNull()
            {
                CheckNull(GraphicsAdapterManager.PreferredModuleFrom(new string[0]));
            }

            public void NoSwitch_ReturnsNull()
            {
                CheckNull(GraphicsAdapterManager.PreferredModuleFrom(new[] { "--novsync", "-debug" }));
            }

            public void ReturnsTheNameAfterTheSwitch()
            {
                string name = GraphicsAdapterManager.PreferredModuleFrom(new[] { "--adapter=Some.Adapter" });

                CheckEqual("Some.Adapter", name);
            }

            public void SkipsOtherArgumentsToFindTheSwitch()
            {
                string name = GraphicsAdapterManager.PreferredModuleFrom(
                    new[] { "--novsync", "--adapter=Some.Adapter", "-debug" });

                CheckEqual("Some.Adapter", name);
            }

            public void SwitchWithNoName_ReturnsEmpty()
            {
                CheckEqual("", GraphicsAdapterManager.PreferredModuleFrom(new[] { "--adapter=" }));
            }
        }

        public class ChooseModuleTests : TestFixture
        {
            public void NoPreference_ChoosesTheBestDrawingAdapter()
            {
                var manager = ManagerWith(typeof(LowAdapter), typeof(HighAdapter), typeof(StandInAdapter));

                CheckTrue(manager.ChooseModule(preferredName: null));

                CheckEqual(manager.GetModule(High), manager.CurrentModule);
            }

            public void PreferredAdapter_BeatsAHigherPriorityOne()
            {
                var manager = ManagerWith(typeof(LowAdapter), typeof(HighAdapter));

                CheckTrue(manager.ChooseModule(Low));

                CheckEqual(manager.GetModule(Low), manager.CurrentModule);
            }

            public void PreferredAdapterThatDoesNotDraw_IsChosen()
            {
                var manager = ManagerWith(typeof(LowAdapter), typeof(StandInAdapter));

                CheckTrue(manager.ChooseModule(StandIn));

                CheckEqual(manager.GetModule(StandIn), manager.CurrentModule);
            }

            public void UnknownPreference_ChoosesTheBestDrawingAdapter()
            {
                var manager = ManagerWith(typeof(LowAdapter), typeof(HighAdapter));

                CheckTrue(manager.ChooseModule("No.Such.Adapter"));

                CheckEqual(manager.GetModule(High), manager.CurrentModule);
            }

            public void UnsupportedPreference_ChoosesTheBestDrawingAdapter()
            {
                var manager = ManagerWith(typeof(LowAdapter), typeof(UnsupportedAdapter));

                CheckTrue(manager.ChooseModule(Unsupported));

                CheckEqual(manager.GetModule(Low), manager.CurrentModule);
            }

            public void NoDrawingAdapter_ReturnsFalseAndChoosesNothing()
            {
                var manager = ManagerWith(typeof(StandInAdapter), typeof(UnsupportedAdapter));

                CheckFalse(manager.ChooseModule(preferredName: null));

                CheckNull(manager.CurrentModule);
            }
        }
    }
}