using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

namespace OpenTap
{
    /// <summary>
    /// Representation of a C#/dotnet type including its inheritance hierarchy. Part of the object model used in the PluginManager
    /// </summary>
    [DebuggerDisplay("{Name}")]
    public class TypeData : ITypeData
    {
        // Used to mark when no display attribute is present.
        static readonly DisplayAttribute noDisplayAttribute = new DisplayAttribute("<<Null>>");

        // Used to mark when no helplink attribute is present.
        static readonly HelpLinkAttribute noHelpLinkAttribute = new HelpLinkAttribute(null);

        /// <summary>
        /// Gets the fully qualified name of the type, including its namespace but not its assembly.
        /// </summary>
        public string Name { get;}

        /// <summary>
        /// Gets the TypeAttributes for this type. This can be used to check if the type is abstract, nested, an interface, etc.
        /// </summary>
        public TypeAttributes TypeAttributes { get; internal set; }

        /// <summary>
        /// Gets the Assembly that defines this type.
        /// </summary>
        public AssemblyData Assembly { get; internal set; }


        /// <summary>
        /// Clone this typedata instance. Note that it is only partially cloned.
        /// In particular, derived types and base types are not populated.
        /// </summary>
        /// <returns></returns>
        internal TypeData Clone()
        {
            return new TypeData(Name)
            {
                IsBrowsable = IsBrowsable,
                display = display,
                helpLink = helpLink,
                canCreateInstance = canCreateInstance,
                Assembly = Assembly,
                TypeAttributes = TypeAttributes,
            };
        }
        
        /// <summary>
        /// Gets.the DisplayAttribute for this type. Null if the type does not have a DisplayAttribute
        /// </summary>
        public DisplayAttribute Display
        {
            get
            {
                if (display is null && attributes != null)
                {
                    display = noDisplayAttribute;
                    foreach (var attr in attributes)
                    {
                        if (attr is DisplayAttribute displayAttr)
                        {
                            display = displayAttr;
                            break;
                        }
                    }
                }

                if (ReferenceEquals(display, noDisplayAttribute))
                    return null;
                return display;
            }
            internal set => display = value;
        }

        /// <summary>
        /// Gets.the HelpLinkAttribute for this type. Null if the type does not have a HelpLinkAttribute
        /// </summary>
        public HelpLinkAttribute HelpLink
        {
            get
            {
                if (helpLink is null && attributes != null)
                {
                    helpLink = noHelpLinkAttribute;
                    foreach (var attr in attributes)
                    {
                        if (attr is HelpLinkAttribute helpLinkAttr)
                        {
                            helpLink = helpLinkAttr;
                            break;
                        }
                    }
                }

                if (ReferenceEquals(helpLink, noHelpLinkAttribute))
                    return null;
                return helpLink;
            }
            internal set => helpLink = value;
        }

        /// <summary> Gets a list of base types (including interfaces) </summary>
        internal ICollection<TypeData> BaseTypes => baseTypes;

        /// <summary>
        /// Gets a list of plugin types (i.e. types that directly implement ITapPlugin) that this type inherits from/implements
        /// </summary>
        public IEnumerable<TypeData> PluginTypes => pluginTypes;

        /// <summary>
        /// Gets a list of types that has this type as a base type (including interfaces)
        /// </summary>
        public IEnumerable<TypeData> DerivedTypes => derivedTypes ?? Array.Empty<TypeData>();

        /// <summary>
        /// False if the type has a System.ComponentModel.BrowsableAttribute with Browsable = false.
        /// </summary>
        public bool IsBrowsable { get; internal set; }

        /// <summary> 
        /// The attributes of this type. 
        /// Accessing this property causes the underlying Assembly to be loaded if it is not already.
        /// </summary>
        public IEnumerable<object> Attributes =>
            attributes ?? (attributes = Load()?.GetAllCustomAttributes(false)) ?? Array.Empty<object>();

        /// <summary>
        /// Gets the System.Type that this represents. Same as calling <see cref="Load()"/>.
        /// Accessing this property causes the underlying Assembly to be loaded if it is not already.
        /// </summary>
        public Type Type => Load();

        /// <summary> gets if the type is a value-type. (see Type.IsValueType)</summary>
        public bool IsValueType
        {
            get
            {
                PostLoad();
                return isValueType;
            }
        }

        /// <summary> Check if the assembly defining the type is loaded. </summary>
        public bool IsAssemblyLoaded() => Assembly?.IsLoaded() ?? false;

