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

namespace Annulus.UnitTests
{
    public class HexIndexTests : TestFixture
    {
        public class CtorTests : TestFixture
        {
            public void KeepsQAndR()
            {
                var index = new HexIndex(3, -5);

                CheckEqual(3, index.Q);
                CheckEqual(-5, index.R);
            }
        }

        public class SPropertyTests : TestFixture
        {
            public void IsMinusQMinusR()
            {
                CheckEqual(-2, new HexIndex(3, -1).S);
            }

            public void AllThreeCubeCoordinatesSumToZero()
            {
                var index = new HexIndex(-4, 7);

                CheckEqual(0, index.Q + index.R + index.S);
            }
        }

        public class NeighborTests : TestFixture
        {
            public void East_StepsQ()
            {
                CheckEqual(new HexIndex(1, 0), new HexIndex(0, 0).Neighbor(PointyHexDirection.East));
            }

            public void SouthEast_StepsR()
            {
                CheckEqual(new HexIndex(0, 1), new HexIndex(0, 0).Neighbor(PointyHexDirection.SouthEast));
            }

            public void SouthWest_StepsBackQAndForwardR()
            {
                CheckEqual(new HexIndex(-1, 1), new HexIndex(0, 0).Neighbor(PointyHexDirection.SouthWest));
            }

            public void West_StepsBackQ()
            {
                CheckEqual(new HexIndex(-1, 0), new HexIndex(0, 0).Neighbor(PointyHexDirection.West));
            }

            public void NorthWest_StepsBackR()
            {
                CheckEqual(new HexIndex(0, -1), new HexIndex(0, 0).Neighbor(PointyHexDirection.NorthWest));
            }

            public void NorthEast_StepsForwardQAndBackR()
            {
                CheckEqual(new HexIndex(1, -1), new HexIndex(0, 0).Neighbor(PointyHexDirection.NorthEast));
            }

            public void AddsTheStepToAnArbitraryHex()
            {
                CheckEqual(new HexIndex(5, -3), new HexIndex(4, -3).Neighbor(PointyHexDirection.SouthEast).Neighbor(
                    PointyHexDirection.East).Neighbor(PointyHexDirection.NorthWest));
            }

            public void WalkingThereAndBackReturnsHome()
            {
                var home = new HexIndex(2, -7);

                for (var direction = PointyHexDirection.East; direction <= PointyHexDirection.NorthEast; ++direction)
                {
                    CheckEqual(home, home.Neighbor(direction).Neighbor(direction.Opposite()));
                }
            }

            public void NotAHexDirection_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new HexIndex(0, 0).Neighbor((PointyHexDirection)6);
            }
        }

        public class FlatNeighborTests : TestFixture
        {
            public void SouthEast_StepsQ()
            {
                CheckEqual(new HexIndex(1, 0), new HexIndex(0, 0).Neighbor(FlatHexDirection.SouthEast));
            }

            public void South_StepsR()
            {
                CheckEqual(new HexIndex(0, 1), new HexIndex(0, 0).Neighbor(FlatHexDirection.South));
            }

            public void SouthWest_StepsBackQAndForwardR()
            {
                CheckEqual(new HexIndex(-1, 1), new HexIndex(0, 0).Neighbor(FlatHexDirection.SouthWest));
            }

            public void NorthWest_StepsBackQ()
            {
                CheckEqual(new HexIndex(-1, 0), new HexIndex(0, 0).Neighbor(FlatHexDirection.NorthWest));
            }

            public void North_StepsBackR()
            {
                CheckEqual(new HexIndex(0, -1), new HexIndex(0, 0).Neighbor(FlatHexDirection.North));
            }

            public void NorthEast_StepsForwardQAndBackR()
            {
                CheckEqual(new HexIndex(1, -1), new HexIndex(0, 0).Neighbor(FlatHexDirection.NorthEast));
            }

            public void CastingToThePointyDirection_GivesTheSameNeighbor()
            {
                var home = new HexIndex(-3, 2);

                for (var direction = FlatHexDirection.SouthEast; direction <= FlatHexDirection.NorthEast; ++direction)
                {
                    CheckEqual(home.Neighbor(direction), home.Neighbor((PointyHexDirection)direction));
                }
            }

            public void WalkingThereAndBackReturnsHome()
            {
                var home = new HexIndex(2, -7);

                for (var direction = FlatHexDirection.SouthEast; direction <= FlatHexDirection.NorthEast; ++direction)
                {
                    CheckEqual(home, home.Neighbor(direction).Neighbor(direction.Opposite()));
                }
            }

