// 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.ComponentModel;
using System.Drawing;
 
namespace System.Windows.Forms;
 
public partial class ListViewItem
{
    public class ListViewSubItemCollection : IList
    {
        private readonly ListViewItem _owner;
 
        // A caching mechanism for key accessor
        // We use an index here rather than control so that we don't have lifetime
        // issues by holding on to extra references.
        private int _lastAccessedIndex = -1;
 
        public ListViewSubItemCollection(ListViewItem owner)
        {
            _owner = owner.OrThrowIfNull();
        }
 
        /// <summary>
        ///  Returns the total number of items within the list view.
        /// </summary>
        [Browsable(false)]
        public int Count => _owner.SubItemCount;
 
        object ICollection.SyncRoot => this;
 
        bool ICollection.IsSynchronized => true;
 
        bool IList.IsFixedSize => false;
 
        public bool IsReadOnly => false;
 
        /// <summary>
        ///  Returns a ListViewSubItem given it's zero based index into the ListViewSubItemCollection.
        /// </summary>
        public ListViewSubItem this[int index]
        {
            get
            {
                ArgumentOutOfRangeException.ThrowIfNegative(index);
                ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Count);
 
                return _owner._subItems[index];
            }
            set
            {
                ArgumentOutOfRangeException.ThrowIfNegative(index);
                ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Count);
 
                ListViewSubItem oldSubItem = _owner._subItems[index];
 
                _owner._subItems[index] = value.OrThrowIfNull();
                value._owner = _owner;
 
                oldSubItem._owner = null;
                oldSubItem.ReleaseUiaProvider();
 
