// 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 System.Reflection;
using ILLink.Shared.TrimAnalysis;
using Mono.Cecil;
using Mono.Linker.Steps;
 
namespace Mono.Linker.Dataflow
{
	public readonly struct ReflectionMarker
	{
		readonly LinkContext _context;
		readonly MarkStep _markStep;
		readonly bool _enabled;
 
		public ReflectionMarker (LinkContext context, MarkStep markStep, bool enabled)
		{
			_context = context;
			_markStep = markStep;
			_enabled = enabled;
		}
 
		internal void MarkTypeForDynamicallyAccessedMembers (in MessageOrigin origin, TypeReference type, DynamicallyAccessedMemberTypes requiredMemberTypes, DependencyKind dependencyKind, bool declaredOnly = false)
		{
			if (!_enabled)
				return;
 
			if (type.ResolveToTypeDefinition (_context) is not TypeDefinition typeDefinition)
				return;
 
			foreach (var member in typeDefinition.GetDynamicallyAccessedMembers (_context, requiredMemberTypes, declaredOnly)) {
				switch (member) {
				case MethodDefinition method:
					MarkMethod (origin, method, dependencyKind);
					break;
				case FieldDefinition field:
					MarkField (origin, field, dependencyKind);
					break;
				case TypeDefinition nestedType:
					MarkType (origin, nestedType, dependencyKind);
					break;
				case PropertyDefinition property:
					MarkProperty (origin, property, dependencyKind);
					break;
				case EventDefinition @event:
					MarkEvent (origin, @event, dependencyKind);
					break;
				case InterfaceImplementation interfaceImplementation:
					MarkInterfaceImplementation (origin, interfaceImplementation, dependencyKind);
					break;
				}
			}
		}
 
		// Resolve a (potentially assembly qualified) type name based on the current context (taken from DiagnosticContext) and mark the type for reflection.
		// This method will probe the current context assembly and if that fails CoreLib for the specified type. Emulates behavior of Type.GetType.
		internal bool TryResolveTypeNameAndMark (string typeName, in DiagnosticContext diagnosticContext, bool needsAssemblyName, [NotNullWhen (true)] out TypeReference? type)
		{
			if (!_context.TypeNameResolver.TryResolveTypeName (typeName, diagnosticContext, out type, out var typeResolutionRecords, needsAssemblyName)) {
				type = default;
				return false;
			}
 
			MarkType (diagnosticContext, type, typeResolutionRecords);
			return true;
		}
 
		// Resolve a type from the specified assembly and mark it for reflection.
		internal bool TryResolveTypeNameAndMark (AssemblyDefinition assembly, string typeName, in DiagnosticContext diagnosticContext, [NotNullWhen (true)] out TypeReference? type)
		{
			if (!_context.TypeNameResolver.TryResolveTypeName (assembly, typeName, out type, out var typeResolutionRecords)) {
				type = default;
				return false;
			}
 
			MarkType (diagnosticContext, type, typeResolutionRecords);
			return true;
		}
 
		void MarkType (
			in DiagnosticContext diagnosticContext,
			TypeReference typeReference,
			List<TypeNameResolver.TypeResolutionRecord> typeResolutionRecords)
		{
			if (_enabled) {
				// Mark the resolved type for reflection access, but also go over all types which were resolved in the process
				// of resolving the outer type (typically generic arguments) and make sure we mark all type forwarders
				// used for that resolution.
				// This is necessary because if the app's code contains the input string as literal (which is pretty much always the case)
				// that string has to work at runtime, and if it relies on type forwarders we need to preserve those as well.
				var origin = diagnosticContext.Origin;
				_markStep.MarkTypeVisibleToReflection (typeReference, new DependencyInfo (DependencyKind.AccessedViaReflection, origin.Provider), origin);
				foreach (var typeResolutionRecord in typeResolutionRecords) {
					_context.MarkingHelpers.MarkMatchingExportedType (typeResolutionRecord.ResolvedType, typeResolutionRecord.ReferringAssembly, new DependencyInfo (DependencyKind.DynamicallyAccessedMember, typeReference), origin);
				}
			}
		}
 
		internal void MarkType (in MessageOrigin origin, TypeReference typeRef, DependencyKind dependencyKind = DependencyKind.AccessedViaReflection)
		{
			if (!_enabled)
				return;
 
			if (typeRef.ResolveToTypeDefinition (_context) is not TypeDefinition type)
				return;
 
			_markStep.MarkTypeVisibleToReflection (type, new DependencyInfo (dependencyKind, origin.Provider), origin);
		}
 
		internal void MarkMethod (in MessageOrigin origin, MethodReference methodRef, DependencyKind dependencyKind = DependencyKind.AccessedViaReflection)
		{
			if (!_enabled)
				return;
 
			if (_context.TryResolve (methodRef) is not MethodDefinition method)
				return;
 
			_markStep.MarkMethodVisibleToReflection (method, new DependencyInfo (dependencyKind, origin.Provider), origin);
		}
 
		void MarkField (in MessageOrigin origin, FieldDefinition field, DependencyKind dependencyKind = DependencyKind.AccessedViaReflection)
		{
			if (!_enabled)
				return;
 
			_markStep.MarkFieldVisibleToReflection (field, new DependencyInfo (dependencyKind, origin.Provider), origin);
		}
 
		internal void MarkProperty (in MessageOrigin origin, PropertyDefinition property, DependencyKind dependencyKind = DependencyKind.AccessedViaReflection)
		{
			if (!_enabled)
				return;
 
			_markStep.MarkPropertyVisibleToReflection (property, new DependencyInfo (dependencyKind, origin.Provider), origin);
		}
 
		void MarkEvent (in MessageOrigin origin, EventDefinition @event, DependencyKind dependencyKind = DependencyKind.AccessedViaReflection)
		{
			if (!_enabled)
				return;
 
			_markStep.MarkEventVisibleToReflection (@event, new DependencyInfo (dependencyKind, origin.Provider), origin);
		}
 
		void MarkInterfaceImplementation (in MessageOrigin origin, InterfaceImplementation interfaceImplementation, DependencyKind dependencyKind = DependencyKind.AccessedViaReflection)
		{
			if (!_enabled)
				return;
 
			_markStep.MarkInterfaceImplementation (interfaceImplementation, origin, new DependencyInfo (dependencyKind, origin.Provider));
		}
 
		internal void MarkConstructorsOnType (in MessageOrigin origin, TypeReference typeRef, Func<MethodDefinition, bool>? filter, BindingFlags? bindingFlags = null)
		{
			if (!_enabled)
				return;
 
			if (typeRef.ResolveToTypeDefinition (_context) is not TypeDefinition type)
				return;
 
			foreach (var ctor in type.GetConstructorsOnType (filter, bindingFlags))
				MarkMethod (origin, ctor);
		}
 
		internal void MarkFieldsOnTypeHierarchy (in MessageOrigin origin, TypeReference typeRef, Func<FieldDefinition, bool> filter, BindingFlags? bindingFlags = BindingFlags.Default)
		{
			if (!_enabled)
				return;
 
			if (typeRef.ResolveToTypeDefinition (_context) is not TypeDefinition type)
				return;
 
			foreach (var field in type.GetFieldsOnTypeHierarchy (_context, filter, bindingFlags))
				MarkField (origin, field);
		}
 
		internal void MarkPropertiesOnTypeHierarchy (in MessageOrigin origin, TypeReference typeRef, Func<PropertyDefinition, bool> filter, BindingFlags? bindingFlags = BindingFlags.Default)
		{
			if (!_enabled)
				return;
 
			if (typeRef.ResolveToTypeDefinition (_context) is not TypeDefinition type)
				return;
 
			foreach (var property in type.GetPropertiesOnTypeHierarchy (_context, filter, bindingFlags))
				MarkProperty (origin, property);
		}
 
		internal void MarkEventsOnTypeHierarchy (in MessageOrigin origin, TypeReference typeRef, Func<EventDefinition, bool> filter, BindingFlags? bindingFlags = BindingFlags.Default)
		{
			if (!_enabled)
				return;
 
			if (typeRef.ResolveToTypeDefinition (_context) is not TypeDefinition type)
				return;
 
			foreach (var @event in type.GetEventsOnTypeHierarchy (_context, filter, bindingFlags))
				MarkEvent (origin, @event);
		}
 
		internal void MarkStaticConstructor (in MessageOrigin origin, TypeReference typeRef)
		{
			if (!_enabled)
				return;
 
			if (typeRef.ResolveToTypeDefinition (_context) is not TypeDefinition type)
				return;
 
			_markStep.MarkStaticConstructorVisibleToReflection (type, new DependencyInfo (DependencyKind.AccessedViaReflection, origin.Provider), origin);
		}
	}
}