using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Tests<>).Assembly).Run(args);

public partial class Tests<T> where T : new()
{
    private T _value = new();
    private T[] _valueArr = [new()];

    private IEnumerable<T> CreateEnumerable()
    {
        for (int i = 0; i < Count; i++) yield return _value;
    }

    private IEnumerable<T> CreateArray()
    {
        var result = new T[Count];
        for (int i = 0; i < Count; i++)
        {
            result[i] = _value;
        }
        return result;
    }

    [Params(1, 5, 50)]
    public int Count { get; set; }

    [Benchmark]
    public List<T> Enumerable_ToList() => 
        CreateEnumerable()
        .ToList();

    [Benchmark]
    public List<T> IEnumerableSelectIterator_ToList() =>
        AssertType(CreateEnumerable().Select(i => i), "IEnumerableSelectIterator`2")
        .ToList();

    [Benchmark]
    public List<T> IteratorSelectIterator_ToList() =>
        AssertType(CreateEnumerable().Skip(1).Select(i => i), "IteratorSelectIterator`2")
        .ToList();

    [Benchmark]
    public List<object> OfTypeIterator_ToList() =>
        AssertType(CreateEnumerable().OfType<object>(), "OfTypeIterator`1")
        .ToList();

    [Benchmark]
    public List<T> SelectManySingleSelectorIterator_ToList() =>
        AssertType(CreateEnumerable().SelectMany(i => _valueArr), "SelectManySingleSelectorIterator`2")
        .ToList();

    [Benchmark]
    public List<T> IEnumerableSkipTakeIterator_ToLost() =>
        AssertType(CreateEnumerable().Skip(1), "IEnumerableSkipTakeIterator`1")
        .ToList();

    [Benchmark]
    public List<T> IEnumerableWhereIterator_ToList() =>
        AssertType(CreateEnumerable().Where(_ => true), "IEnumerableWhereIterator`1")
        .ToList();

    [Benchmark]
    public List<T> ArrayWhereIterator_ToList() =>
        AssertType(CreateArray().Where(_ => true), "ArrayWhereIterator`1")
        .ToList();

    [Benchmark]
    public List<T> IEnumerableWhereSelectIterator_ToList() =>
        AssertType(CreateEnumerable().Where(_ => true).Select(i => i), "IEnumerableWhereSelectIterator`2")
        .ToList();

    [Benchmark]
    public List<T> ArrayWhereSelectIterator_ToList() =>
        AssertType(CreateArray().Where(_ => true).Select(i => i), "ArrayWhereSelectIterator`2")
        .ToList();


    private static TIterator AssertType<TIterator>(TIterator value, string type)
    {
        if(value!.GetType().Name is { } actual && actual != type)
        {
            throw new InvalidOperationException($"Expected {type} got {actual}");
        }

        return value;
    }
}

[HideColumns("Error", "StdDev", "Median", "RatioSD", "Job")]
[MemoryDiagnoser(false)]
public class Int32Tests : Tests<int> { }

[HideColumns("Error", "StdDev", "Median", "RatioSD", "Job")]
[MemoryDiagnoser(false)]
public class ObjectTests : Tests<object> { }