// 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.Immutable;
using System.Diagnostics.CodeAnalysis;
using Mono.Cecil;
using Mono.Linker;
 
namespace ILLink.Shared.TypeSystemProxy
{
    internal readonly partial struct MethodProxy : IEquatable<MethodProxy>
    {
        public static bool TryCreate(MethodReference method, ITryResolveMetadata resolver, [NotNullWhen(true)] out MethodProxy? methodProxy)
        {
            if (resolver.TryResolve(method) is not MethodDefinition methodDef)
            {
                methodProxy = null;
                return false;
            }
 
            methodProxy = new MethodProxy(method, methodDef);
            return true;
        }
 
        private MethodProxy(MethodReference method, MethodDefinition methodDef)
        {
            Method = method;
            Definition = methodDef;
        }
 
        public static implicit operator MethodProxy(MethodDefinition method) => new(method, method);
 
        public readonly MethodReference Method;
 
        internal MethodDefinition Definition { get; }
 
        public string Name { get => Method.Name; }
 
        public string GetDisplayName() => Method.GetDisplayName();
 
        internal partial bool IsDeclaredOnType(string fullTypeName) => Method.IsDeclaredOnType(fullTypeName);
 
        internal partial bool HasMetadataParameters() => Definition.HasMetadataParameters();
 
        /// <summary>
        /// Gets the number of entries in the 'Parameters' section of a method's metadata (i.e. excludes the implicit 'this' from the count)
        /// </summary>
        internal partial int GetMetadataParametersCount() => Definition.GetMetadataParametersCount();
 
        /// <summary>
        /// Returns the number of parameters that are passed to the method in IL (including the implicit 'this' parameter).
        /// In pseudocode: <code>method.HasImplicitThis() ? 1 + MetadataParametersCount : MetadataParametersCount;</code>
        /// </summary>
        internal partial int GetParametersCount() => Definition.GetParametersCount();
 
        /// <summary>
        /// Use only when iterating over all parameters. When wanting to index, use GetParameters(ParameterIndex)
        /// </summary>
        internal partial ParameterProxyEnumerable GetParameters()
        {
            return new ParameterProxyEnumerable(0, Definition.GetParametersCount(), this);
        }
 
        internal partial ParameterProxy GetParameter(ParameterIndex index) => Definition.GetParameter(index);
 
        internal partial bool HasGenericParameters() => Method.HasGenericParameters;
 
        internal partial bool HasGenericArgumentsCount(int genericArgumentCount) => Method is GenericInstanceMethod generic && generic.GenericArguments.Count == genericArgumentCount;
 
        internal partial ImmutableArray<GenericParameterProxy> GetGenericParameters()
        {
            if (!Method.HasGenericParameters)
                return ImmutableArray<GenericParameterProxy>.Empty;
 
            var builder = ImmutableArray.CreateBuilder<GenericParameterProxy>(Method.GenericParameters.Count);
            foreach (var genericParameter in Method.GenericParameters)
            {
                builder.Add(new GenericParameterProxy(genericParameter));
            }
 
            return builder.ToImmutableArray();
        }
 
        internal partial bool IsConstructor() => Definition.IsConstructor;
 
        internal partial bool IsStatic() => Definition.IsStatic;
 
        internal partial bool HasImplicitThis() => Method.HasImplicitThis();
 
        internal partial bool ReturnsVoid() => Method.ReturnsVoid();
 
        public override string ToString() => Method.ToString();
 
        public bool Equals(MethodProxy other) => Method.Equals(other.Method);
 
        public override bool Equals(object? obj) => obj is MethodProxy other && Equals(other);
 
        public override int GetHashCode() => Method.GetHashCode();
    }
}