        internal TypeCode TypeCode => typeCode;
        internal bool IsNumeric
        {
            get
            {
                PostLoad();
                if (type.IsEnum)
                    return false;
                switch (typeCode)
                {
                    case TypeCode.Byte:
                    case TypeCode.SByte:
                    case TypeCode.UInt16:
                    case TypeCode.UInt32:
                    case TypeCode.UInt64:
                    case TypeCode.Int16:
                    case TypeCode.Int32:
                    case TypeCode.Int64:
                    case TypeCode.Decimal:
                    case TypeCode.Double:
                    case TypeCode.Single:
                        return true;
                    default:
                        return false;
                }
            }
        }

        /// <summary> The base type of this type. Will return null if there is no base type. If there is no direct base, but instead an interface, that will be returned.</summary>
        public ITypeData BaseType
        {
            get
            {
                if (baseTypeCache != null)
                    return ReferenceEquals(baseTypeCache, NullTypeData.Instance) ? null : baseTypeCache;
                baseTypeCache = BaseTypes?.ElementAtOrDefault(0);
                if (baseTypeCache != null) return baseTypeCache;
                var result2 = Load()?.BaseType;
                if (result2 != null)
                {
                    baseTypeCache = FromType(result2);
                    return baseTypeCache;
                }

                baseTypeCache = NullTypeData.Instance;
                return baseTypeCache;
            }
        }

        /// <summary> If this is a collection type, then this is the element type. Otherwise null. </summary>
        internal TypeData ElementType
        {
            get
            {
                PostLoad();
                return elementType;
            }
        }

        /// <summary> 
        /// returns true if an instance possibly can be created. 
        /// Accessing this property causes the underlying Assembly to be loaded if it is not already.
        /// </summary>
        public bool CanCreateInstance
        {
            get
            {
                if (failedLoad) return false;
                if (canCreateInstance.HasValue) return canCreateInstance.Value;
                if (Load() is Type t)
                {
                    type = t;
                    canCreateInstance = type.IsValueType ||
                                        type.IsAbstract == false && type.IsInterface == false &&
                                        type.ContainsGenericParameters == false &&
                                        type.GetConstructor(Array.Empty<Type>()) != null;
                    return canCreateInstance.Value;
                }

                return false; // failed to load
            }
            internal set => canCreateInstance = value;
        }

        internal string AssemblyQualifiedName
        {
            get
            {
                if (failedLoad) return "";
                return assemblyQualifiedName ?? (assemblyQualifiedName = Load().AssemblyQualifiedName);
            }
        }

        /// <summary> The loaded state of the type. </summary>
        internal LoadStatus Status =>
            type != null ? LoadStatus.Loaded : (failedLoad ? LoadStatus.FailedToLoad : LoadStatus.NotLoaded);

        internal bool createInstanceSet => canCreateInstance.HasValue;

        internal bool IsString
        {
            get
            {
                PostLoad();
                return typeCode == TypeCode.String;
            }
        }

        /// <summary>  Invoked when new types has been discovered in an asynchronous fashion. </summary>
        public static event EventHandler<TypeDataCacheInvalidatedEventArgs> TypeCacheInvalidated;

        static readonly TraceSource log = Log.CreateSource("PluginManager");
        static ImmutableArray<ITypeDataSearcher> searchers = ImmutableArray<ITypeDataSearcher>.Empty;

        static readonly ConcurrentDictionary<ITypeData, ITypeData[]> derivedTypesCache =
            new ConcurrentDictionary<ITypeData, ITypeData[]>();

        static readonly object lockSearchers = new object();
        static int lastCount;
        static readonly HashSet<ITypeData> warningLogged = new HashSet<ITypeData>();
        static ConditionalWeakTable<Type, TypeData> typeToTypeDataCache = new ConditionalWeakTable<Type, TypeData>();

        // add assembly is not thread safe.
        static readonly object loadTypeDictLock = new object();

        Type type;
        bool? canCreateInstance;
        ICollection<TypeData> baseTypes;
        ICollection<TypeData> derivedTypes;
        ICollection<TypeData> pluginTypes;
        IMemberData[] members;
        bool hasFlags;
        DisplayAttribute display;
        HelpLinkAttribute helpLink;
        string assemblyQualifiedName;
        bool failedLoad;
        TypeData elementType;
        ITypeData baseTypeCache;

        // this value is used to mark a type code that has not been loaded
        // all the normal values of TypeCode means something specifically
        // so this value is used as something that does not have other meaning.
        const int UnloadedTypeCode = 100;
        
