using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Linq;
using System.Web;
using System.Web.Compilation;
using System.Web.Util;
using System.Reflection;

namespace System.Web.UI {

    // Helper class to retrieve filtered members from the target framework type using TargetFrameworkProvider.
    // We need to be careful not to expose faux/LMR types or memberInfo as they don't work properly when mixed
    // with their runtime counter parts.
    internal static class TargetFrameworkUtil {

        private class MemberCache {
            private ConcurrentDictionary<string, EventInfo> _events;
            private ConcurrentDictionary<Tuple<string, int>, FieldInfo> _fields;
            private ConcurrentDictionary<Tuple<string, int>, PropertyInfo> _properties;

            internal MemberCache() {
            }

            internal ConcurrentDictionary<string, EventInfo> Events {
                get {
                    if (_events == null) {
                        _events = new ConcurrentDictionary<string, EventInfo>();
                    }
                    return _events;
                }
            }
            internal ConcurrentDictionary<Tuple<string, int>, FieldInfo> Fields {
                get {
                    if (_fields == null) {
                        _fields = new ConcurrentDictionary<Tuple<string, int>, FieldInfo>();
                    }
                    return _fields;
                }
            }
            internal ConcurrentDictionary<Tuple<string, int>, PropertyInfo> Properties {
                get {
                    if (_properties == null) {
                        _properties = new ConcurrentDictionary<Tuple<string, int>, PropertyInfo>();
                    }
                    return _properties;
                }
            }
        }

        private static ConcurrentDictionary<Type, MemberCache> s_memberCache = new ConcurrentDictionary<Type, MemberCache>();

        private static ClientBuildManagerTypeDescriptionProviderBridge s_cbmTdpBridge;

        private static ConcurrentDictionary<Type, PropertyDescriptorCollection> s_typePropertyDescriptorCollectionDict =
            new ConcurrentDictionary<Type, PropertyDescriptorCollection>();
        private static ConcurrentDictionary<object, PropertyDescriptorCollection> s_objectPropertyDescriptorCollectionDict =
            new ConcurrentDictionary<object, PropertyDescriptorCollection>();
        private static ConcurrentDictionary<Type, EventDescriptorCollection> s_eventDescriptorCollectionDict =
            new ConcurrentDictionary<Type, EventDescriptorCollection>();
        
        private static ConcurrentDictionary<Type, bool> s_isFrameworkType = new ConcurrentDictionary<Type, bool>();
        
        private static MemberCache GetMemberCache(Type type){
            MemberCache memberCache = null;
            if (!s_memberCache.TryGetValue(type, out memberCache)) {
                memberCache = new MemberCache();
                s_memberCache.TryAdd(type, memberCache);
            }
            return memberCache;
        }

        private static Tuple<string, int> MakeTuple(string name, BindingFlags bindingAttr) {
            return new Tuple<string, int>(name, (int)bindingAttr);
        }

        private static TypeDescriptionProviderService TypeDescriptionProviderService {
            get {
                if (DesignerHost == null) {
                    return null;
                }
                TypeDescriptionProviderService tdpService = DesignerHost.GetService(typeof(TypeDescriptionProviderService)) as TypeDescriptionProviderService;
                return tdpService;
            }
        }

        /// <summary>
        /// The DesignerHost is only available within the context of DesignTimeTemplateParser.ParseControl, which is called
        /// from the design view.
        /// </summary>
        internal static IDesignerHost DesignerHost { get; set; }

        /// <summary>
        /// The CBMTypeDescriptionProviderBridge is only available when building using the ClientBuildManager in VS.
        /// </summary>
        internal static ClientBuildManagerTypeDescriptionProviderBridge CBMTypeDescriptionProviderBridge {
            set {
                s_cbmTdpBridge = value;
            }
        }

        // The provider needs not be cached because the TFP service 
        // returns light-weight providers that delegate to the same 
        // underlying TFP instance.  (Dev10 bug 795001)
        private static TypeDescriptionProvider GetTargetFrameworkProvider(object obj) {
            TypeDescriptionProviderService service = TargetFrameworkUtil.TypeDescriptionProviderService;
            if (service != null) {
                return service.GetProvider(obj);
            }
            return null;
        }

