// 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;

namespace System.Security.Cryptography.Xml
{
    public sealed class ReferenceList : IList
    {
        private readonly ArrayList _references;

        public ReferenceList()
        {
            _references = new ArrayList();
        }

        public IEnumerator GetEnumerator()
        {
            return _references.GetEnumerator();
        }

        public int Count
        {
            get { return _references.Count; }
        }

#pragma warning disable CS8995 // Nullable type 'object?' is null-checked and will throw if null.
        public int Add(object? value)
        {
            ArgumentNullException.ThrowIfNull(value);

            if (!(value is DataReference) && !(value is KeyReference))
                throw new ArgumentException(SR.Cryptography_Xml_IncorrectObjectType, nameof(value));

            return _references.Add(value);
        }
#pragma warning restore

        public void Clear()
        {
            _references.Clear();
        }

        public bool Contains(object? value)
        {
            return _references.Contains(value);
        }

        public int IndexOf(object? value)
        {
            return _references.IndexOf(value);
        }

        public void Insert(int index, object? value)
        {
            ArgumentNullException.ThrowIfNull(value);

            if (!(value is DataReference) && !(value is KeyReference))
                throw new ArgumentException(SR.Cryptography_Xml_IncorrectObjectType, nameof(value));

            _references.Insert(index, value);
        }
#pragma warning restore

        public void Remove(object? value)
        {
            _references.Remove(value);
        }

        public void RemoveAt(int index)
        {
            _references.RemoveAt(index);
        }

        public EncryptedReference? Item(int index)
        {
            return (EncryptedReference?)_references[index];
        }

        [System.Runtime.CompilerServices.IndexerName("ItemOf")]
        public EncryptedReference this[int index]
        {
            get
            {
                return Item(index)!;
            }
            set
            {
                ((IList)this)[index] = value;
            }
        }

        /// <internalonly/>
        object? IList.this[int index]
        {
            get { return _references[index]; }
            set
            {
                if (value == null)
                    throw new ArgumentNullException(nameof(value));

                if (!(value is DataReference) && !(value is KeyReference))
                    throw new ArgumentException(SR.Cryptography_Xml_IncorrectObjectType, nameof(value));

                _references[index] = value;
            }
        }

        public void CopyTo(Array array, int index)
        {
            _references.CopyTo(array, index);
        }

        bool IList.IsFixedSize
        {
            get { return _references.IsFixedSize; }
        }

        bool IList.IsReadOnly
        {
            get { return _references.IsReadOnly; }
        }

        public object SyncRoot
        {
            get { return _references.SyncRoot; }
        }

        public bool IsSynchronized
        {
            get { return _references.IsSynchronized; }
        }
    }
}