        TypeCode typeCode = (TypeCode)(UnloadedTypeCode);
        object[] attributes = null;
        bool postLoaded = false;
        readonly object loadLock = new object();
        bool isValueType;

        internal void FinalizeCreation()
        {
            baseTypes = baseTypes?.ToArray();
            pluginTypes = pluginTypes?.ToArray();
        }

        internal void AddBaseType(TypeData typename)
        {
            if (baseTypes == null)
                baseTypes = new HashSet<TypeData>();
            baseTypes.Add(typename);
        }

        internal void AddPluginType(TypeData typename)
        {
            if (typename == null)
                return;
            if (pluginTypes == null)
                pluginTypes = new HashSet<TypeData>();
            pluginTypes.Add(typename);
        }

        internal void AddPluginTypes(IEnumerable<TypeData> types)
        {
            if (types == null)
                return;
            if (pluginTypes == null)
                pluginTypes = new HashSet<TypeData>();
            foreach (var t in types)
                pluginTypes.Add(t);
        }

        internal void AddDerivedType(TypeData typename)
        {
            if (derivedTypes == null)
                derivedTypes = new HashSet<TypeData>();
            else if (derivedTypes.Contains(typename))
                return;
            derivedTypes.Add(typename);
            if (BaseTypes != null)
            {
                foreach (TypeData b in BaseTypes)
                    b.AddDerivedType(typename);
            }
        }

        internal void RemoveDerivedType(TypeData typename)
        {
            if (derivedTypes != null && derivedTypes.Contains(typename))
                derivedTypes.Remove(typename);
        }

        internal TypeData(string typeName)
        {
            Name = typeName;
            IsBrowsable = true;
        }

        TypeData(Type type, PluginSearcher searcher): this(type.FullName)
        {
            this.type = type;
            if(type.Assembly.IsDynamic == false)
                this.Assembly = searcher.GetAssemblyData(type.Assembly);
            else
            {
                this.Assembly = new AssemblyData(null, type.Assembly);
            }
            PostLoad();
            IsBrowsable = this.GetAttribute<BrowsableAttribute>()?.Browsable ?? true;
        }
        

        /// <summary>
        /// Returns the System.Type corresponding to this. 
        /// If the assembly in which this type is defined has not yet been loaded, this call will load it.
        /// </summary>
        public Type Load()
        {
            if (failedLoad) return null;
            if (type != null && UnloadedTypeCode != (int)typeCode)
            {
                return type;
            }
            // if UnloadedTypeCode == typeCode, it means it has not been fully loaded. 

            try
            {
                
                var asm = Assembly?.Load();
                if (asm == null)
                {
                    failedLoad = true;
                    return null;
                }

                type = asm.GetType(this.Name, true);
                typeCode = Type.GetTypeCode(type);
                typeToTypeDataCache.GetValue(type, t => this);
            }
            catch (Exception ex)
            {
                failedLoad = true;
                var reason = ex.Message;
                // Create a special-case error message when the load error is due to a dotnet runtime mismatch.
                // FileName is a qualified assembly name, e.g. System.Runtime, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                const string versionPrefix = "System.Runtime, Version=";
                if (ex is FileNotFoundException notFound && notFound.FileName.StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase))
                {
                    // Build the reason string. I don't know if it's possible for the assembly to not be strong-named,
                    // but let's handle that just in case.
                    var filename = notFound.FileName;
                    
                    var versionEnd = filename.IndexOf(',', versionPrefix.Length);
                    if (versionEnd == -1)
                    {
                        // no comma, so it ends with "Version=X.Y.Z.W"
                        versionEnd = filename.Length;
                    }
                    var versionString = filename.Substring(versionPrefix.Length, versionEnd - versionPrefix.Length);

                    reason =
                        $"This type depends on .NET {versionString}, but the current process is running {System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription}";
                }
                log.Error("Unable to load type '{0}' from '{1}'. Reason: '{2}'.", Name, Assembly.Location, reason);
                log.Debug(ex);
            }

            return type;
        }

        /// <summary>
        /// Returns the DisplayAttribute.Name if the type has a DisplayAttribute, otherwise the FullName without namespace
        /// </summary>
        /// <returns></returns>
        public string GetBestName()
        {
            return Display != null ? Display.Name : Name.Split('.', '+').Last();
        }
        
                /// <summary> Creates a string value of this.</summary>
        public override string ToString() => Name;

