using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using UnitTestSharp;
using Azimuth;

namespace Glass.UnitTests
{
    public class ButtonTests : TestFixture
    {
        public class MaterialTests : TestFixture
        {
            public class TestMaterial : Material
            {
                public string debugName;

                public TestMaterial([CallerMemberName] string debugName = null)
                {
                    this.debugName = debugName;
                }

                public override string ToString()
                {
                    return debugName ?? base.ToString();
                }
            }

            static TestMaterial Normal = new TestMaterial();
            static TestMaterial Hover = new TestMaterial();
            static TestMaterial Pressed = new TestMaterial();
            static TestMaterial HoverAndPressed = new TestMaterial();

            Button button;

            public override void TestSetup()
            {
                button = new Button
                {
                    NominalMaterial = Normal,
                    HoverMaterial = Hover,
                    PressedMaterial = Pressed,
                    HoverPressedMaterial = HoverAndPressed,
                };
            }

            public void ReturnsNormalMaterialByDefault()
            {
                CheckEqual(Normal, button.Material);
            }

            public void ReturnsHoverMaterialWhenHovered()
            {
                button.ButtonsDown = MouseButtonFlags.Left;
                CheckEqual(Pressed, button.Material);
            }

            public void ReturnsPressedMaterialWhenPressed()
            {
                button.HoveredOver = true;
                CheckEqual(Hover, button.Material);
            }

            public void ReturnsHoverAndPressedMaterialWhenHoveredAndPressed()
            {
                button.ButtonsDown = MouseButtonFlags.Left;
                button.HoveredOver = true;
                CheckEqual(HoverAndPressed, button.Material);
            }
        }

        public class PressedTests : TestFixture
        {
            public void NotPressedIfNoButtonsDown()
            {
                var button = new Button();
                button.ButtonsDown = MouseButtonFlags.None;
                CheckFalse(button.Pressed);
            }

            public void PressedIfButtonDown()
            {
                var button = new Button();
                button.ButtonsDown = MouseButtonFlags.Middle;
                Check(button.Pressed);
            }

            public void InvalidButtonStillCountsAsPressed()
            {
                var button = new Button();
                button.ButtonsDown = MouseButtonFlags.End;
                Check(button.Pressed);
            }
        }

        public class MouseDownTests : TestFixture
        {
            public void CallsCallbackWithCorrectArguments()
            {
                var button = new Button();
                var state = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                };
                bool called = false;
                button.OnMouseDown = (in MouseState stateIn, MouseButtonFlags buttonIn) =>
                {
                    var expected = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                    };
                    CheckEqual(expected, stateIn);
                    CheckEqual(MouseButtonFlags.Left, buttonIn);
                    called = true;
                };
                bool locked = button.MouseDown(state, MouseButtonFlags.Left);
                Check(called);
                Check(locked);
            }