        private static TypeDescriptionProvider GetTargetFrameworkProvider(Type type) {
            TypeDescriptionProviderService service = TargetFrameworkUtil.TypeDescriptionProviderService;
            if (service != null) {
                return service.GetProvider(type);
            }
            return null;
        }

        private static ICustomTypeDescriptor GetTypeDescriptor(Type type) {
            TypeDescriptionProvider tdp = GetTargetFrameworkProvider(type);
            if (tdp != null) {
                ICustomTypeDescriptor descriptor = tdp.GetTypeDescriptor(type);
                if (descriptor != null) {
                    return descriptor;
                }
            }
            return null;
        }

        private static ICustomTypeDescriptor GetTypeDescriptor(object obj) {
            TypeDescriptionProvider tdp = GetTargetFrameworkProvider(obj);
            if (tdp != null) {
                ICustomTypeDescriptor descriptor = tdp.GetTypeDescriptor(obj);
                if (descriptor != null) {
                    return descriptor;
                }
            }
            return null;
        }

        /// <summary>
        /// Returns the target type if it is available, otherwise returns back the original type
        /// </summary>
        private static Type GetReflectionType(Type type) {
            if (type == null) {
                return null;
            }
            TypeDescriptionProvider provider = GetTargetFrameworkProvider(type);
            if (provider != null) {
                return provider.GetReflectionType(type);
            }
            return type;
        }

        private static Type[] GetReflectionTypes(Type[] types) {
            if (types == null) {
                return null;
            }
            var reflectionTypes = from t in types select GetReflectionType(t);
            return reflectionTypes.ToArray();
        }

        internal static PropertyInfo GetProperty(Type type, string name, BindingFlags bindingAttr,
            Type returnType = null,
            Type[] types = null,
            bool throwAmbiguousMatchException = false) {

            if (types == null) {
                types = Type.EmptyTypes;
            }

            if (SkipCache || returnType != null || types != Type.EmptyTypes) {
                // Don't cache if any of the values are non-default
                return GetPropertyHelper(type, name, bindingAttr, returnType, types, throwAmbiguousMatchException);
            }

            PropertyInfo result = null;
            MemberCache memberCache = GetMemberCache(type);
            Tuple<string, int> key = MakeTuple(name, bindingAttr);
            if (!memberCache.Properties.TryGetValue(key, out result)) {
                result = GetPropertyHelper(type, name, bindingAttr, returnType, types, throwAmbiguousMatchException);
                memberCache.Properties.TryAdd(key, result);
            }

            return result;
        }

        private static PropertyInfo GetPropertyHelper(Type type, string name, BindingFlags bindingAttr,
            Type returnType, Type[] types, bool throwAmbiguousMatchException) {
            try {

                bool hasProperty = false;
                if (s_cbmTdpBridge != null && IsFrameworkType(type)) {
                    Type typeToUse = GetTypeToUseForCBMBridge(type);
                    hasProperty = s_cbmTdpBridge.HasProperty(typeToUse, name, bindingAttr, returnType, types);
                }
                else {
                    Type reflectionType = GetReflectionType(type);
                    Type reflectionReturnType = GetReflectionType(returnType);
                    Type[] reflectionTypes = GetReflectionTypes(types);
                    PropertyInfo propInfo = reflectionType.GetProperty(name, bindingAttr, null /* binder */, 
                        reflectionReturnType, reflectionTypes, null /* modifiers */);

                    hasProperty = propInfo != null;
                }
                
                // Return the actual runtime PropertyInfo only if it was found in the target type.
                if (hasProperty) {
                    return type.GetProperty(name, bindingAttr, null /* binder */, returnType, types, null /* modifiers */);
                }
            } catch (AmbiguousMatchException) {
                if (throwAmbiguousMatchException) {
                    throw;
                } 
                return GetMostSpecificProperty(type, name, bindingAttr, returnType, types);
            }
            return null;
        }