        void PostLoad()
        {
            if (postLoaded) return;
            lock (loadLock)
            {
                if (postLoaded) return;
                Load();
                if (type != typeof(string))
                {
                    var elementType = type.GetEnumerableElementType();
                    if (elementType != null)
                        this.elementType = FromType(elementType);
                }

                typeCode = Type.GetTypeCode(type);
                hasFlags = this.HasAttribute<FlagsAttribute>();
                isValueType = type.IsValueType;
                postLoaded = true;
            }
        }


        /// <summary>
        /// Creates a new object instance of this type.
        /// Accessing this property causes the underlying Assembly to be loaded if it is not already.
        /// </summary>
        public object CreateInstance(object[] arguments)
        {
            if (!(Load() is Type t))
                throw new InvalidOperationException(
                    $"Failed to instantiate object of type '{this.Name}'. The assembly failed to load.");
            return Activator.CreateInstance(t, arguments);
        }

        /// <summary>
        /// Gets a member by name.
        /// Causes the underlying Assembly to be loaded if it is not already.
        /// </summary>
        public IMemberData GetMember(string name)
        {
            var members = (IMemberData[])GetMembers();
            foreach (var member in members)
            {
                if (member.Name == name)
                    return member;
            }

            return null;
        }

        /// <summary>
        /// Gets all the members of this type. 
        /// Causes the underlying Assembly to be loaded if it is not already.
        /// </summary>
        public IEnumerable<IMemberData> GetMembers()
        {
            if (members != null) return members;

            if (Load() is Type t)
            {
                var props = t.GetPropertiesTap();
                List<IMemberData> m = new List<IMemberData>(props.Length);
                foreach (var mem in props)
                {
                    try
                    {
                        if (mem.GetMethod != null && mem.GetMethod.GetParameters().Length > 0)
                            continue;

                        if (mem.SetMethod != null && mem.SetMethod.GetParameters().Length != 1)
                            continue;
                    }
                    catch
                    {
                        continue;
                    }

                    m.Add(MemberData.Create(mem));
                }

                foreach (var mem in t.GetMethodsTap())
                {
                    if (mem.GetAttribute<BrowsableAttribute>()?.Browsable ?? false)
                    {
                        var member = MemberData.Create(mem);
                        m.Add(member);
                    }
                }

                members = m.ToArray();
            }
            else
            {
                // The members list cannot be populated because the type could not be loaded.
                members = Array.Empty<IMemberData>();
            }

            return members;
        }

        internal bool HasFlags()
        {
            PostLoad();
            return hasFlags;
        }

        /// <summary> Compares two TypeDatas by comparing their inner Type instances. </summary>
        /// <param name="obj"> Should be a TypeData</param>
        /// <returns>true if the two Type properties are equals.</returns>
        public override bool Equals(object obj)
        {
            if (obj is TypeData td && td.type != null && type != null)
                return td.type == type;
            return ReferenceEquals(this, obj);
        }

