//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Collections.Generic
{
    using System;
    using System.Collections;
    using System.Diagnostics;
    using System.ServiceModel;

    [System.Runtime.InteropServices.ComVisible(false)]
    public class SynchronizedReadOnlyCollection<T> : IList<T>, IList
    {
        IList<T> items;
        object sync;

        public SynchronizedReadOnlyCollection()
        {
            this.items = new List<T>();
            this.sync = new Object();
        }

        public SynchronizedReadOnlyCollection(object syncRoot)
        {
            if (syncRoot == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));

            this.items = new List<T>();
            this.sync = syncRoot;
        }

        public SynchronizedReadOnlyCollection(object syncRoot, IEnumerable<T> list)
        {
            if (syncRoot == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));
            if (list == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("list"));

            this.items = new List<T>(list);
            this.sync = syncRoot;
        }

        public SynchronizedReadOnlyCollection(object syncRoot, params T[] list)
        {
            if (syncRoot == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));
            if (list == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("list"));

            this.items = new List<T>(list.Length);
            for (int i = 0; i < list.Length; i++)
                this.items.Add(list[i]);

            this.sync = syncRoot;
        }

        internal SynchronizedReadOnlyCollection(object syncRoot, List<T> list, bool makeCopy)
        {
            if (syncRoot == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));
            if (list == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("list"));

            if (makeCopy)
                this.items = new List<T>(list);
            else
                this.items = list;

            this.sync = syncRoot;
        }

        public int Count
        {
            get { lock (this.sync) { return this.items.Count; } }
        }

        protected IList<T> Items
        {
            get
            {
                return this.items;
            }
        }

        public T this[int index]
        {
            get { lock (this.sync) { return this.items[index]; } }
        }

        public bool Contains(T value)
        {
            lock (this.sync)
            {
                return this.items.Contains(value);
            }
        }

        public void CopyTo(T[] array, int index)
        {
            lock (this.sync)
            {
                this.items.CopyTo(array, index);
            }
        }

        public IEnumerator<T> GetEnumerator()
        {
            lock (this.sync)
            {
                return this.items.GetEnumerator();
            }
        }

        public int IndexOf(T value)
        {
            lock (this.sync)
            {
                return this.items.IndexOf(value);
            }
        }

        void ThrowReadOnly()
        {
            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SFxCollectionReadOnly)));
        }

        bool ICollection<T>.IsReadOnly
        {
            get { return true; }
        }

        T IList<T>.this[int index]
        {
            get
            {
                return this[index];
            }
            set
            {
                this.ThrowReadOnly();
            }
        }

        void ICollection<T>.Add(T value)
        {
            this.ThrowReadOnly();
        }

        void ICollection<T>.Clear()
        {
            this.ThrowReadOnly();
        }

        bool ICollection<T>.Remove(T value)
        {
            this.ThrowReadOnly();
            return false;
        }

        void IList<T>.Insert(int index, T value)
        {
            this.ThrowReadOnly();
        }

        void IList<T>.RemoveAt(int index)
        {
            this.ThrowReadOnly();
        }

        bool ICollection.IsSynchronized
        {
            get { return true; }
        }

        object ICollection.SyncRoot
        {
            get { return this.sync; }
        }

        void ICollection.CopyTo(Array array, int index)
        {
            ICollection asCollection = this.items as ICollection;
            if (asCollection == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SFxCopyToRequiresICollection)));

            lock (this.sync)
            {
                asCollection.CopyTo(array, index);
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            lock (this.sync)
            {
                IEnumerable asEnumerable = this.items as IEnumerable;
                if (asEnumerable != null)
                    return asEnumerable.GetEnumerator();
                else
                    return new EnumeratorAdapter(this.items);
            }
        }

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

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

        object IList.this[int index]
        {
            get
            {
                return this[index];
            }
            set
            {
                this.ThrowReadOnly();
            }
        }

        int IList.Add(object value)
        {
            this.ThrowReadOnly();
            return 0;
        }

        void IList.Clear()
        {
            this.ThrowReadOnly();
        }

        bool IList.Contains(object value)
        {
            VerifyValueType(value);
            return this.Contains((T)value);
        }

        int IList.IndexOf(object value)
        {
            VerifyValueType(value);
            return this.IndexOf((T)value);
        }

        void IList.Insert(int index, object value)
        {
            this.ThrowReadOnly();
        }

        void IList.Remove(object value)
        {
            this.ThrowReadOnly();
        }

        void IList.RemoveAt(int index)
        {
            this.ThrowReadOnly();
        }

        static void VerifyValueType(object value)
        {
            if ((value is T) || (value == null && !typeof(T).IsValueType))
                return;

            Type type = (value == null) ? typeof(Object) : value.GetType();
            string message = SR.GetString(SR.SFxCollectionWrongType2, type.ToString(), typeof(T).ToString());
            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(message));
        }

        sealed class EnumeratorAdapter : IEnumerator, IDisposable
        {
            IList<T> list;
            IEnumerator<T> e;

            public EnumeratorAdapter(IList<T> list)
            {
                this.list = list;
                this.e = list.GetEnumerator();
            }

            public object Current
            {
                get { return e.Current; }
            }

            public bool MoveNext()
            {
                return e.MoveNext();
            }

            public void Dispose()
            {
                e.Dispose();
            }

            public void Reset()
            {
                e = list.GetEnumerator();
            }
        }
    }
}