// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Collections.Concurrent;
using System.Diagnostics;
using System.IO;
using System.Reflection.TypeLoading;
 
namespace System.Reflection
{
    public sealed partial class MetadataLoadContext
    {
        //
        // List of ref AssemblyNames to successfully bound assemblies. This is not the same as _loadedAssemblies.
        // _loadedAssemblies keeps track of canonical Assembly instances.
        //
        // _binds keeps the resolve event from being called to resolve the same refName over and over again.
        // If the resolve logic allows variations on the ref name, it is possible and common for the same assembly instance
        // to appear multiple times (once for each variation that was used to bind to it.)
        //
        // We also latch failures. That is, _binds can bind a RuntimeAssemblyName to a RoFailedBindAssembly.
        //
        private readonly ConcurrentDictionary<RoAssemblyName, RoAssembly> _binds = new ConcurrentDictionary<RoAssemblyName, RoAssembly>();
 
        internal RoAssembly ResolveAssembly(RoAssemblyName refName)
        {
            Debug.Assert(refName != null);
 
            RoAssembly? assembly = TryResolveAssembly(refName, out Exception? e);
            return assembly ?? throw e!;
        }
 
        internal RoAssembly? TryResolveAssembly(RoAssemblyName refName, out Exception? e)
        {
            e = null;
 
            RoAssembly result = ResolveToAssemblyOrExceptionAssembly(refName);
            if (result is RoExceptionAssembly exceptionAssembly)
            {
                e = exceptionAssembly.Exception;
                return null;
            }
            return result;
        }
 
        internal RoAssembly ResolveToAssemblyOrExceptionAssembly(RoAssemblyName refName)
        {
            Debug.Assert(refName != null);
 
            if (_binds.TryGetValue(refName, out RoAssembly? prior))
                return prior;
 
            RoAssembly assembly = TryFindAssemblyByCallingResolveHandler(refName);
            return _binds.GetOrAdd(refName, assembly);
        }
 
        private RoAssembly TryFindAssemblyByCallingResolveHandler(RoAssemblyName refName)
        {
            Debug.Assert(refName != null);
 
            Assembly? assembly = resolver?.Resolve(this, refName.ToAssemblyName());
 
            if (assembly == null)
                return new RoExceptionAssembly(new FileNotFoundException(SR.Format(SR.FileNotFoundAssembly, refName.FullName)));
 
            if (!(assembly is RoAssembly roAssembly && roAssembly.Loader == this))
                throw new FileLoadException(SR.ExternalAssemblyReturnedByMetadataAssemblyResolver);
 
            return roAssembly;
        }
    }
}