// 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.Diagnostics.CodeAnalysis;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;
 
namespace Mono.Linker
{
	public static class MethodBodyScanner
	{
		public static bool IsWorthConvertingToThrow (MethodIL body)
		{
			// Some bodies are cheaper size wise to leave alone than to convert to a throw
			Instruction? previousMeaningful = null;
			int meaningfulCount = 0;
			foreach (var ins in body.Instructions) {
				// Handle ignoring noops because (1) it's a valid case to ignore
				// and (2) When running the tests on .net core roslyn tosses in no ops
				// and that leads to a difference in test results between mcs and .net framework csc.
				if (ins.OpCode.Code == Code.Nop)
					continue;
 
				meaningfulCount++;
 
				if (meaningfulCount == 1 && ins.OpCode.Code == Code.Ret)
					return false;
 
				if (meaningfulCount == 2 && ins.OpCode.Code == Code.Ret && previousMeaningful != null) {
					if (previousMeaningful.OpCode.StackBehaviourPop == StackBehaviour.Pop0) {
						switch (previousMeaningful.OpCode.StackBehaviourPush) {
						case StackBehaviour.Pushi:
						case StackBehaviour.Pushi8:
						case StackBehaviour.Pushr4:
						case StackBehaviour.Pushr8:
							return false;
						}
 
						switch (previousMeaningful.OpCode.Code) {
						case Code.Ldnull:
							return false;
						}
					}
				}
 
				if (meaningfulCount >= 2)
					return true;
 
				previousMeaningful = ins;
			}
 
			return true;
		}
	}
	readonly struct InterfacesOnStackScanner
	{
		readonly LinkContext context;
 
		public InterfacesOnStackScanner (LinkContext context)
		{
			this.context = context;
		}
 
		public IEnumerable<(InterfaceImplementation, TypeDefinition)>? GetReferencedInterfaces (MethodIL methodIL)
		{
			var possibleStackTypes = AllPossibleStackTypes (methodIL);
			if (possibleStackTypes.Count == 0)
				return null;
 
			var interfaceTypes = possibleStackTypes.Where (t => t.IsInterface).ToArray ();
			if (interfaceTypes.Length == 0)
				return null;
 
			var interfaceImplementations = new HashSet<(InterfaceImplementation, TypeDefinition)> ();
 
			// If a type could be on the stack in the body and an interface it implements could be on the stack on the body
			// then we need to mark that interface implementation.  When this occurs it is not safe to remove the interface implementation from the type
			// even if the type is never instantiated
			foreach (var type in possibleStackTypes) {
				// We only sweep interfaces on classes so that's why we only care about classes
				if (!type.IsClass)
					continue;
 
				TypeDefinition? currentType = type;
				while (currentType?.BaseType != null) // Checking BaseType != null to skip System.Object
				{
					AddMatchingInterfaces (interfaceImplementations, currentType, interfaceTypes);
					currentType = context.TryResolve (currentType.BaseType);
				}
			}
 
			return interfaceImplementations;
		}
 
		HashSet<TypeDefinition> AllPossibleStackTypes (MethodIL methodIL)
		{
			var types = new HashSet<TypeDefinition> ();
 
			foreach (VariableDefinition var in methodIL.Variables)
				AddIfResolved (types, var.VariableType);
 
			foreach (var param in methodIL.Method.GetParameters ())
				AddIfResolved (types, param.ParameterType);
 
			foreach (ExceptionHandler eh in methodIL.ExceptionHandlers) {
				if (eh.HandlerType == ExceptionHandlerType.Catch) {
					AddIfResolved (types, eh.CatchType);
				}
			}
 
			foreach (Instruction instruction in methodIL.Instructions) {
				if (instruction.Operand is FieldReference fieldReference) {
					if (context.TryResolve (fieldReference)?.FieldType is TypeReference fieldType)
						AddIfResolved (types, fieldType);
				} else if (instruction.Operand is MethodReference methodReference) {
					if (methodReference is GenericInstanceMethod genericInstanceMethod)
						AddFromGenericInstance (types, genericInstanceMethod);
 
					if (methodReference.DeclaringType is GenericInstanceType genericInstanceType)
						AddFromGenericInstance (types, genericInstanceType);
 
					var resolvedMethod = context.TryResolve (methodReference);
					if (resolvedMethod != null) {
						if (resolvedMethod.HasMetadataParameters ()) {
							foreach (var param in resolvedMethod.GetParameters ())
								AddIfResolved (types, param.ParameterType);
						}
 
						AddFromGenericParameterProvider (types, resolvedMethod);
						AddFromGenericParameterProvider (types, resolvedMethod.DeclaringType);
						AddIfResolved (types, resolvedMethod.ReturnType);
					}
				}
			}
 
 
			return types;
		}
 
		void AddMatchingInterfaces (HashSet<(InterfaceImplementation, TypeDefinition)> results, TypeDefinition type, TypeDefinition[] interfaceTypes)
		{
			if (!type.HasInterfaces)
				return;
 
			foreach (var interfaceType in interfaceTypes) {
				if (HasInterface (type, interfaceType, out InterfaceImplementation? implementation))
					results.Add ((implementation, type));
			}
		}
 
		bool HasInterface (TypeDefinition type, TypeDefinition interfaceType, [NotNullWhen (true)] out InterfaceImplementation? implementation)
		{
			implementation = null;
			if (!type.HasInterfaces)
				return false;
 
			foreach (var iface in type.Interfaces) {
				if (context.TryResolve (iface.InterfaceType) == interfaceType) {
					implementation = iface;
					return true;
				}
			}
 
			return false;
		}
 
		void AddFromGenericInstance (HashSet<TypeDefinition> set, IGenericInstance instance)
		{
			if (!instance.HasGenericArguments)
				return;
 
			foreach (var genericArgument in instance.GenericArguments)
				AddIfResolved (set, genericArgument);
		}
 
		void AddFromGenericParameterProvider (HashSet<TypeDefinition> set, IGenericParameterProvider provider)
		{
			if (!provider.HasGenericParameters)
				return;
 
			foreach (var genericParameter in provider.GenericParameters) {
				foreach (var constraint in genericParameter.Constraints)
					AddIfResolved (set, constraint.ConstraintType);
			}
		}
 
		void AddIfResolved (HashSet<TypeDefinition> set, TypeReference item)
		{
			var resolved = context.TryResolve (item);
			if (resolved == null)
				return;
 
			set.Add (resolved);
		}
	}
}