reflection

using System;
using System.Linq;
using System.Reflection;

namespace Documentation
{
    public class Specifier<T> : ISpecifier
    {
        private readonly Type objectType = typeof(T);

        public string GetApiDescription()
        {
            return GetAttribute<ApiDescriptionAttribute>(objectType)?.Description;
        }

        public string[] GetApiMethodNames()
        {
            return objectType.GetMethods()
                .Where(m => m.GetCustomAttributes<ApiMethodAttribute>().Any())
                .Select(m => m.Name)
                .ToArray();
        }

        public string GetApiMethodDescription(string methodName)
        {
            var methodInfo = GetMethod(methodName);
            return methodInfo is null ? null : GetAttribute<ApiDescriptionAttribute>(methodInfo)?.Description;
        }

        public string[] GetApiMethodParamNames(string methodName)
        {
            var methodInfo = GetMethod(methodName);
            return methodInfo is null
                ? Array.Empty<string>()
                : methodInfo.GetParameters().Select(p => p.Name).ToArray();
        }

        public string GetApiMethodParamDescription(string methodName, string paramName)
        {
            var methodInfo = GetMethod(methodName);
            return methodInfo is null
                ? null
                : GetAttribute<ApiDescriptionAttribute>(GetParameter(methodInfo, paramName))?.Description;
        }

        public ApiParamDescription GetApiMethodParamFullDescription(string methodName, string paramName)
        {
            var methodInfo = GetMethod(methodName);
            if (methodInfo is null)
                return new ApiParamDescription { ParamDescription = new CommonDescription(paramName) };

            var parameterInfo = GetParameter(methodInfo, paramName);
            return new ApiParamDescription
            {
                ParamDescription = new CommonDescription
                {
                    Name = paramName,
                    Description = GetApiMethodParamDescription(methodName, paramName)
                },
                Required = GetAttribute<ApiRequiredAttribute>(parameterInfo)?.Required ?? false,
                MinValue = GetAttribute<ApiIntValidationAttribute>(parameterInfo)?.MinValue,
                MaxValue = GetAttribute<ApiIntValidationAttribute>(parameterInfo)?.MaxValue
            };
        }

        public ApiMethodDescription GetApiMethodFullDescription(string methodName)
        {
            var methodInfo = GetMethod(methodName);
            if (methodInfo is null)
                return null;

            return new ApiMethodDescription
            {
                ParamDescriptions = GetParamsDescription(methodInfo),
                MethodDescription = GetMethodDescription(methodInfo),
                ReturnDescription = GetDescription(methodInfo)
            };
        }

        private ParameterInfo GetParameter(MethodInfo methodInfo, string parameterName)
        {
            return methodInfo.GetParameters().FirstOrDefault(p => p.Name == parameterName);
        }

        private TAttribute GetAttribute<TAttribute>(ParameterInfo parameterInfo) where TAttribute : Attribute
        {
            return parameterInfo?.GetCustomAttribute<TAttribute>();
        }

        private TAttribute GetAttribute<TAttribute>(MethodInfo methodInfo) where TAttribute : Attribute
        {
            return methodInfo?.GetCustomAttribute<TAttribute>();
        }

        private TAttribute GetAttribute<TAttribute>(Type type) where TAttribute : Attribute
        {
            return type?.GetCustomAttribute<TAttribute>();
        }

        private MethodInfo GetMethod(string methodName)
        {
            var method = objectType.GetMethod(methodName);
            return GetAttribute<ApiMethodAttribute>(method) is null ? null : method;
        }

        private ApiParamDescription[] GetParamsDescription(MethodInfo method)
        {
            return method.GetParameters().Select(p => GetApiMethodParamFullDescription(method.Name, p.Name)).ToArray();
        }

        private ApiParamDescription GetDescription(MethodInfo method)
        {
            var returnTypeCustomAttributes = method.ReturnTypeCustomAttributes.GetCustomAttributes(true);

            if (!returnTypeCustomAttributes.Any())
                return null;

            var apiRequiredAttribute = returnTypeCustomAttributes.OfType<ApiRequiredAttribute>().FirstOrDefault();
            var apiIntValidationAttribute = returnTypeCustomAttributes.OfType<ApiIntValidationAttribute>().FirstOrDefault();

            return new ApiParamDescription
            {
                Required = apiRequiredAttribute?.Required ?? false,
                MinValue = apiIntValidationAttribute?.MinValue,
                MaxValue = apiIntValidationAttribute?.MaxValue
            };
        }

        private CommonDescription GetMethodDescription(MethodInfo method)
        {
            return new CommonDescription
            {
                Name = method.Name,
                Description = method.GetCustomAttribute<ApiDescriptionAttribute>()?.Description
            };
        }
    }
}