        internal static FieldInfo GetField(Type type, string name, BindingFlags bindingAttr) {
            if (SkipCache) {
                return GetFieldInfo(type, name, bindingAttr);
            }

            FieldInfo result = null;
            MemberCache memberCache = GetMemberCache(type);

            Tuple<string, int> key = MakeTuple(name, bindingAttr);
            if (!memberCache.Fields.TryGetValue(key, out result)) {
                result = GetFieldInfo(type, name, bindingAttr);
                memberCache.Fields.TryAdd(key, result);
            }

            return result;
        }

        private static FieldInfo GetFieldInfo(Type type, string name, BindingFlags bindingAttr) {
            if (s_cbmTdpBridge != null && IsFrameworkType(type)) {
                Type typeToUse = GetTypeToUseForCBMBridge(type);
                bool hasField = s_cbmTdpBridge.HasField(typeToUse, name, bindingAttr);
                if (hasField) {
                    return type.GetField(name, bindingAttr);
                }
                return null;
            }

            Type targetFrameworkType = GetReflectionType(type);
            FieldInfo fieldInfo = targetFrameworkType.GetField(name, bindingAttr);

            // Return the actual runtime FieldInfo only if it was found in the target type.
            if (fieldInfo != null) {
                return type.GetField(name, bindingAttr);
            }
            return null;
        }

        internal static EventInfo GetEvent(Type type, string name) {
            if (SkipCache) {
                return GetEventInfo(type, name);
            }

            EventInfo result = null;
            MemberCache memberCache = GetMemberCache(type);

            if (!memberCache.Events.TryGetValue(name, out result)) {
                result = GetEventInfo(type, name);
                memberCache.Events.TryAdd(name, result);
            }

            return result;
        }

        private static EventInfo GetEventInfo(Type type, string name) {
            if (s_cbmTdpBridge != null && IsFrameworkType(type)) {
                Type typeToUse = GetTypeToUseForCBMBridge(type);
                bool hasEvent = s_cbmTdpBridge.HasEvent(typeToUse, name);
                if (hasEvent) {
                    return type.GetEvent(name);
                }
                return null;
            }

            Type targetFrameworkType = GetReflectionType(type);
            EventInfo eventInfo = targetFrameworkType.GetEvent(name);

            // Return the actual runtime EventInfo only if it was found in the target type.
            if (eventInfo != null) {
                return type.GetEvent(name);
            }
            return null;
        }

        internal static PropertyDescriptorCollection GetProperties(Type type) {
            if (SkipCache) {
                return GetPropertyDescriptorCollection(type);
            }

            PropertyDescriptorCollection result = null;
            
            if (!s_typePropertyDescriptorCollectionDict.TryGetValue(type, out result)) {
                result = GetPropertyDescriptorCollection(type);
                s_typePropertyDescriptorCollectionDict.TryAdd(type, result);
            }

            return result;
        }

        private static PropertyDescriptorCollection GetPropertyDescriptorCollection(Type type) {
            if (s_cbmTdpBridge != null && IsFrameworkType(type)) {
                return GetFilteredPropertyDescriptorCollection(type, null);
            }

            ICustomTypeDescriptor descriptor = GetTypeDescriptor(type);
            if (descriptor != null) {
                return descriptor.GetProperties();
            }
            else {
                return TypeDescriptor.GetProperties(type);
            }
        }

        internal static PropertyDescriptorCollection GetProperties(object obj) {
            if (SkipCache) {
                return GetPropertyDescriptorCollection(obj);
            }

            PropertyDescriptorCollection result = null;

            if (!s_objectPropertyDescriptorCollectionDict.TryGetValue(obj, out result)) {
                result = GetPropertyDescriptorCollection(obj);
                s_objectPropertyDescriptorCollectionDict.TryAdd(obj, result);
            }

            return result;
        }
        
