// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Collections;
using System.Diagnostics;
using System.Linq;
 
namespace Microsoft.AspNetCore.Mvc.Infrastructure;
 
[DebuggerDisplay("Count = {Count}")]
[DebuggerTypeProxy(typeof(CopyOnWriteList<>.CopyOnWriteListDebugView))]
internal sealed class CopyOnWriteList<T> : IList<T>
{
    private readonly IReadOnlyList<T> _source;
    private List<T>? _copy;
 
    public CopyOnWriteList(IReadOnlyList<T> source)
    {
        _source = source;
    }
 
    private IReadOnlyList<T> Readable => _copy ?? _source;
 
    private List<T> Writable
    {
        get
        {
            if (_copy == null)
            {
                _copy = new List<T>(_source);
            }
 
            return _copy;
        }
    }
 
    public T this[int index]
    {
        get => Readable[index];
        set => Writable[index] = value;
    }
 
    public int Count => Readable.Count;
 
    public bool IsReadOnly => false;
 
    public void Add(T item)
    {
        Writable.Add(item);
    }
 
    public void Clear()
    {
        Writable.Clear();
    }
 
    public bool Contains(T item)
    {
        foreach (var obj in Readable)
        {
            if (object.Equals(obj, item))
            {
                return true;
            }
        }
 
        return false;
    }
 
    public void CopyTo(T[] array, int arrayIndex)
    {
        foreach (var item in Readable)
        {
            array[arrayIndex++] = item;
        }
    }
 
    public IEnumerator<T> GetEnumerator()
    {
        return Readable.GetEnumerator();
    }
 
    public int IndexOf(T item)
    {
        var i = 0;
        foreach (var obj in Readable)
        {
            if (object.Equals(obj, item))
            {
                return i;
            }
 
            i++;
        }
 
        return -1;
    }
 
    public void Insert(int index, T item)
    {
        Writable.Insert(index, item);
    }
 
    public bool Remove(T item)
    {
        return Writable.Remove(item);
    }
 
    public void RemoveAt(int index)
    {
        Writable.RemoveAt(index);
    }
 
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
 
    private sealed class CopyOnWriteListDebugView(CopyOnWriteList<T> collection)
    {
        private readonly CopyOnWriteList<T> _collection = collection;
 
        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
        public T[] Items => _collection.ToArray();
    }
}