// 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.Diagnostics;
using Mono.Cecil;
 
 
namespace Mono.Linker
{
	/// <summary>
	/// Class which implements IDependencyRecorder and writes the dependencies into an DGML file.
	/// </summary>
	public class DependencyRecorderHelper
	{
		static bool IsAssemblyBound (TypeDefinition td)
		{
			do {
				if (td.IsNestedPrivate || td.IsNestedAssembly || td.IsNestedFamilyAndAssembly)
					return true;
 
				td = td.DeclaringType;
			} while (td != null);
 
			return false;
		}
 
		public static string TokenString (LinkContext context, object? o)
		{
			if (o == null)
				return "N:null";
 
			if (o is TypeReference t) {
				bool addAssembly = true;
				var td = context.TryResolve (t);
 
				if (td != null) {
					addAssembly = td.IsNotPublic || IsAssemblyBound (td);
					t = td;
				}
 
				var addition = addAssembly ? $":{t.Module}" : "";
 
				return $"{((IMetadataTokenProvider) o).MetadataToken.TokenType}:{o}{addition}";
			}
 
			if (o is IMetadataTokenProvider provider)
				return provider.MetadataToken.TokenType + ":" + o;
 
			return "Other:" + o;
		}
 
		static bool ShouldRecordAssembly (LinkContext context, AssemblyDefinition assembly)
		{
			Debug.Assert (context.EnableReducedTracing || context.TraceAssembly != null);
 
			if (context.TraceAssembly != null && !context.TraceAssembly.Contains (assembly.Name.Name))
				return false; // We were asked to only trace a specific set of assemblies and this is not one of them
 
			// We were either asked to trace in general, or to trace this assembly in particular.
 
			// Note: with reduced tracing, we may still not trace an assembly if it's not linked.
			if (context.EnableReducedTracing) {
				switch (context.Annotations.GetAction (assembly)) {
				case AssemblyAction.Link:
				case AssemblyAction.AddBypassNGen:
				case AssemblyAction.AddBypassNGenUsed:
					return true;
				default:
					return false;
				}
			}
 
			return true;
		}
 
		public static bool ShouldRecord (LinkContext context, object? source, object target)
		{
			if (source == null || target == null)
				return false;
 
			// We use a few hacks to work around MarkStep outputting thousands of edges even
			// with the above ShouldRecord checks. Ideally we would format these into a meaningful format
			// however I don't think that is worth the effort at the moment.
 
			// Prevent useless logging of attributes like `e="Other:Mono.Cecil.CustomAttribute"`.
			if (source is CustomAttribute || target is CustomAttribute)
				return false;
 
			// Prevent useless logging of interface implementations like `e="InterfaceImpl:Mono.Cecil.InterfaceImplementation"`.
			if (source is InterfaceImplementation || target is InterfaceImplementation)
				return false;
 
			if (!ShouldRecord (context, source) && !ShouldRecord (context, target)) {
				return false;
			}
			return true;
		}
 
		public static bool ShouldRecord (LinkContext context, object? o)
		{
			// If tracing a specific set of assemblies (TraceAssembly != null),
			// this takes precedence over the EnableReducedTracing setting.
			if (!context.EnableReducedTracing && context.TraceAssembly == null)
				return true;
 
			if (o is TypeDefinition t)
				return ShouldRecordAssembly (context, t.Module.Assembly);
 
			if (o is IMemberDefinition m)
				return ShouldRecordAssembly (context, m.DeclaringType.Module.Assembly);
 
			if (o is TypeReference typeRef) {
				var resolved = context.TryResolve (typeRef);
 
				// Err on the side of caution if we can't resolve
				if (resolved == null)
					return true;
 
				return ShouldRecordAssembly (context, resolved.Module.Assembly);
			}
 
			if (o is MemberReference mRef) {
				var resolved = mRef.Resolve ();
 
				// Err on the side of caution if we can't resolve
				if (resolved == null)
					return true;
 
				return ShouldRecordAssembly (context, resolved.DeclaringType.Module.Assembly);
			}
 
			if (o is ModuleDefinition module)
				return ShouldRecordAssembly (context, module.Assembly);
 
			if (o is AssemblyDefinition assembly)
				return ShouldRecordAssembly (context, assembly);
 
			if (o is ParameterDefinition parameter) {
				if (parameter.Method is MethodDefinition parameterMethodDefinition)
					return ShouldRecordAssembly (context, parameterMethodDefinition.DeclaringType.Module.Assembly);
			}
 
			return true;
		}
	}
}