//------------------------------------------------------------------------------
// <copyright file="VirtualDirectoryMappingCollection.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.Configuration {
    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Configuration;
    using System.Web.Util;
    using System.Security.Permissions;

    //
    // Collection of VirtualDirectoryMappings.
    // Follows the standard pattern for collections derived from NameObjectCollectionBase.
    //
    [Serializable()]
    public sealed class VirtualDirectoryMappingCollection : NameObjectCollectionBase {
        public VirtualDirectoryMappingCollection() : base(StringComparer.OrdinalIgnoreCase) {
        }

        public ICollection AllKeys {
            get {
                return BaseGetAllKeys();
            }
        }                                       

        public VirtualDirectoryMapping this[string virtualDirectory] {
            get {
                virtualDirectory = ValidateVirtualDirectoryParameter(virtualDirectory);

                return Get(virtualDirectory);
            }
        }

        public VirtualDirectoryMapping this[int index] {
            get {
                return Get(index);
            }
        }

        public void Add(string virtualDirectory, VirtualDirectoryMapping mapping) {
            virtualDirectory = ValidateVirtualDirectoryParameter(virtualDirectory);

            if (mapping == null) {
                throw new ArgumentNullException("mapping");
            }

            if (Get(virtualDirectory) != null) {
                throw ExceptionUtil.ParameterInvalid("virtualDirectory");
            }

            mapping.SetVirtualDirectory(VirtualPath.CreateAbsoluteAllowNull(virtualDirectory));
            BaseAdd(virtualDirectory, mapping);
        }

        public void Clear() {
            BaseClear();
        }

        public void CopyTo(VirtualDirectoryMapping[] array, int index) {
            if (array == null) {
                throw new ArgumentNullException("array");
            }

            int c = Count;
            if (array.Length < c + index) {
                throw new ArgumentOutOfRangeException("index");
            }

            for (int i = 0, j = index; i < c; i++, j++) {
                array[j] = Get(i);
            }
        }

        public VirtualDirectoryMapping Get(int index) {
            return (VirtualDirectoryMapping) BaseGet(index);
        }

        public VirtualDirectoryMapping Get(string virtualDirectory) {
            virtualDirectory = ValidateVirtualDirectoryParameter(virtualDirectory);

            return (VirtualDirectoryMapping) BaseGet(virtualDirectory);
        }

        public string GetKey(int index) {
            return BaseGetKey(index);
        }

        public void Remove(string virtualDirectory) {
            virtualDirectory = ValidateVirtualDirectoryParameter(virtualDirectory);

            BaseRemove(virtualDirectory);
        }

        public void RemoveAt(int index) {
            BaseRemoveAt(index);
        }

        internal VirtualDirectoryMappingCollection Clone() {
            VirtualDirectoryMappingCollection col = new VirtualDirectoryMappingCollection();
            for (int i = 0; i < this.Count; i++) {
                VirtualDirectoryMapping mapping = this[i];
                col.Add(mapping.VirtualDirectory, mapping.Clone());
            }

            return col;
        }

        private static string ValidateVirtualDirectoryParameter(string virtualDirectory) {
            // Create a VirtualPath object to validate the path
            VirtualPath v = VirtualPath.CreateAbsoluteAllowNull(virtualDirectory);
            return VirtualPath.GetVirtualPathString(v);
        }
    }
}