        /// <summary> Calculates the hash code based on the .NET Type instance. </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            var asm = Assembly?.GetHashCode() ?? 0;
            return (asm + 586093897) * 759429795 +
                   (Name.GetHashCode() + 836431542) * 678129773;
        }

        
        /// <summary> Get the type info of an object. </summary>
        public static ITypeData GetTypeData(object obj)
        {
            if (obj == null) return NullTypeData.Instance;
            var cache = TypeDataCache.Current;
            if (cache != null && cache.TryGetValue(obj, out var cachedValue))
                return cachedValue;
            var resolver = new TypeDataProviderStack();
            var result = resolver.GetTypeData(obj);
            if (result == null)
                // this should never be possible since even GetTypeData(null) returns type of object.
                throw new Exception($"GetTypeData returned null for an object if type {obj.GetType()}");
            if (cache == null)
                return result;
            cache[obj] = result;
            return result;
        }

        /// <summary> Get all known types that derive from a given type.</summary>
        /// <param name="baseType">Base type that all returned types descends to.</param>
        /// <returns>All known types that descends to the given base type.</returns>
        public static IEnumerable<ITypeData> GetDerivedTypes(ITypeData baseType)
        {
            bool invalidated = false;
            int count = 0;
            foreach (var s in searchers)
            {
                var items = s.Types;
                if (items is null)
                    invalidated = true;
                else
                    count += items.Count();
            }

            if (lastCount == count && invalidated == false && derivedTypesCache.TryGetValue(baseType, out var result2))
                return result2;

            lock (lockSearchers)
            {
                if (lastCount != count || invalidated)
                {
                    derivedTypesCache.Clear();
                    lastCount = count;
                }
                else if (derivedTypesCache.TryGetValue(baseType, out var result3))
                {
                    return result3;
                }

                var searchTasks = new List<Task>();
                foreach (var s in searchers)
                {
                    if (s != null && s.Types == null)
                    {
                        searchTasks.Add(TapThread.StartAwaitable(s.Search));
                    }
                }

                var searcherTypes = FromType(typeof(ITypeDataSearcher)).DerivedTypes
                    .Where(x => x.CanCreateInstance)
                    .ToArray();
                if (searchers.Length != searcherTypes.Length)
                {
                    var existing = searchers.Select(GetTypeData).ToHashSet();
                    foreach (var searcherType in searcherTypes)
                    {
                        if (existing.Contains(searcherType)) continue;

                        bool error = false;
                        try
                        {
                            if (searcherType.CreateInstance(Array.Empty<object>()) is ITypeDataSearcher searcher)
                            {
                                // make sure that ITypeDataSearchers with cache invalidation are activated.
                                if (searcher is ITypeDataSearcherCacheInvalidated cacheInvalidated)
                                    cacheInvalidated.CacheInvalidated += CacheInvalidatedOnCacheInvalidated;

                                searchTasks.Add(TapThread.StartAwaitable(searcher.Search));
                                searchers = searchers.Add(searcher);
                            }
                            else error = true;
                        }
                        catch
                        {
                            error = true;
                        }

                        if (error)      
                            WarnOnce($"Failed to instantiate {nameof(ITypeDataSearcher)} {searcherType}", searcherType);
                    }
                }

                try
                {
                    Task.WaitAll(searchTasks.ToArray());
                }
                catch (Exception ex)
                {
                    Log.CreateSource("TypeData").Debug(ex);
                }

                searchers = searchers.Sort(PluginOrderAttribute.Comparer);
                var derivedTypes = new List<ITypeData>();
                foreach (var searcher in searchers)
                {
                    if (searcher is DotNetTypeDataSearcher && baseType is TypeData td)
                    {
                        // This is a performance shortcut.
                        derivedTypes.AddRange(td.DerivedTypes);
                        continue;
                    }

                    if (searcher?.Types is IEnumerable<ITypeData> types)
                    {
                        foreach (var type in types)
                        {
                            if (type.DescendsTo(baseType))
                                derivedTypes.Add(type);
                        }
                    }
                }

                var result = derivedTypes.ToArray();
                derivedTypesCache[baseType] = result;
                return result;
            }
        }

        static readonly ConditionalWeakTable<ITypeData, ITypeDataSource> typeDataSourceLookup =
            new ConditionalWeakTable<ITypeData, ITypeDataSource>();
        /// <summary>
        /// Gets the type data source for an ITypeData. For most types this will return the AssemblyData, but for types for which
        /// an ITypeDataSourceProvider exists it will return that instead. The base AssemblyData will often be associated to one
        /// of the typedatas base classes.
        /// </summary>
        /// <param name="typeData"></param>
        /// <returns></returns>
        public static ITypeDataSource GetTypeDataSource(ITypeData typeData)
        {
            if (typeDataSourceLookup.TryGetValue(typeData, out var src))
                return src;
            var typeData0 = typeData;
            lock (lockSearchers)
            {
                // if 'lock' actually caused a lock and it was that same typeData, we want to use it instead
                // of calculating it again.
                if (typeDataSourceLookup.TryGetValue(typeData, out var src2))
                    return src2;
                GetDerivedTypes<ITypeDataSearcher>(); // update cache.
                while (typeData != null)
                {
                    foreach (var searcher in searchers)
                    {
                        if (searcher is ITypeDataSourceProvider sp)
                        {
                            var source = sp.GetSource(typeData);
                            if (source != null)
                                return typeDataSourceLookup.GetValue(typeData0, td => source);
                        }
                    }
                    typeData = typeData.BaseType;
                }
            }

            return typeDataSourceLookup.GetValue(typeData0, td => null);
        }
        
        static void OnSearcherCacheInvalidated(TypeDataCacheInvalidatedEventArgs args)
        {
            lastCount = 0;
            TypeCacheInvalidated?.Invoke(null, args);
        }

        /// <summary> Get all known types that derive from a given type.</summary>
        /// <typeparam name="BaseType">Base type that all returned types descends to.</typeparam>
        /// <returns>All known types that descends to the given base type.</returns>
        public static IEnumerable<ITypeData> GetDerivedTypes<BaseType>()
        {
            return GetDerivedTypes(FromType(typeof(BaseType)));
        }

        static TypeData()
        {
            PluginManager.CacheState.Updated += (s, e) =>
            {
                foreach (var searcher in searchers.OfType<ITypeDataSearcherCacheInvalidated>())
                    searcher.CacheInvalidated -= CacheInvalidatedOnCacheInvalidated;
                searchers = searchers.Clear();
                MemberData.InvalidateCache();
                derivedTypesCache.Clear();
                typeToTypeDataCache = new ConditionalWeakTable<Type, TypeData>();
            };
        }

        static void WarnOnce(string message, ITypeData t)
        {
            if (warningLogged.Add(t))
                log.Warning(message);
        }

        static void CacheInvalidatedOnCacheInvalidated(object sender, TypeDataCacheInvalidatedEventArgs e)
        {
            OnSearcherCacheInvalidated(e);
        }

        
        /// <summary>  Creates a type data cache. Note this should be used with 'using{}' so that it gets removed afterwards. </summary>
        /// <returns> A disposable object removing the cache. </returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static IDisposable WithTypeDataCache() => new TypeDataCache();

        /// <summary> Gets the type info from a string. </summary>
        public static ITypeData GetTypeData(string name) => new TypeDataProviderStack().GetTypeData(name);

        /// <summary>
        /// This throws an exception due to the ambiguousness of TypeData.FromType vs TypeData.GetTypeData. To get TypeData representing a type use TypeData.FromType.
        /// Otherwise cast 'type' to an 'object' first.
        /// </summary>
        [Obsolete(
            "This overload of GetTypeData should not be used: To get TypeData representing a type use TypeData.FromType. Otherwise cast 'type' to an 'object' first.",
            true)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        static public ITypeData GetTypeData(Type _)
        {
            throw new NotSupportedException(
                @"Ambiguous call to GetTypeData: To get TypeData representing a type use TypeData.FromType."
                + "Otherwise cast 'type' to an 'object' first.");
        }

        /// <summary> Creates a new TypeData object to represent a dotnet type. </summary>
        public static TypeData FromType(Type type)
        {
            if (typeToTypeDataCache.TryGetValue(type, out var i))
                return i;
            TypeData td = null;
            lock (loadTypeDictLock)
            {
                var searcher = PluginManager.GetSearcher();

                searcher?.AllTypes.TryGetValue(type.FullName, out td);
                if (td == null && searcher != null)
                {
                    // This can occur for some types inside mscorlib such as System.Net.IPAddress.
                    try
                    {
                        if (type.Assembly != null && type.Assembly.IsDynamic == false &&
                            type.Assembly.Location != null)
                        {
                            searcher.AddAssembly(type.Assembly.Location, type.Assembly);
                            if (searcher.AllTypes.TryGetValue(type.FullName, out td))
                                return td;
                        }
                    }
                    catch
                    {
                    }

                    td = new TypeData(type, searcher);
                }
                else
                {
                    // This can occur when using shared projects because the same type is defined in multiple different assemblies with the same fully qualified
                    // name (namespace+typename). In this case, it is possible for the PluginSearcher to resolve an instance of this typedata from a different
                    // type than the input type to this method, which will cause all sorts of reflection errors. We detect this edge case here, and if there
                    // is a type mismatch, we instantiate a new typedata from the correct type.
                    if (td == null || td.Type != type)
                    {
                        td = new TypeData(type, searcher);
                    }
                }
            }

            return typeToTypeDataCache.GetValue(type, x => td);
        }


        class TypeDataCache : IDisposable
        {
            static ThreadField<IDictionary<object, ITypeData>> cache =
                new ThreadField<IDictionary<object, ITypeData>>();

            public static IDictionary<object, ITypeData> Current => cache.Value;

            ICacheOptimizer[] caches;

            public TypeDataCache()
            {
                var types = GetDerivedTypes<ICacheOptimizer>().Where(x => x.CanCreateInstance)
                    .Select(x => x.AsTypeData().Type).ToArray();
                caches = types.Select(t => t.CreateInstance()).OfType<ICacheOptimizer>().ToArray();
                foreach (var type in caches)
                    type.LoadCache();
                cache.Value = new ConcurrentDictionary<object, ITypeData>();
            }
            
            public void Dispose()
            {
                cache.Value = null;
                foreach (var cache in caches)
                    cache.UnloadCache();
            }
        }
    }
}