// 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.Collections.Generic;
using System.IO;
using ILLink.Shared;
 
namespace Mono.Linker.Steps
{
	public class ProcessReferencesStep : BaseStep
	{
		protected override void Process ()
		{
			// Walk over all -reference inputs and resolve any that may need to be rooted.
 
			// For example:
			// -reference dir/Unreferenced.dll --action copy --trim-mode copyused
			//     In this case we need to check whether Unreferenced has the
			//     IsTrimmable attribute, and root it if not.
			// -reference dir/Unreferenced.dll --action copy --trim-mode copyused --action link Unreferenced
			//     The per-assembly action wins over the default --action or --trim-mode,
			//     so we don't need to load the assembly to check for IsTrimmable attribute.
			// -reference dir/Unreferenced.dll --action link --trim-mode link
			//     In this case, we don't need to load the assembly up-front, because it will
			//     not get the copy/save action, regardless of the IsTrimmable attribute.
 
			// Note that we don't do the same for assemblies which may be resolved from input directories - such
			// assemblies will only be rooted if something loads them.
			foreach (var assemblyPath in GetInputAssemblyPaths ()) {
				var assemblyName = Path.GetFileNameWithoutExtension (assemblyPath);
 
				// If there's no way that this reference could have the copy/save action,
				// we don't need to load it up-front.
				if (!MaybeIsFullyPreservedAssembly (assemblyName))
					continue;
 
				// For the remaining references, we need to resolve them (which looks for IsTrimmable attribute)
				// to determine the action.
				var assembly = Context.TryResolve (assemblyName);
				if (assembly == null) {
					Context.LogError (null, DiagnosticId.ReferenceAssemblyCouldNotBeLoaded, assemblyPath);
					continue;
				}
 
				// If the assigned action (now taking into account the IsTrimmable attribute) requires us
				// to root the assembly, do so.
				if (IsFullyPreservedAction (Annotations.GetAction (assembly)))
					Annotations.Mark (assembly.MainModule, new DependencyInfo (DependencyKind.AssemblyAction, assembly), new MessageOrigin (assembly));
			}
		}
 
		IEnumerable<string> GetInputAssemblyPaths ()
		{
			var assemblies = new HashSet<string> ();
			foreach (var referencePath in Context.Resolver.GetReferencePaths ()) {
				var assemblyName = Path.GetFileNameWithoutExtension (referencePath);
				if (assemblies.Add (assemblyName))
					yield return referencePath;
			}
		}
 
		public static bool IsFullyPreservedAction (AssemblyAction action)
		{
			return action == AssemblyAction.Copy || action == AssemblyAction.Save;
		}
 
		bool MaybeIsFullyPreservedAssembly (string assemblyName)
		{
			if (Context.Actions.TryGetValue (assemblyName, out AssemblyAction action))
				return IsFullyPreservedAction (action);
 
			return IsFullyPreservedAction (Context.DefaultAction) || IsFullyPreservedAction (Context.TrimAction);
		}
	}
}