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

namespace Amphora.UnitTests
{
    public class BinaryDecisionDiagramBuilderTests : TestFixture
    {
        public const int Never = BinaryDecisionDiagramBuilder.NeverPosition;
        public const int Always = BinaryDecisionDiagramBuilder.AlwaysPosition;

        public class CountTests : TestFixture
        {
            public void NewBuilder_HasJustTheTwoOutcomes()
            {
                CheckEqual(2, new BinaryDecisionDiagramBuilder().Count);
            }

            public void EachNewNode_AddsOne()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                builder.Make(0, Never, Always);
                builder.Make(1, Never, Always);

                CheckEqual(4, builder.Count);
            }

            public void ReusedNode_AddsNothing()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                builder.Make(0, Never, Always);
                builder.Make(0, Never, Always);

                CheckEqual(3, builder.Count);
            }
        }

        public class VariableAtTests : TestFixture
        {
            public void Outcomes_ReportTheReservedVariable()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckEqual(BinaryDecisionDiagramBuilder.ReservedVariable, builder.VariableAt(Never));
                CheckEqual(BinaryDecisionDiagramBuilder.ReservedVariable, builder.VariableAt(Always));
            }

            public void MadeNode_ReportsItsVariable()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int position = builder.Make(7, Never, Always);

                CheckEqual(7, builder.VariableAt(position));
            }

            public void PositionBeyondTheEnd_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.VariableAt(2);
            }

            public void NegativePosition_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.VariableAt(-1);
            }
        }

        public class IfFalseAtTests : TestFixture
        {
            public void Outcomes_ReportNever()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckEqual(Never, builder.IfFalseAt(Never));
                CheckEqual(Never, builder.IfFalseAt(Always));
            }

            public void MadeNode_ReportsWhereItGoesWhenFalse()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int later = builder.Make(5, Never, Always);
                int position = builder.Make(1, later, Always);

                CheckEqual(later, builder.IfFalseAt(position));
            }

            public void PositionBeyondTheEnd_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.IfFalseAt(2);
            }

            public void NegativePosition_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.IfFalseAt(-1);
            }
        }

        public class IfTrueAtTests : TestFixture
        {
            public void Outcomes_ReportNever()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckEqual(Never, builder.IfTrueAt(Never));
                CheckEqual(Never, builder.IfTrueAt(Always));
            }

            public void MadeNode_ReportsWhereItGoesWhenTrue()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int later = builder.Make(5, Never, Always);
                int position = builder.Make(1, Never, later);

                CheckEqual(later, builder.IfTrueAt(position));
            }

            public void PositionBeyondTheEnd_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.IfTrueAt(2);
            }

            public void NegativePosition_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.IfTrueAt(-1);
            }
        }

        public class MakeTests : TestFixture
        {
            public void NewNodes_TakeConsecutivePositionsAfterTheOutcomes()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckEqual(2, builder.Make(0, Never, Always));
                CheckEqual(3, builder.Make(1, Never, Always));
            }

            public void EqualNodeAgain_ReturnsTheSamePosition()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int first = builder.Make(0, Never, Always);

                CheckEqual(first, builder.Make(0, Never, Always));
            }

            public void NodesDifferingInAnyPart_AreDifferentNodes()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int later = builder.Make(5, Never, Always);

                int[] positions =
                {
                    builder.Make(0, Never, Always),
                    builder.Make(1, Never, Always),
                    builder.Make(0, Always, Never),
                    builder.Make(0, later, Always),
                    builder.Make(0, Never, later),
                };

                CheckEqual(5, new HashSet<int>(positions).Count);
            }

            public void SameDestinationEitherWay_IsThatDestination()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int later = builder.Make(5, Never, Always);
                int before = builder.Count;

                CheckEqual(Always, builder.Make(0, Always, Always));
                CheckEqual(later, builder.Make(0, later, later));
                CheckEqual(before, builder.Count);
            }

            public void ReservedVariable_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.Make(BinaryDecisionDiagramBuilder.ReservedVariable, Never, Always);
            }

            public void IfFalseBeyondTheEnd_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.Make(0, 2, Always);
            }

            public void IfTrueBeyondTheEnd_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.Make(0, Never, 2);
            }

            public void NegativeDestination_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                builder.Make(0, -1, Always);
            }

            public void IfFalseAskingAboutTheSameVariable_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int same = builder.Make(3, Never, Always);

                CheckThrow(typeof(ArgumentException));
                builder.Make(3, same, Always);
            }

            public void IfTrueAskingAboutTheSameVariable_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int same = builder.Make(3, Never, Always);

                CheckThrow(typeof(ArgumentException));
                builder.Make(3, Never, same);
            }

            public void IfFalseAskingAboutAnEarlierVariable_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int earlier = builder.Make(1, Never, Always);

                CheckThrow(typeof(ArgumentException));
                builder.Make(3, earlier, Always);
            }

            public void IfTrueAskingAboutAnEarlierVariable_Throws()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int earlier = builder.Make(1, Never, Always);

                CheckThrow(typeof(ArgumentException));
                builder.Make(3, Never, earlier);
            }

            public void OrderIsCheckedBeforeSameDestinationsCollapse()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int earlier = builder.Make(1, Never, Always);

                CheckThrow(typeof(ArgumentException));
                builder.Make(3, earlier, earlier);
            }

            public void NodeAskingAboutALaterVariable_IsAccepted()
            {
                var builder = new BinaryDecisionDiagramBuilder();
                int later = builder.Make(9, Never, Always);

                CheckEqual(3, builder.Make(2, later, Always));
            }
        }
    }
}