using System;
using System.Collections.Generic;

namespace Amphora.UnitTests
{
    public class IReadOnlyDynamicArrayTests : UnitTestSharp.TestFixture
    {
        public static IReadOnlyDynamicArray<int> Holding(params int[] items)
        {
            return DynamicArrayTests.Holding(items);
        }

        public class IndexerTests : UnitTestSharp.TestFixture
        {
            public void ReadsTheItems()
            {
                IReadOnlyDynamicArray<int> view = Holding(3, 1, 4);

                CheckEqual(new[] { 3, 1, 4 }, new[] { view[0], view[1], view[2] });
            }

            public void RefersToTheItemItself()
            {
                DynamicArray<int> array = DynamicArrayTests.Holding(3, 1);
                IReadOnlyDynamicArray<int> view = array;
                ref readonly int item = ref view[1];
                array[1] = 9;

                CheckEqual(9, item);
            }

            public void PastTheCount_Throws()
            {
                IReadOnlyDynamicArray<int> view = Holding(1, 2);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                _ = view[2];
            }

            public void Negative_Throws()
            {
                IReadOnlyDynamicArray<int> view = Holding(1, 2);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                _ = view[-1];
            }
        }

        public class GetEnumeratorTests : UnitTestSharp.TestFixture
        {
            public void ForEach_VisitsTheItemsInOrder()
            {
                var visited = new List<int>();
                foreach (int item in Holding(3, 1, 4))
                {
                    visited.Add(item);
                }

                CheckEqual(new[] { 3, 1, 4 }, visited);
            }

            public void Empty_VisitsNothing()
            {
                int visits = 0;
                foreach (int item in (IReadOnlyDynamicArray<int>)DynamicArray<int>.Empty)
                {
                    ++visits;
                }

                CheckEqual(0, visits);
            }

            public void ForEachByRef_RefersToTheItemsThemselves()
            {
                DynamicArray<int> array = DynamicArrayTests.Holding(3, 1);
                IReadOnlyDynamicArray<int> view = array;
                var visited = new List<int>();
                foreach (ref readonly int item in view)
                {
                    array[0] = 9;
                    visited.Add(item);
                }

                CheckEqual(new[] { 9, 1 }, visited);
            }

            public void AddingMidway_Throws()
            {
                DynamicArray<int> array = DynamicArrayTests.Holding(1, 2);

                CheckThrow(typeof(InvalidOperationException));
                foreach (int item in (IReadOnlyDynamicArray<int>)array)
                {
                    array.Add(item);
                }
            }

            public void RemovingThenAddingBackMidway_Throws()
            {
                DynamicArray<int> array = DynamicArrayTests.Holding(1, 2);

                CheckThrow(typeof(InvalidOperationException));
                foreach (int item in (IReadOnlyDynamicArray<int>)array)
                {
                    array.RemoveAt(0);
                    array.Add(item);
                }
            }

            public static readonly IReadOnlyDynamicArray<int> AllocationView = Holding(3, 1, 4);

            [UnitTestSharp.AllocationTest]
            public void ForEach_AllocatesNothing()
            {
                int sum = 0;
                foreach (int item in AllocationView)
                {
                    sum += item;
                }

                CheckNoAllocations();
                CheckEqual(8, sum);
            }
        }
    }
}