//---------------------------------------------------------------------
// <copyright file="EntityDataSourceWrapperCollection.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner       Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------
using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Collections;
using System.ComponentModel;
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Data.Mapping;
using System.Data.Objects;
using System.Reflection;
using System.Diagnostics;
using System.Data.Common;
using System.Data.Objects.DataClasses;
using System.Globalization;
using System.Data.EntityClient;
using System.Collections.ObjectModel;


namespace System.Web.UI.WebControls
{
    /// <summary>
    /// Summary description for EntityDataSourceWrapperCollection
    /// </summary>
    internal class EntityDataSourceWrapperCollection : IEnumerable, ICollection, ITypedList
    {
        private readonly ObjectContext _context;
        private readonly List<EntityDataSourceWrapper> _wrapperList;

        /// <summary>
        /// Gets the property descriptors exposed to the user.
        /// </summary>
        private readonly PropertyDescriptorCollection _visiblePropertyDescriptors;

        /// <summary>
        /// Gets all property descriptors.
        /// </summary>
        internal readonly ReadOnlyCollection<EntityDataSourceWrapperPropertyDescriptor> AllPropertyDescriptors; 

        private readonly bool _isReadOnly;
        private readonly Type _clrEntityType;

        internal EntityDataSourceWrapperCollection(ObjectContext context, EntitySet entitySet, EntityType restrictedEntityType)
        {
            EntityDataSourceUtil.CheckArgumentNull(context, "context");
            EntityDataSourceUtil.CheckArgumentNull(entitySet, "entitySet");

            _context = context;
            _wrapperList = new List<EntityDataSourceWrapper>();

            // get handles on the relevant workspaces
            MetadataWorkspace csWorkspace = ((EntityConnection)context.Connection).GetMetadataWorkspace();
            MetadataWorkspace ocWorkspace = context.MetadataWorkspace;

            // if no restricted type is given, we assume the entity set element type is exposed
            EntityType entityType = restrictedEntityType ?? entitySet.ElementType;
            _clrEntityType = EntityDataSourceUtil.GetClrType(ocWorkspace, entityType);
            
            // if no restricted type is given and the set is polymorphic, make the collection readonly
            if (null == restrictedEntityType &&
                1 < EntityDataSourceUtil.GetTypeAndSubtypesOf(entityType, csWorkspace.GetItemCollection(DataSpace.CSpace), true).Count())
            {
                _isReadOnly = true;
            }

            // gather the properties
            ReadOnlyCollection<EntityDataSourceColumn> columns = EntityDataSourceUtil.GetNamedColumns(csWorkspace, ocWorkspace, entitySet, entityType);
            List<PropertyDescriptor> visiblePropertyDescriptors = new List<PropertyDescriptor>(columns.Count);
            List<EntityDataSourceWrapperPropertyDescriptor> propertyDescriptors = new List<EntityDataSourceWrapperPropertyDescriptor>(columns.Count);
            foreach (EntityDataSourceColumn column in columns)
            {
                var descriptor = new EntityDataSourceWrapperPropertyDescriptor(this, column);
                propertyDescriptors.Add(descriptor);

                // if the descriptor does not have a dependent, it is exposed to the user
                if (!descriptor.Column.IsHidden)
                {
                    visiblePropertyDescriptors.Add(descriptor);
                }
            }

            _visiblePropertyDescriptors = new PropertyDescriptorCollection(visiblePropertyDescriptors.ToArray(), true);
            AllPropertyDescriptors = propertyDescriptors.AsReadOnly();
        }


        internal EntityDataSourceWrapper AddWrappedEntity(object entity)
        {
            EntityDataSourceWrapper wrapper = new EntityDataSourceWrapper(this, entity);
            this._wrapperList.Add(wrapper);
            return wrapper;
        }

        #region IEnumerable Implementation
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this._wrapperList.GetEnumerator();
        }
        #endregion IEnumerable Implementation

        #region ICollection Implementation
        public int Count
        {
            get { return this._wrapperList.Count; }
        }
        public void CopyTo(Array array, int index)
        {
            ((ICollection)this._wrapperList).CopyTo(array, index);
        }
        public bool IsSynchronized
        {
            get { return false; }
        }
        public object SyncRoot
        {
            get { return null; }
        }
        #endregion

        #region ITypedList Implementation
        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
        {
            if (null == listAccessors)
            {
                return this._visiblePropertyDescriptors ;
            }
            else
            {
                return null;// Implement this feature when we support traversing collections.
            }

        }

        string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
        {
            return null;
        }
        #endregion

        #region Internal properties
        /// <summary>
        /// Gets CLR type or base type for entities exposed in this collection.
        /// </summary>
        internal Type ClrEntityType 
        { 
            get { return _clrEntityType; } 
        }

        /// <summary>
        /// Indicates whether this configuration supports modifications.
        /// </summary>
        internal bool IsReadOnly 
        { 
            get { return _isReadOnly; } 
        }

        /// <summary>
        /// Gets object context tracking the contents of this collection.
        /// </summary>
        internal ObjectContext Context 
        { 
            get { return _context; } 
        }
        #endregion
    }
}