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

namespace Glass.UnitTests
{
    public class ControlTests : TestFixture
    {
        public class MouseDownTests : TestFixture
        {
            public void EmptyControlDoesNothing()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = Vector.Zero,
                    Buttons = MouseButtonFlags.None,
                };
                bool locked = control.MouseDown(mouseState, MouseButtonFlags.Left);
                CheckFalse(locked);
            }

            public void CallsCallbackWithAppropriateArguments()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Middle,
                };
                bool called = false;
                control.OnMouseDown = (in MouseState state, MouseButtonFlags button) =>
                {
                    called = true;
                    var expectedState = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Middle,
                    };
                    CheckEqual(expectedState, state);
                    CheckEqual(MouseButtonFlags.Left, button);
                };
                bool locked = control.MouseDown(mouseState, MouseButtonFlags.Left);
                Check(called);
                Check(locked);
            }
        }

        public class MouseUpTests : TestFixture
        {
            public void EmptyControlDoesNothing()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = Vector.Zero,
                    Buttons = MouseButtonFlags.None,
                };
                bool locked = control.MouseUp(mouseState, MouseButtonFlags.Left);
                CheckFalse(locked);
            }

            public void CallsCallbackWithAppropriateArguments()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Middle,
                };
                bool called = false;
                control.OnMouseUp = (in MouseState state, MouseButtonFlags button) =>
                {
                    called = true;
                    var expectedState = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Middle,
                    };
                    CheckEqual(expectedState, state);
                    CheckEqual(MouseButtonFlags.Left, button);
                };
                bool locked = control.MouseUp(mouseState, MouseButtonFlags.Left);
                Check(called);
                Check(locked);
            }
        }

        public class MouseMoveTests : TestFixture
        {
            public void EmptyControlDoesNothing()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = Vector.Zero,
                    Buttons = MouseButtonFlags.None,
                };
                bool locked = control.MouseMove(mouseState);
                CheckFalse(locked);
            }

            public void CallsCallbackWithAppropriateArguments()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Middle,
                };
                bool called = false;
                control.OnMouseMove = (in MouseState state) =>
                {
                    called = true;
                    var expectedState = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Middle,
                    };
                    CheckEqual(expectedState, state);
                };
                bool locked = control.MouseMove(mouseState);
                Check(called);
                Check(locked);
            }
        }

        public class MouseMoveStartTests : TestFixture
        {
            public void EmptyControlDoesNothing()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = Vector.Zero,
                    Buttons = MouseButtonFlags.None,
                };
                bool locked = control.MouseMoveStart(mouseState);
                CheckFalse(locked);
            }

            public void CallsCallbackWithAppropriateArguments()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Middle,
                };
                bool called = false;
                control.OnMouseMoveStart = (in MouseState state) =>
                {
                    called = true;
                    var expectedState = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Middle,
                    };
                    CheckEqual(expectedState, state);
                };
                bool locked = control.MouseMoveStart(mouseState);
                Check(called);
                Check(locked);
            }
        }

        public class MouseMoveEndTests : TestFixture
        {
            public void EmptyControlDoesNothing()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = Vector.Zero,
                    Buttons = MouseButtonFlags.None,
                };
                bool locked = control.MouseMoveEnd(mouseState);
                CheckFalse(locked);
            }

            public void CallsCallbackWithAppropriateArguments()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Middle,
                };
                bool called = false;
                control.OnMouseMoveEnd = (in MouseState state) =>
                {
                    called = true;
                    var expectedState = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Middle,
                    };
                    CheckEqual(expectedState, state);
                };
                bool locked = control.MouseMoveEnd(mouseState);
                Check(called);
                Check(locked);
            }
        }

        public class ClickTests : TestFixture
        {
            public void EmptyControlDoesNothing()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = Vector.Zero,
                    Buttons = MouseButtonFlags.None,
                };
                control.Click(mouseState, MouseButtonFlags.None);
            }

            public void CallsCallbackWithAppropriateArguments()
            {
                var control = new Control();
                var mouseState = new MouseState
                {
                    Position = new Vector(3, 4),
                    Buttons = MouseButtonFlags.Middle,
                };
                bool called = false;
                control.OnClick = (in MouseState state, MouseButtonFlags button) =>
                {
                    called = true;
                    var expectedState = new MouseState
                    {
                        Position = new Vector(3, 4),
                        Buttons = MouseButtonFlags.Middle,
                    };
                    CheckEqual(expectedState, state);
                    CheckEqual(MouseButtonFlags.Left, button);
                };
                control.Click(mouseState, MouseButtonFlags.Left);
                Check(called);
            }
        }
    }
}