namespace FlexArray.Test;

public class FlexArrayIntTests
{
    // Constructor tests
    [Fact]
    public void Construction_NoSize()
    {
        var array = new FlexArrayInt();

        array.Should().NotBeNull();
        array.Count.Should().Be(0, "no items added yet");
        array.Capacity.Should().Be(FlexArrayInt.DefaultStartSize, "default capacity");
    }
    
    [Theory]
    [InlineData(0)]
    [InlineData(4)]
    [InlineData(20)]
    [InlineData(100_000)]
    public void Construction_WithSize(int size)
    {
        var array = new FlexArrayInt(size);

        array.Should().NotBeNull();
        array.Count.Should().Be(0, "no items added yet");
        array.Capacity.Should().Be(size, "initial capacity set to specified size");
    }

    [Fact]
    public void Construction_WithInvalidSize()
    {
        var array = new FlexArrayInt(-5);

        array.Should().NotBeNull();
        array.Count.Should().Be(0);
        array.Capacity.Should().Be(0, "negative size provided => set to 0");
    }
    
    // Add tests
    [Fact]
    public void AddItem_Single()
    {
        var array = new FlexArrayInt();

        array.Add(17);

        array.Count.Should().Be(1, "one item added");
        array.Capacity.Should().Be(FlexArrayInt.DefaultStartSize, "capacity unchanged");
    }
    
    [Fact]
    public void AddItem_Multiple_NoGrowth()
    {
        var array = new FlexArrayInt();

        array.Add(17);
        array.Add(20);
        array.Add(-100);

        array.Count.Should().Be(3, "three items added");
        array.Capacity.Should().Be(FlexArrayInt.DefaultStartSize, "no growth required yet");
    }

    [Fact]
    public void AddItem_Multiple_Growth()
    {
        var array = new FlexArrayInt();

        void AddItems(int count) 
        {
            for (var i = 0; i < count; i++)
            {
                array.Add(i + 1);
            }
        }

        AddItems(FlexArrayInt.DefaultStartSize);
        array.Capacity.Should().Be(FlexArrayInt.DefaultStartSize);

        AddItems(2);
        array.Capacity.Should().BeGreaterThan(FlexArrayInt.DefaultStartSize, "capacity exceeded, had to grow"); 
        array.Count.Should().Be(FlexArrayInt.DefaultStartSize + 2);
    }
    
    // Contains tests
    [Fact]
    public void Contains_Success()
    {
        var array = new FlexArrayInt();
        array.Add(12);
        array.Add(23);
        array.Add(-900);
        array.Add(76);

        array.Contains(23)
             .Should().BeTrue();
    }

    [Fact]
    public void Contains_Success_AfterGrowth()
    {
        var array = new FlexArrayInt();
        for (var i = 0; i <= FlexArrayInt.DefaultStartSize; i++)
        {
            array.Add(i);
        }

        array.Contains(FlexArrayInt.DefaultStartSize - 1)
             .Should().BeTrue();
    }

    [Fact]
    public void Contains_Empty()
    {
        var array = new FlexArrayInt();

        array.Contains(23)
             .Should().BeFalse("collection is empty");
    }

    [Fact]
    public void Contains_NotFound()
    {
        var array = new FlexArrayInt();
        array.Add(-12);
        array.Add(23);

        array.Contains(12)
             .Should().BeFalse("not contained in list");
    }
    
    // Indexer tests
    [Fact]
    public void Indexer_Simple()
    {
        var array = new FlexArrayInt();
        array.Add(89);

        array[0].Should().Be(89);
    }

    [Fact]
    public void Indexer_Multiple()
    {
        var array = new FlexArrayInt();
        for (var i = 0; i < 100; i++)
        {
            array.Add(i+1);
        }

        array[20].Should().Be(21);
        array[88].Should().Be(89);
    }

    [Theory]
    [InlineData(-1, "negative index")]
    [InlineData(2, "index too high")]
    [InlineData(10, "index too high")]
    public void Indexer_InvalidIndex(int index, string reason)
    {
        var array = new FlexArrayInt();
        array.Add(-89);

        array[index].Should().Be(-1, reason);
    }
    
    [Fact]
    public void Iterate()
    {
        var array = new FlexArrayInt();
        for (var i = 0; i < 10; i++)
        {
            array.Add(i);
        }

        for (var i = 0; i < 10; i++)
        {
            array[i].Should().Be(i);
        }
    }
    