        private static PropertyDescriptorCollection GetPropertyDescriptorCollection(object obj) {
            Type type = obj.GetType();
            if (s_cbmTdpBridge != null && IsFrameworkType(type)) {
                return GetFilteredPropertyDescriptorCollection(type, obj);
            }

            ICustomTypeDescriptor descriptor = GetTypeDescriptor(obj);
            if (descriptor != null) {
                return descriptor.GetProperties();
            }
            else {
                return TypeDescriptor.GetProperties(obj);
            }
        }

        /// <summary>
        /// This method does filtering based on propertyInfo, and should only be used when the TargetFrameworkProvider
        /// is not directly available, for example in the CBM case where it is in another appdomain.
        /// </summary>
        private static PropertyDescriptorCollection GetFilteredPropertyDescriptorCollection(Type objectType, object instance) {
            Debug.Assert(s_cbmTdpBridge != null, "s_cbmTdpBridge should not be null");
            PropertyDescriptorCollection propertyDescriptors = null;
            if (instance != null) {
                propertyDescriptors = TypeDescriptor.GetProperties(instance);
            }
            else if (objectType != null) {
                propertyDescriptors = TypeDescriptor.GetProperties(objectType);
            }
            else {
                throw new ArgumentException("At least one argument should be non-null");
            }
            BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance; 
            Type typeToUse = GetTypeToUseForCBMBridge(objectType);
            string[] propertyNames = s_cbmTdpBridge.GetFilteredProperties(typeToUse, bindingFlags);
            
            var filteredPropertyDescriptors = from p in propertyNames
                let d = propertyDescriptors[p]
                where d != null select d;

            return new PropertyDescriptorCollection(filteredPropertyDescriptors.ToArray());
        }

        internal static EventDescriptorCollection GetEvents(Type type) {
            if (SkipCache) {
                return GetEventDescriptorCollection(type);
            }

            EventDescriptorCollection result = null;
            if (!s_eventDescriptorCollectionDict.TryGetValue(type, out result)) {
                result = GetEventDescriptorCollection(type);
                s_eventDescriptorCollectionDict.TryAdd(type, result);
            }
            return result;

        }

        private static EventDescriptorCollection GetEventDescriptorCollection(Type type) {
            if (s_cbmTdpBridge != null && IsFrameworkType(type)) {
                return GetFilteredEventDescriptorCollection(type, null);
            }

            ICustomTypeDescriptor descriptor = GetTypeDescriptor(type);
            if (descriptor != null) {
                return descriptor.GetEvents();
            }
            else {
                return TypeDescriptor.GetEvents(type);
            }
        }

        /// <summary>
        /// This method does filtering based on eventInfo, and should only be used when the TargetFrameworkProvider
        /// is not directly available, for example in the CBM case where it is in another appdomain.
        /// </summary>
        private static EventDescriptorCollection GetFilteredEventDescriptorCollection(Type objectType, object instance) {
            Debug.Assert(s_cbmTdpBridge != null, "s_cbmTdpBridge should not be null");
            EventDescriptorCollection eventDescriptors = null;
            if (instance != null) {
                eventDescriptors = TypeDescriptor.GetEvents(instance);
            }
            else if (objectType != null) {
                eventDescriptors = TypeDescriptor.GetEvents(objectType);
            }
            else {
                throw new ArgumentException("At least one argument should be non-null");
            }
            BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
            Type typeToUse = GetTypeToUseForCBMBridge(objectType);
            string[] eventNames = s_cbmTdpBridge.GetFilteredEvents(typeToUse, bindingFlags);
            
            var filteredEventDescriptors = from e in eventNames
                let d = eventDescriptors[e]
                where d != null select d;

            return new EventDescriptorCollection(filteredEventDescriptors.ToArray());
        }

        internal static System.ComponentModel.AttributeCollection GetAttributes(Type type) {
            ICustomTypeDescriptor descriptor = GetTypeDescriptor(type);
            if (descriptor != null) {
                return descriptor.GetAttributes();
            }
            else {
                return TypeDescriptor.GetAttributes(type);
            }
        }