            public void RecordsMouseButton()
            {
                var button = new Button();
                var state = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                };
                button.MouseDown(state, MouseButtonFlags.Left);
                CheckEqual(MouseButtonFlags.Left, button.ButtonsDown);
            }

            public void ReturnsTrueEvenWithNoAttachedCallback()
            {
                var button = new Button();
                var state = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                };
                bool locked = button.MouseDown(state, MouseButtonFlags.Left);
                Check(locked);
            }

            public void DoesNotOverwriteOldMouseButtons()
            {
                var button = new Button();
                var state = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                };
                button.ButtonsDown = MouseButtonFlags.Middle | MouseButtonFlags.Right;
                button.MouseDown(state, MouseButtonFlags.Left);                
                CheckEqual(MouseButtonFlags.Left | MouseButtonFlags.Middle | MouseButtonFlags.Right,
                    button.ButtonsDown);
            }
        }

        public class MouseUpTests : TestFixture
        {
            public void CallsCallbackWithCorrectArguments()
            {
                var button = new Button();
                var state = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                };
                bool called = false;
                button.OnMouseUp = (in MouseState stateIn, MouseButtonFlags buttonIn) =>
                {
                    var expected = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                    };
                    CheckEqual(expected, stateIn);
                    CheckEqual(MouseButtonFlags.Left, buttonIn);
                    called = true;
                };
                bool locked = button.MouseUp(state, MouseButtonFlags.Left);
                Check(called);
                Check(locked);
            }

            public void ReturnsFalseIfNoAttachedCallback()
            {
                var button = new Button();
                var state = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Right | MouseButtonFlags.Middle,
                };
                bool locked = button.MouseUp(state, MouseButtonFlags.Left);
                CheckFalse(locked);
            }

            public void UnsetsSetMouseButton()
            {
                var button = new Button();
                var state = new MouseState();
                button.ButtonsDown = MouseButtonFlags.Middle | MouseButtonFlags.Right;
                button.MouseUp(state, MouseButtonFlags.Right);                
                CheckEqual(MouseButtonFlags.Middle, button.ButtonsDown);
            }
        }

        public class MouseeMoveTests : TestFixture
        {
            public void SetsHoveredWhenInside()
            {
                var button = new Button();
                button.Bounds = Rect.FromTwoPoints(new Vector(0, 0), new Vector(100, 100));
                button.MouseMove(new MouseState());
                Check(button.HoveredOver);
            }

            public void ClearsHoveredWhenOutside()
            {
                var button = new Button();
                button.HoveredOver = true;
                button.Bounds = Rect.FromTwoPoints(new Vector(10, 10), new Vector(100, 100));
                button.MouseMove(new MouseState());
                CheckFalse(button.HoveredOver);
            }

            public void CallsCallbackWhenInside()
            {
                var button = new Button();
                bool called = false;
                button.OnMouseMove = (in MouseState stateIn) =>
                {
                    CheckEqual(Vector.Zero, stateIn.Position);
                    CheckEqual(MouseButtonFlags.Middle | MouseButtonFlags.Right, stateIn.Buttons);
                    called = true;
                };
                button.Bounds = Rect.FromTwoPoints(new Vector(0, 0), new Vector(100, 100));
                button.MouseMove(new MouseState { Buttons = MouseButtonFlags.Middle | MouseButtonFlags.Right } );
                Check(called);
            }

            public void CallsCallbackWhenOutside()
            {
                var button = new Button();
                bool called = false;
                button.OnMouseMove = (in MouseState stateIn) =>
                {
                    CheckEqual(Vector.Zero, stateIn.Position);
                    CheckEqual(MouseButtonFlags.Middle | MouseButtonFlags.Right, stateIn.Buttons);
                    called = true;
                };
                button.Bounds = Rect.FromTwoPoints(new Vector(10, 10), new Vector(100, 100));
                button.MouseMove(new MouseState { Buttons = MouseButtonFlags.Middle | MouseButtonFlags.Right } );
                Check(called);
            }

            public void ReturnsTrueWhenThereIsACallback()
            {
                var button = new Button();
                button.OnMouseMove = (in MouseState stateIn) => { };
                Check(button.MouseMove(new MouseState() ));
            }

            public void ReturnsFalseWhenThereIsNoCallback()
            {
                var button = new Button();
                CheckFalse(button.MouseMove(new MouseState() ));
            }
        }

        public class MouseMoveStartTests : TestFixture
        {
            public void SetsHoveredWhenInside()
            {
                var button = new Button();
                button.Bounds = Rect.FromTwoPoints(new Vector(0, 0), new Vector(100, 100));
                button.MouseMoveStart(new MouseState());
                Check(button.HoveredOver);
            }

            public void ClearsHoveredWhenOutside()
            {
                var button = new Button();
                button.HoveredOver = true;
                button.Bounds = Rect.FromTwoPoints(new Vector(10, 10), new Vector(100, 100));
                button.MouseMoveStart(new MouseState());
                CheckFalse(button.HoveredOver);
            }

            public void CallsCallbackWhenInside()
            {
                var button = new Button();
                bool called = false;
                button.OnMouseMoveStart = (in MouseState stateIn) =>
                {
                    CheckEqual(Vector.Zero, stateIn.Position);
                    CheckEqual(MouseButtonFlags.Middle | MouseButtonFlags.Right, stateIn.Buttons);
                    called = true;
                };
                button.Bounds = Rect.FromTwoPoints(new Vector(0, 0), new Vector(100, 100));
                button.MouseMoveStart(new MouseState { Buttons = MouseButtonFlags.Middle | MouseButtonFlags.Right } );
                Check(called);
            }

            public void CallsCallbackWhenOutside()
            {
                var button = new Button();
                bool called = false;
                button.OnMouseMoveStart = (in MouseState stateIn) =>
                {
                    CheckEqual(Vector.Zero, stateIn.Position);
                    CheckEqual(MouseButtonFlags.Middle | MouseButtonFlags.Right, stateIn.Buttons);
                    called = true;
                };
                button.Bounds = Rect.FromTwoPoints(new Vector(10, 10), new Vector(100, 100));
                button.MouseMoveStart(new MouseState { Buttons = MouseButtonFlags.Middle | MouseButtonFlags.Right } );
                Check(called);
            }

            public void ReturnsTrueWhenThereIsACallback()
            {
                var button = new Button();
                button.OnMouseMoveStart = (in MouseState stateIn) => { };
                Check(button.MouseMoveStart(new MouseState() ));
            }

            public void ReturnsFalseWhenThereIsNoCallback()
            {
                var button = new Button();
                CheckFalse(button.MouseMoveStart(new MouseState() ));
            }
        }

        public class MouseMoveEndTests : TestFixture
        {
            public void ClearsHoveredWhenInside()
            {
                var button = new Button();
                button.HoveredOver = true;
                button.Bounds = Rect.FromTwoPoints(new Vector(0, 0), new Vector(100, 100));
                button.MouseMoveEnd(new MouseState());
                CheckFalse(button.HoveredOver);
            }

            public void ClearsHoveredWhenOutside()
            {
                var button = new Button();
                button.HoveredOver = true;
                button.Bounds = Rect.FromTwoPoints(new Vector(10, 10), new Vector(100, 100));
                button.MouseMoveEnd(new MouseState());
                CheckFalse(button.HoveredOver);
            }

            public void CallsCallbackWhenInside()
            {
                var button = new Button();
                bool called = false;
                button.OnMouseMoveEnd = (in MouseState stateIn) =>
                {
                    CheckEqual(Vector.Zero, stateIn.Position);
                    CheckEqual(MouseButtonFlags.Middle | MouseButtonFlags.Right, stateIn.Buttons);
                    called = true;
                };
                button.Bounds = Rect.FromTwoPoints(new Vector(0, 0), new Vector(100, 100));
                button.MouseMoveEnd(new MouseState { Buttons = MouseButtonFlags.Middle | MouseButtonFlags.Right } );
                Check(called);
            }

            public void CallsCallbackWhenOutside()
            {
                var button = new Button();
                bool called = false;
                button.OnMouseMoveEnd = (in MouseState stateIn) =>
                {
                    CheckEqual(Vector.Zero, stateIn.Position);
                    CheckEqual(MouseButtonFlags.Middle | MouseButtonFlags.Right, stateIn.Buttons);
                    called = true;
                };
                button.Bounds = Rect.FromTwoPoints(new Vector(10, 10), new Vector(100, 100));
                button.MouseMoveEnd(new MouseState { Buttons = MouseButtonFlags.Middle | MouseButtonFlags.Right } );
                Check(called);
            }

            public void ReturnsTrueWhenThereIsACallback()
            {
                var button = new Button();
                button.OnMouseMoveEnd = (in MouseState stateIn) => { };
                Check(button.MouseMoveEnd(new MouseState() ));
            }

            public void ReturnsFalseWhenThereIsNoCallback()
            {
                var button = new Button();
                CheckFalse(button.MouseMoveEnd(new MouseState() ));
            }
        }
    }
}