// 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.Diagnostics.CodeAnalysis;
using ILLink.Shared;
using Mono.Cecil;
 
namespace Mono.Linker
{
	/// Tracks dependencies created via DynamicDependencyAttribute in trimming.
	/// This is almost identical to DynamicDependencyAttribute, but it holds a
	/// TypeReference instead of a Type, and it has a reference to the original
	/// CustomAttribute for dependency tracing. It is also a place for helper
	/// methods related to the attribute.
	[System.AttributeUsage (System.AttributeTargets.Constructor | System.AttributeTargets.Field | System.AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
	internal sealed class DynamicDependency : Attribute
	{
		public CustomAttribute? OriginalAttribute { get; private set; }
		public DynamicDependency (string memberSignature)
		{
			MemberSignature = memberSignature;
		}
 
		public DynamicDependency (string memberSignature, TypeReference type)
		{
			MemberSignature = memberSignature;
			Type = type;
		}
 
		public DynamicDependency (string memberSignature, string typeName, string assemblyName)
		{
			MemberSignature = memberSignature;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}
 
		public DynamicDependency (DynamicallyAccessedMemberTypes memberTypes, TypeReference type)
		{
			MemberTypes = memberTypes;
			Type = type;
		}
 
		public DynamicDependency (DynamicallyAccessedMemberTypes memberTypes, string typeName, string assemblyName)
		{
			MemberTypes = memberTypes;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}
 
		public string? MemberSignature { get; }
 
		public DynamicallyAccessedMemberTypes MemberTypes { get; }
 
		public TypeReference? Type { get; }
 
		public string? TypeName { get; }
 
		public string? AssemblyName { get; }
 
		public string? Condition { get; set; }
 
		public static DynamicDependency? ProcessAttribute (LinkContext context, ICustomAttributeProvider provider, CustomAttribute customAttribute)
		{
			if (!(provider is IMemberDefinition member))
				return null;
 
			if (!(member is MethodDefinition || member is FieldDefinition))
				return null;
 
			// Don't honor the Condition until we have figured out the behavior for DynamicDependencyAttribute:
			// https://github.com/dotnet/linker/issues/1231
			// if (!ShouldProcess (context, customAttribute))
			//   return null;
 
			var dynamicDependency = GetDynamicDependency (customAttribute);
			if (dynamicDependency != null)
				return dynamicDependency;
 
			context.LogWarning (member, DiagnosticId.DynamicDependencyAttributeCouldNotBeAnalyzed);
			return null;
		}
 
		static DynamicDependency? GetDynamicDependency (CustomAttribute ca)
		{
			var args = ca.ConstructorArguments;
			if (args.Count < 1 || args.Count > 3)
				return null;
 
			DynamicDependency? result = args[0].Value switch {
				string stringMemberSignature => args.Count switch {
					1 => new DynamicDependency (stringMemberSignature),
					2 when args[1].Value is TypeReference type => new DynamicDependency (stringMemberSignature, type),
					3 when args[1].Value is string typeName && args[2].Value is string assemblyName => new DynamicDependency (stringMemberSignature, typeName, assemblyName),
					_ => null,
				},
				int memberTypes => args.Count switch {
					2 when args[1].Value is TypeReference type => new DynamicDependency ((DynamicallyAccessedMemberTypes) memberTypes, type),
					3 when args[1].Value is string typeName && args[2].Value is string assemblyName => new DynamicDependency ((DynamicallyAccessedMemberTypes) memberTypes, typeName, assemblyName),
					_ => null,
				},
				_ => null,
			};
 
			if (result != null)
				result.OriginalAttribute = ca;
 
			return result;
		}
 
		public static bool ShouldProcess (LinkContext context, CustomAttribute ca)
		{
			if (ca.HasProperties && ca.Properties[0].Name == "Condition") {
				var condition = ca.Properties[0].Argument.Value as string;
				switch (condition) {
				case "":
				case null:
					return true;
				case "DEBUG":
					if (!context.KeepMembersForDebugger)
						return false;
 
					break;
				default:
					// Don't have yet a way to match the general condition so everything is excluded
					return false;
				}
			}
			return true;
		}
	}
}