// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;

namespace System.Reflection.TypeLoading
{
    /// <summary>
    /// Class for all RoMethod objects created by a MetadataLoadContext for which IsConstructedGenericMethod returns true.
    /// </summary>
    internal sealed partial class RoConstructedGenericMethod : RoMethod
    {
        private readonly RoDefinitionMethod _genericMethodDefinition;
        private readonly RoType[] _genericMethodArguments;

        internal RoConstructedGenericMethod(RoDefinitionMethod genericMethodDefinition, RoType[] genericMethodArguments)
            : base(genericMethodDefinition.ReflectedType)
        {
            Debug.Assert(genericMethodDefinition != null);
            Debug.Assert(genericMethodArguments != null);

            _genericMethodDefinition = genericMethodDefinition;
            _genericMethodArguments = genericMethodArguments;
        }

        internal sealed override RoType GetRoDeclaringType() => _genericMethodDefinition.GetRoDeclaringType();
        internal sealed override RoModule GetRoModule() => _genericMethodDefinition.GetRoModule();

        protected sealed override string ComputeName() => _genericMethodDefinition.Name;
        public sealed override int MetadataToken => _genericMethodDefinition.MetadataToken;
        public sealed override IEnumerable<CustomAttributeData> CustomAttributes => _genericMethodDefinition.CustomAttributes;
        public sealed override bool IsConstructedGenericMethod => true;
        public sealed override bool IsGenericMethodDefinition => false;
        protected sealed override MethodAttributes ComputeAttributes() => _genericMethodDefinition.Attributes;
        protected sealed override CallingConventions ComputeCallingConvention() => _genericMethodDefinition.CallingConvention;
        protected sealed override MethodImplAttributes ComputeMethodImplementationFlags() => _genericMethodDefinition.MethodImplementationFlags;

        protected sealed override MethodSig<RoParameter> ComputeMethodSig() => _genericMethodDefinition.SpecializeMethodSig(this);

        public sealed override MethodBody? GetMethodBody() => _genericMethodDefinition.SpecializeMethodBody(this);

        protected sealed override RoType[] ComputeGenericArgumentsOrParameters() => _genericMethodArguments;

        internal sealed override RoType[] GetGenericTypeArgumentsNoCopy() => _genericMethodArguments;
        internal sealed override RoType[] GetGenericTypeParametersNoCopy() => Array.Empty<RoType>();

        public sealed override MethodInfo GetGenericMethodDefinition() => _genericMethodDefinition;

        [RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
        public sealed override MethodInfo MakeGenericMethod(params Type[] typeArguments) => throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericMethodDefinition, this));

        public sealed override bool Equals([NotNullWhen(true)] object? obj)
        {
            if (!(obj is RoConstructedGenericMethod other))
                return false;

            if (!(_genericMethodDefinition == other._genericMethodDefinition))
                return false;

            if (_genericMethodArguments.Length != other._genericMethodArguments.Length)
                return false;

            for (int i = 0; i < _genericMethodArguments.Length; i++)
            {
                if (_genericMethodArguments[i] != other._genericMethodArguments[i])
                    return false;
            }

            return true;
        }

        public sealed override int GetHashCode()
        {
            int hashCode = _genericMethodDefinition.GetHashCode();
            foreach (Type genericMethodArgument in _genericMethodArguments)
            {
                hashCode ^= genericMethodArgument.GetHashCode();
            }
            return hashCode;
        }

        protected sealed override MethodSig<string> ComputeMethodSigStrings() => _genericMethodDefinition.SpecializeMethodSigStrings(TypeContext);

        public sealed override TypeContext TypeContext => new TypeContext(_genericMethodDefinition.TypeContext.GenericTypeArguments, _genericMethodArguments);
    }
}