// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using ILLink.Shared;
using ILLink.Shared.TrimAnalysis;
using Mono.Cecil;
 
using TypeName = System.Reflection.Metadata.TypeName;
 
namespace Mono.Linker
{
    internal sealed partial class TypeNameResolver
    {
        public bool TryResolveTypeName(
            string typeNameString,
            in DiagnosticContext diagnosticContext,
            [NotNullWhen(true)] out TypeReference? typeReference,
            [NotNullWhen(true)] out List<TypeResolutionRecord>? typeResolutionRecords,
            bool needsAssemblyName)
        {
            typeReference = null;
            typeResolutionRecords = null;
            if (string.IsNullOrEmpty(typeNameString))
                return false;
 
            if (!TypeName.TryParse(typeNameString, out TypeName? parsedTypeName, s_typeNameParseOptions))
                return false;
 
            if (needsAssemblyName && !IsFullyQualified(parsedTypeName))
            {
                diagnosticContext.AddDiagnostic(DiagnosticId.TypeNameIsNotAssemblyQualified, typeNameString);
                return false;
            }
 
            // If parsedTypeName doesn't have an assembly name in it but it does have a namespace,
            // search for the type in the calling object's assembly. If not found, look in the core
            // assembly.
            ICustomAttributeProvider? provider = diagnosticContext.Origin.Provider;
            AssemblyDefinition? referencingAssembly = provider switch
            {
                AssemblyDefinition asm => asm,
                TypeDefinition type => type.Module?.Assembly,
                IMemberDefinition member => member.DeclaringType.Module.Assembly,
                null => null,
                _ => throw new NotSupportedException()
            };
 
            if (referencingAssembly is null)
                return false;
 
            typeResolutionRecords = new List<TypeResolutionRecord>();
            typeReference = ResolveTypeName(referencingAssembly, parsedTypeName, typeResolutionRecords);
            return typeReference != null;
 
            static bool IsFullyQualified(TypeName typeName)
            {
                if (typeName.AssemblyName is null)
                    return false;
 
                if (typeName.IsArray || typeName.IsPointer || typeName.IsByRef)
                    return IsFullyQualified(typeName.GetElementType());
 
                if (typeName.IsConstructedGenericType)
                {
                    foreach (var typeArgument in typeName.GetGenericArguments())
                    {
                        if (!IsFullyQualified(typeArgument))
                            return false;
                    }
                }
 
                return true;
            }
        }
    }
}