            public void NotAHexDirection_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new HexIndex(0, 0).Neighbor((FlatHexDirection)6);
            }
        }

        public class DistanceToTests : TestFixture
        {
            public void ToItselfIsZero()
            {
                CheckEqual(0, new HexIndex(3, -2).DistanceTo(new HexIndex(3, -2)));
            }

            public void ToANeighborIsOne()
            {
                var origin = new HexIndex(0, 0);

                for (var direction = PointyHexDirection.East; direction <= PointyHexDirection.NorthEast; ++direction)
                {
                    CheckEqual(1, origin.DistanceTo(origin.Neighbor(direction)));
                }
            }

            public void AlongOneAxisCountsTheSteps()
            {
                CheckEqual(4, new HexIndex(0, 0).DistanceTo(new HexIndex(4, 0)));
            }

            public void AcrossTwoAxesTheDiagonalIsShorterThanTheSum()
            {
                CheckEqual(3, new HexIndex(0, 0).DistanceTo(new HexIndex(2, 1)));
                CheckEqual(2, new HexIndex(0, 0).DistanceTo(new HexIndex(2, -1)));
            }

            public void IsSymmetric()
            {
                var first = new HexIndex(-3, 5);
                var second = new HexIndex(4, -2);

                CheckEqual(first.DistanceTo(second), second.DistanceTo(first));
            }
        }

        public class RoundTests : TestFixture
        {
            public void WholeCoordinates_AreKept()
            {
                CheckEqual(new HexIndex(2, -3), HexIndex.Round(2.0, -3.0));
            }

            public void WhenTheRoundedCubeCoordinatesDontSumToZero_FixesRWhenItRoundedFurthest()
            {
                CheckEqual(new HexIndex(1, 0), HexIndex.Round(0.6, 0.6));
            }

            public void WhenTheRoundedCubeCoordinatesDontSumToZero_FixesQWhenItRoundedFurthest()
            {
                CheckEqual(new HexIndex(0, 0), HexIndex.Round(0.6, -0.3));
            }

            public void WhenOnlyTheImpliedCoordinateRoundedFurthest_KeepsQAndR()
            {
                CheckEqual(new HexIndex(0, 0), HexIndex.Round(0.3, 0.3));
            }
        }

        public class LineToTests : TestFixture
        {
            public void RunsFromThisHexToTheOther()
            {
                var start = new HexIndex(1, 2);
                var end = new HexIndex(4, -1);
                HexLine line = start.LineTo(end);

                CheckEqual(start, line.Start);
                CheckEqual(end, line.End);
            }
        }

        public class EqualityTests : TestFixture
        {
            public void SameQAndR_AreEqual()
            {
                CheckTrue(new HexIndex(1, 2) == new HexIndex(1, 2));
                CheckFalse(new HexIndex(1, 2) != new HexIndex(1, 2));
                CheckTrue(new HexIndex(1, 2).Equals(new HexIndex(1, 2)));
                CheckTrue(new HexIndex(1, 2).Equals((object)new HexIndex(1, 2)));
            }

            public void DifferentQ_AreNotEqual()
            {
                CheckFalse(new HexIndex(1, 2) == new HexIndex(0, 2));
                CheckTrue(new HexIndex(1, 2) != new HexIndex(0, 2));
            }

            public void DifferentR_AreNotEqual()
            {
                CheckFalse(new HexIndex(1, 2) == new HexIndex(1, 3));
                CheckTrue(new HexIndex(1, 2) != new HexIndex(1, 3));
            }

            public void SwappedQAndR_AreNotEqual()
            {
                CheckFalse(new HexIndex(1, 2).Equals(new HexIndex(2, 1)));
            }

            public void SomethingElse_IsNotEqual()
            {
                CheckFalse(new HexIndex(1, 2).Equals("(1, 2)"));
                CheckFalse(new HexIndex(1, 2).Equals(null));
            }

            public void EqualIndices_HashTheSame()
            {
                CheckEqual(new HexIndex(-7, 9).GetHashCode(), new HexIndex(-7, 9).GetHashCode());
            }

            public void NearbyIndices_MostlyHashApart()
            {
                var hashes = new HashSet<int>();

                for (int q = -10; q <= 10; ++q)
                {
                    for (int r = -10; r <= 10; ++r)
                    {
                        hashes.Add(new HexIndex(q, r).GetHashCode());
                    }
                }

                CheckEqual(441, hashes.Count);
            }

            public void WorksAsADictionaryKey()
            {
                var dictionary = new Dictionary<HexIndex, string>
                {
                    [new HexIndex(1, -1)] = "found",
                };

                CheckEqual("found", dictionary[new HexIndex(1, -1)]);
                CheckFalse(dictionary.ContainsKey(new HexIndex(-1, 1)));
            }
        }

        public class ToStringTests : TestFixture
        {
            public void ShowsQThenR()
            {
                CheckEqual("(3, -5)", new HexIndex(3, -5).ToString());
            }
        }
    }
}