using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.CSharp.Symbols;

internal abstract class NonMissingAssemblySymbol : AssemblySymbol
{
	private readonly ConcurrentDictionary<Key, NamedTypeSymbol> _emittedNameToTypeMap = new ConcurrentDictionary<Key, NamedTypeSymbol>();

	private NamespaceSymbol? _globalNamespace;

	internal sealed override bool IsMissing => false;

	public sealed override NamespaceSymbol GlobalNamespace
	{
		get
		{
			if ((object)_globalNamespace == null)
			{
				IEnumerable<NamespaceSymbol> enumerable = Modules.Select((ModuleSymbol m) => m.GlobalNamespace);
				NamespaceSymbol value = MergedNamespaceSymbol.Create(new NamespaceExtent(this), null, ImmutableArrayExtensions.AsImmutable<NamespaceSymbol>(enumerable));
				Interlocked.CompareExchange(ref _globalNamespace, value, null);
			}
			return _globalNamespace;
		}
	}

	internal int EmittedNameToTypeMapCount => _emittedNameToTypeMap.Count;

	internal sealed override NamedTypeSymbol? LookupDeclaredTopLevelMetadataType(ref MetadataTypeName emittedName)
	{
		NamedTypeSymbol namedTypeSymbol = null;
		namedTypeSymbol = LookupTopLevelMetadataTypeInCache(ref emittedName);
		if ((object)namedTypeSymbol != null)
		{
			if (!namedTypeSymbol.IsErrorType() && (object)namedTypeSymbol.ContainingAssembly == this)
			{
				return namedTypeSymbol;
			}
			return null;
		}
		namedTypeSymbol = LookupDeclaredTopLevelMetadataTypeInModules(ref emittedName);
		if ((object)namedTypeSymbol == null)
		{
			return null;
		}
		return CacheTopLevelMetadataType(ref emittedName, namedTypeSymbol);
	}

	private NamedTypeSymbol? LookupDeclaredTopLevelMetadataTypeInModules(ref MetadataTypeName emittedName)
	{
		ImmutableArray<ModuleSymbol>.Enumerator enumerator = Modules.GetEnumerator();
		while (enumerator.MoveNext())
		{
			NamedTypeSymbol namedTypeSymbol = enumerator.Current.LookupTopLevelMetadataType(ref emittedName);
			if ((object)namedTypeSymbol != null)
			{
				return namedTypeSymbol;
			}
		}
		return null;
	}

	internal sealed override NamedTypeSymbol LookupDeclaredOrForwardedTopLevelMetadataType(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies)
	{
		NamedTypeSymbol namedTypeSymbol = LookupTopLevelMetadataTypeInCache(ref emittedName);
		if ((object)namedTypeSymbol != null)
		{
			return namedTypeSymbol;
		}
		namedTypeSymbol = LookupDeclaredTopLevelMetadataTypeInModules(ref emittedName);
		if ((object)namedTypeSymbol == null)
		{
			namedTypeSymbol = TryLookupForwardedMetadataTypeWithCycleDetection(ref emittedName, visitedAssemblies);
		}
		return CacheTopLevelMetadataType(ref emittedName, namedTypeSymbol ?? new MissingMetadataTypeSymbol.TopLevel(Modules[0], ref emittedName));
	}

	internal abstract override NamedTypeSymbol? TryLookupForwardedMetadataTypeWithCycleDetection(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies);

	private NamedTypeSymbol? LookupTopLevelMetadataTypeInCache(ref MetadataTypeName emittedName)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		if (_emittedNameToTypeMap.TryGetValue(((MetadataTypeName)(ref emittedName)).ToKey(), out NamedTypeSymbol value))
		{
			return value;
		}
		return null;
	}

	internal NamedTypeSymbol CachedTypeByEmittedName(string emittedname)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		MetadataTypeName val = MetadataTypeName.FromFullName(emittedname, false, -1);
		return _emittedNameToTypeMap[((MetadataTypeName)(ref val)).ToKey()];
	}

	private NamedTypeSymbol CacheTopLevelMetadataType(ref MetadataTypeName emittedName, NamedTypeSymbol result)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		return _emittedNameToTypeMap.GetOrAdd(((MetadataTypeName)(ref emittedName)).ToKey(), result);
	}
}