using System;
using Glass.Text;
using UnitTestSharp;

namespace Glass.UnitTests.Text
{
    public class PackedLanesTests : TestFixture
    {
        public class GetTests : TestFixture
        {
            public void LaneZero_IsTheLowestBits()
            {
                CheckEqual(0x01UL, PackedLanes.Get(0x0807060504030201UL, lane: 0, laneBits: 8));
            }

            public void TheTopLane_IsTheHighestBits()
            {
                CheckEqual(0x08UL, PackedLanes.Get(0x0807060504030201UL, lane: 7, laneBits: 8));
            }

            public void ALaneInTheMiddle_IsOnlyItsOwnBits()
            {
                CheckEqual(0x04UL, PackedLanes.Get(0x0807060504030201UL, lane: 3, laneBits: 8));
            }

            public void NibbleLanes_EachHoldOneHexDigit()
            {
                const ulong word = 0xFEDCBA9876543210UL;

                CheckEqual(0x0UL, PackedLanes.Get(word, lane: 0, laneBits: 4));
                CheckEqual(0x5UL, PackedLanes.Get(word, lane: 5, laneBits: 4));
                CheckEqual(0xFUL, PackedLanes.Get(word, lane: 15, laneBits: 4));
            }

            public void OneBitLanes_AreSingleBits()
            {
                CheckEqual(1UL, PackedLanes.Get(0x8000000000000000UL, lane: 63, laneBits: 1));
                CheckEqual(0UL, PackedLanes.Get(0x8000000000000000UL, lane: 62, laneBits: 1));
            }

            public void ALaneAsWideAsTheWord_IsTheWholeWord()
            {
                CheckEqual(ulong.MaxValue, PackedLanes.Get(ulong.MaxValue, lane: 0, laneBits: 64));
            }

            public void LanesThatDontDivideTheWord_LeaveTheTopBitsUnused()
            {
                CheckEqual(0x1FUL, PackedLanes.Get(0x0F80000000000000UL, lane: 11, laneBits: 5));
            }

            public void ALaneThatWouldRunPastTheWord_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Get(0, lane: 12, laneBits: 5);
            }

            public void ALanePastTheLast_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Get(0, lane: 8, laneBits: 8);
            }

            public void ANegativeLane_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Get(0, lane: -1, laneBits: 8);
            }

            public void ALaneWidthOfZero_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Get(0, lane: 0, laneBits: 0);
            }

            public void ALaneWidthPastTheWord_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Get(0, lane: 0, laneBits: 65);
            }
        }

        public class PutTests : TestFixture
        {
            public void IntoAnEmptyWord_SetsOnlyThatLane()
            {
                CheckEqual(0x0000000000AB0000UL, PackedLanes.Put(0, lane: 2, laneBits: 8, value: 0xAB));
            }

            public void OtherLanes_AreKept()
            {
                CheckEqual(0x0807060504FF0201UL,
                    PackedLanes.Put(0x0807060504030201UL, lane: 2, laneBits: 8, value: 0xFF));
            }

            public void ALaneAlreadySet_IsReplacedNotMerged()
            {
                CheckEqual(0xF0UL, PackedLanes.Put(0x0FUL, lane: 0, laneBits: 8, value: 0xF0));
            }

            public void TheTopLane_ReachesTheHighestBits()
            {
                CheckEqual(0x8000000000000000UL, PackedLanes.Put(0, lane: 63, laneBits: 1, value: 1));
            }

            public void TheLargestValueThatFits_IsAccepted()
            {
                CheckEqual(0x0FUL << 12, PackedLanes.Put(0, lane: 3, laneBits: 4, value: 0xF));
            }

            public void OneMoreThanFits_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Put(0, lane: 0, laneBits: 4, value: 16);
            }

            public void ALaneAsWideAsTheWord_TakesAnyValue()
            {
                CheckEqual(ulong.MaxValue, PackedLanes.Put(0x1234, lane: 0, laneBits: 64, value: ulong.MaxValue));
            }

            public void ValuesPutInEveryLane_ComeBackFromGet()
            {
                ulong word = 0;
                for (int lane = 0; lane < 16; ++lane)
                {
                    word = PackedLanes.Put(word, lane, laneBits: 4, value: (ulong)(15 - lane));
                }

                CheckEqual(0x0123456789ABCDEFUL, word);
                for (int lane = 0; lane < 16; ++lane)
                {
                    CheckEqual((ulong)(15 - lane), PackedLanes.Get(word, lane, laneBits: 4));
                }
            }

            public void ALanePastTheLast_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Put(0, lane: 16, laneBits: 4, value: 1);
            }

            public void ANegativeLane_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Put(0, lane: -1, laneBits: 4, value: 1);
            }

            public void ALaneWidthOutsideOneToSixtyFour_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                PackedLanes.Put(0, lane: 0, laneBits: 0, value: 0);
            }
        }
    }
}