                _owner.UpdateSubItems(index);
            }
        }
 
        object? IList.this[int index]
        {
            get => this[index];
            set
            {
                if (value is not ListViewSubItem item)
                {
                    throw new ArgumentException(SR.ListViewBadListViewSubItem, nameof(value));
                }
 
                this[index] = item;
            }
        }
 
        /// <summary>
        ///  Retrieves the child control with the specified key.
        /// </summary>
        public virtual ListViewSubItem? this[string key]
        {
            get
            {
                // We do not support null and empty string as valid keys.
                if (string.IsNullOrEmpty(key))
                {
                    return null;
                }
 
                // Search for the key in our collection
                int index = IndexOfKey(key);
                if (!IsValidIndex(index))
                {
                    return null;
                }
 
                return this[index];
            }
        }
 
        public ListViewSubItem Add(ListViewSubItem item)
        {
            ArgumentNullException.ThrowIfNull(item);
 
            EnsureAdditionalCapacity(1);
            item._owner = _owner;
            _owner._subItems.Add(item);
            _owner.UpdateSubItems(_owner.SubItemCount++);
            return item;
        }
 
        public ListViewSubItem Add(string? text)
        {
            ListViewSubItem item = new(_owner, text);
            Add(item);
            return item;
        }
 
        public ListViewSubItem Add(string? text, Color foreColor, Color backColor, Font font)
        {
            ListViewSubItem item = new(_owner, text, foreColor, backColor, font);
            Add(item);
            return item;
        }
 
        public void AddRange(params ListViewSubItem[] items)
        {
            ArgumentNullException.ThrowIfNull(items);
 
            EnsureAdditionalCapacity(items.Length);
            foreach (ListViewSubItem item in items)
            {
                if (item is not null)
                {
                    item._owner = _owner;
                    _owner._subItems.Add(item);
                    _owner.SubItemCount++;
                }
            }
 
            _owner.UpdateSubItems(-1);
        }
 
        public void AddRange(params string[] items)
        {
            ArgumentNullException.ThrowIfNull(items);
 
            EnsureAdditionalCapacity(items.Length);
            foreach (string item in items)
            {
                if (item is not null)
                {
                    _owner._subItems.Add(new ListViewSubItem(_owner, item));
                    _owner.SubItemCount++;
                }
            }
 
            _owner.UpdateSubItems(-1);
        }
 
        public void AddRange(string[] items, Color foreColor, Color backColor, Font font)
        {
            ArgumentNullException.ThrowIfNull(items);
 
            EnsureAdditionalCapacity(items.Length);
            foreach (string item in items)
            {
                if (item is not null)
                {
                    _owner._subItems.Add(new ListViewSubItem(_owner, item, foreColor, backColor, font));
                    _owner.SubItemCount++;
                }
            }
 
            _owner.UpdateSubItems(-1);
        }
 
        int IList.Add(object? item)
        {
            if (item is not ListViewSubItem itemValue)
            {
                throw new ArgumentException(SR.ListViewSubItemCollectionInvalidArgument, nameof(item));
            }
 
            return IndexOf(Add(itemValue));
        }
 
        public void Clear()
        {
            int oldCount = _owner.SubItemCount;
            if (oldCount > 0)
            {
                for (int i = 0; i < oldCount; i++)
                {
                    _owner.SubItems[i]._owner = null;
                    _owner._subItems[i].ReleaseUiaProvider();
                }
 
                _owner._subItems.Clear();
                _owner.SubItemCount = 0;
                _owner.UpdateSubItems(-1, oldCount);
            }
        }
 
        public bool Contains(ListViewSubItem? subItem) => IndexOf(subItem) != -1;
 
        bool IList.Contains(object? item)
        {
            if (item is not ListViewSubItem itemValue)
            {
                return false;
            }
 
            return Contains(itemValue);
        }
 
        /// <summary>
        ///  Returns true if the collection contains an item with the specified key, false otherwise.
        /// </summary>
        public virtual bool ContainsKey(string? key) => IsValidIndex(IndexOfKey(key));
 
        /// <summary>
        ///  Checks that the sub items list size does not exceed the MaxSubItems value
        ///  and ensures that it has the given capacity.
        /// </summary>
        private void EnsureAdditionalCapacity(int additionalCapacity)
        {
            if (_owner.SubItemCount >= MaxSubItems)
            {
                throw new InvalidOperationException(SR.ErrorCollectionFull);
            }
 
            _owner._subItems.EnsureCapacity(_owner._subItems.Count + additionalCapacity);
        }
 
        public int IndexOf(ListViewSubItem? subItem)
        {
            for (int index = 0; index < Count; ++index)
            {
                if (_owner._subItems[index] == subItem)
                {
                    return index;
                }
            }
 
            return -1;
        }
 
        int IList.IndexOf(object? subItem)
        {
            if (subItem is not ListViewSubItem subItemValue)
            {
                return -1;
            }
 
            return IndexOf(subItemValue);
        }
 
        /// <summary>
        ///  The zero-based index of the first occurrence of value within the entire CollectionBase, if found; otherwise, -1.
        /// </summary>
        public virtual int IndexOfKey(string? key)
        {
            if (string.IsNullOrEmpty(key))
            {
                return -1;
            }
 
            if (IsValidIndex(_lastAccessedIndex))
            {
                if (WindowsFormsUtils.SafeCompareStrings(this[_lastAccessedIndex].Name, key, ignoreCase: true))
                {
                    return _lastAccessedIndex;
                }
            }
 
            for (int i = 0; i < Count; i++)
            {
                if (WindowsFormsUtils.SafeCompareStrings(this[i].Name, key, ignoreCase: true))
                {
                    _lastAccessedIndex = i;
                    return i;
                }
            }
 
            _lastAccessedIndex = -1;
            return -1;
        }
 
        /// <summary>
        ///  Determines if the index is valid for the collection.
        /// </summary>
        private bool IsValidIndex(int index) => ((index >= 0) && (index < Count));
 
        public void Insert(int index, ListViewSubItem item)
        {
            ArgumentOutOfRangeException.ThrowIfNegative(index);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(index, Count);
            ArgumentNullException.ThrowIfNull(item);
 
            item._owner = _owner;
 
            EnsureAdditionalCapacity(1);
 
            // Insert new item
            _owner._subItems.Insert(index, item);
            _owner.SubItemCount++;
            _owner.UpdateSubItems(-1);
        }
 
        void IList.Insert(int index, object? item)
        {
            if (item is not ListViewSubItem subItem)
            {
                throw new ArgumentException(SR.ListViewBadListViewSubItem, nameof(item));
            }
 
            Insert(index, subItem);
        }
 
        public void Remove(ListViewSubItem? item)
        {
            int index = IndexOf(item);
            if (index != -1)
            {
                RemoveAt(index);
            }
        }
 
        void IList.Remove(object? item)
        {
            if (item is ListViewSubItem itemValue)
            {
                Remove(itemValue);
            }
        }
 
        public void RemoveAt(int index)
        {
            ArgumentOutOfRangeException.ThrowIfNegative(index);
            ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Count);
 
            // Remove ourselves as the owner.
            _owner._subItems[index]._owner = null;
            _owner._subItems[index].ReleaseUiaProvider();
 
            // Collapse the items
            _owner._subItems.RemoveAt(index);
 
            int oldCount = _owner.SubItemCount;
            _owner.SubItemCount--;
            _owner.UpdateSubItems(-1, oldCount);
        }
 
        /// <summary>
        ///  Removes the child control with the specified key.
        /// </summary>
        public virtual void RemoveByKey(string? key)
        {
            int index = IndexOfKey(key);
            if (IsValidIndex(index))
            {
                RemoveAt(index);
            }
        }
 
        void ICollection.CopyTo(Array dest, int index)
        {
            if (Count > 0)
            {
                ((ICollection)_owner._subItems).CopyTo(dest, index);
            }
        }
 
        public IEnumerator GetEnumerator()
        {
            return _owner._subItems.GetEnumerator();
        }
    }
}