        internal static object[] GetCustomAttributes(Type type, Type attributeType, bool inherit) {
            Type targetType = GetReflectionType(type);
            return targetType.GetCustomAttributes(attributeType, inherit);
        }

        /// <summary>
        /// Function to return an assembly qualified type name based on the type in the target framework
        /// </summary>
        internal static string TypeNameConverter(Type type) {
            string typeName = null;

            if (type != null) {
                Type targetFrameworkType = GetReflectionType(type);
                if (targetFrameworkType != null) {
                    typeName = targetFrameworkType.AssemblyQualifiedName;
                }
            }

            return typeName;
        }

        private static bool IsFrameworkType(Type type) {
            // We need to make sure a type is a framework type, before we try to use s_cbmTdpBridge on it.
            // Also, isFrameworkType should only be called in this specific scenario, when we are trying
            // to use s_cbmTdpBridge.
            Debug.Assert(s_cbmTdpBridge != null, "s_cbmTdpBridge should not be null in IsFrameworkType");
            bool result;
            if (!s_isFrameworkType.TryGetValue(type, out result)) {
                Assembly a = type.Assembly;
                string path;
                ReferenceAssemblyType referenceAssemblyType = AssemblyResolver.GetPathToReferenceAssembly(a, out path);
                result = (referenceAssemblyType != ReferenceAssemblyType.NonFrameworkAssembly);
                s_isFrameworkType.TryAdd(type, result);
            }
            return result;
        }

        private static PropertyInfo GetMostSpecificProperty(Type type, string name, BindingFlags additionalFlags, Type returnType, Type[] types) {
            BindingFlags flags = BindingFlags.DeclaredOnly;
            flags |= additionalFlags;
            PropertyInfo propInfo;
            Type currentType = type;

            while (currentType != null) {
                // DevDiv #425681: Even with BindingFlags.DeclaredOnly, Type.GetProperty may still throw an
                // AmbiguousMatchException, such as if there exist two properties that differ only by case.
                // If this happens, we need to let that exception propagate up, otherwise GetPropertyHelper
                // will call GetMostSpecificProperty, eventually resulting in stack overflow.
                propInfo = GetProperty(currentType, name, flags, returnType, types, throwAmbiguousMatchException: true);
                if (propInfo != null) {
                    return propInfo;
                }
                else {
                    currentType = currentType.BaseType;
                }
            }

            return null;
        }

        // If the type is a generic type, use the generic type definition instead,
        // in case it has non-framework type arguments.
        private static Type GetTypeToUseForCBMBridge(Type type) {
            return type.IsGenericType ? type.GetGenericTypeDefinition() : type;
        }

        internal static bool HasMethod(Type type, string name, BindingFlags bindingAttr) {
            bool hasMethod = false;
            if (s_cbmTdpBridge != null && IsFrameworkType(type)) {
                Type typeToUse = GetTypeToUseForCBMBridge(type);
                hasMethod = s_cbmTdpBridge.HasMethod(typeToUse, name, bindingAttr);
            }
            else {
                Type reflectionType = GetReflectionType(type);
                MethodInfo methodInfo = reflectionType.GetMethod(name, bindingAttr);
                hasMethod = methodInfo != null;
            }
            return hasMethod;
        }
        private static bool SkipCache {
            get {
                // We should not be statically caching items in the VS primary appdomain.
                // - If the cbm bridge is available, caching is ok since we are in a separate appdomain.
                //   (The appdomain gets reset when the project unloads or when a reference assembly is
                //   updated).
                // - Otherwise, we are either already using standard reflection, or we are using the
                //   TFP in the primary appdomain, and should not be caching statically.
                // Dev10 bug 805134
                return s_cbmTdpBridge == null;
            }
        }

        internal static bool IsSupportedType(Type type) {
            TypeDescriptionProvider provider = GetTargetFrameworkProvider(type);
            if (provider == null) {
                provider = TypeDescriptor.GetProvider(type);
            }
            return provider.IsSupportedType(type);
        }
    }
}