    // Remove tests
    [Fact]
    public void Remove_ByIndex_Simple()
    {
        var array = new FlexArrayInt();
        array.Add(40);

        array.Count.Should().Be(1);
        array.RemoveAt(0).Should().BeTrue("index exists");
        array.Count.Should().Be(0, "count has to be reduced");
    }

    [Fact]
    public void Remove_ByIndex_Shifting()
    {
        var array = new FlexArrayInt();
        array.Add(30);
        array.Add(31);
        array.Add(32);

        array.Count.Should().Be(3);
        array.RemoveAt(1).Should().BeTrue();
        array.Count.Should().Be(2);
        array[1].Should().Be(32, "items to the right have to be shifted left after removal");
        array.RemoveAt(2)
             .Should().BeFalse("not a valid index any longer, despite a value still being there");
    }

    [Fact]
    public void Remove_ByIndex_FromEnd()
    {
        var array = new FlexArrayInt();
        array.Add(30);
        array.Add(31);
        array.Add(32);

        array.Count.Should().Be(3);
        array.RemoveAt(2).Should().BeTrue();
        array.Count.Should().Be(2);
        array[1].Should().Be(31);
    }

    [Fact]
    public void Remove_ByIndex_Invalid()
    {
        var array = new FlexArrayInt();
        array.Add(30);

        array.RemoveAt(1)
             .Should().BeFalse("the array is big enough for this index, but no value has been set there");
        array.Count.Should().Be(1, "unchanged");

        array.RemoveAt(-1)
             .Should().BeFalse("negative index doesn't make any sense");
    }
    
    [Fact]
    public void Remove_Single_OneOccurrence()
    {
        var array = new FlexArrayInt();
        array.Add(1);
        array.Add(2);
        array.Add(3);

        array.Remove(2, true)
            .Should().BeTrue("element was found");
        array.Count.Should().Be(2, "element was removed");
    }

    [Fact]
    public void Remove_Single_OnlyOccurrence()
    {
        var array = new FlexArrayInt();
        array.Add(1);

        array.Remove(1, true)
            .Should().BeTrue("element was found");
        array.Count.Should().Be(0, "element was removed");
    }

    [Fact] public void Remove_Single_MultipleOccurrence()
    {
        var array = new FlexArrayInt();
        array.Add(1);
        array.Add(2);
        array.Add(2);

        array.Remove(2, true)
            .Should().BeTrue("element was found");
        array.Count.Should().Be(2, "only one element was removed");
    }

    [Fact]
    public void Remove_Single_NotFound()
    {
        var array = new FlexArrayInt();
        array.Add(1);
        array.Add(2);
        array.Add(3);

        array.Remove(4, true)
            .Should().BeFalse("element was not found");
        array.Count.Should().Be(3, "unchanged");
    }

    [Fact]
    public void Remove_Multiple_OneOccurrence()
    {
        var array = new FlexArrayInt();
        array.Add(1);
        array.Add(2);
        array.Add(3);

        array.Remove(2, false)
            .Should().BeTrue("element was found");
        array.Count.Should().Be(2, "only one element was removed");
    }

    [Fact]
    public void Remove_Multiple_MultipleOccurrence()
    {
        var array = new FlexArrayInt();
        array.Add(1);
        array.Add(2);
        array.Add(2);
        array.Add(3);
        array.Add(2);
        array.Add(4);
        array.Add(2);

        array.Remove(2, false)
            .Should().BeTrue("elements were found");
        array.Count.Should().Be(3, "four elements were removed");
    }

    [Fact]
    public void Remove_Multiple_OnlyOccurrence()
    {
        var array = new FlexArrayInt();
        array.Add(1);
        array.Add(1);
        array.Add(1);


        array.Remove(1, false)
            .Should().BeTrue("elements were found");
        array.Count.Should().Be(0, "all elements were removed");
    }

    [Fact]
    public void Remove_Multiple_NoOccurrence()
    {
        var array = new FlexArrayInt();
        array.Add(1);
        array.Add(2);
        array.Add(3);

        array.Remove(4, false)
            .Should().BeFalse("element was not found");
        array.Count.Should().Be(3, "unchanged");
    }
}