// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Diagnostics.CodeAnalysis;
using Microsoft.Extensions.Internal;
 
namespace Microsoft.AspNetCore.Components.Endpoints.FormMapping;
 
internal class DictionaryConverterFactory : IFormDataConverterFactory
{
    internal static readonly DictionaryConverterFactory Instance = new();
 
    [RequiresDynamicCode(FormMappingHelpers.RequiresDynamicCodeMessage)]
    [RequiresUnreferencedCode(FormMappingHelpers.RequiresUnreferencedCodeMessage)]
    public bool CanConvert(Type type, FormDataMapperOptions options)
    {
        var (keyType, valueType) = ResolveDictionaryTypes(type);
 
        // Value must have a converter
        if (valueType == null)
        {
            return default;
        }
 
        var converter = options.ResolveConverter(valueType);
        if (converter == null)
        {
            return false;
        }
 
        if (Activator.CreateInstance(typeof(TypedDictionaryConverterFactory<,,>)
            .MakeGenericType(type, keyType, valueType)) is not IFormDataConverterFactory factory)
        {
            return false;
        }
 
        return factory.CanConvert(type, options);
    }
 
    [RequiresDynamicCode(FormMappingHelpers.RequiresDynamicCodeMessage)]
    [RequiresUnreferencedCode(FormMappingHelpers.RequiresUnreferencedCodeMessage)]
    internal static (Type keyType, Type valueType) ResolveDictionaryTypes(Type type)
    {
        // Type must implement IDictionary<TKey, TValue> IReadOnlyDictionary<TKey, TValue>
        // Note that IDictionary doesn't extend IReadOnlyDictionary, hence the need for two checks
        var dictionaryType = ClosedGenericMatcher.ExtractGenericInterface(type, typeof(IDictionary<,>)) ??
            ClosedGenericMatcher.ExtractGenericInterface(type, typeof(IReadOnlyDictionary<,>));
 
        if (dictionaryType == null)
        {
            return default;
        }
 
        // Key type must implement IParsable<T>
        var keyType = dictionaryType.GetGenericArguments()[0];
        if (keyType == null)
        {
            return default;
        }
 
        var parsableKeyType = ClosedGenericMatcher.ExtractGenericInterface(keyType, typeof(IParsable<>));
        if (parsableKeyType == null)
        {
            return default;
        }
 
        var valueType = dictionaryType.GetGenericArguments()[1];
        return (keyType, valueType);
    }
 
    [RequiresDynamicCode(FormMappingHelpers.RequiresDynamicCodeMessage)]
    [RequiresUnreferencedCode(FormMappingHelpers.RequiresUnreferencedCodeMessage)]
    public FormDataConverter CreateConverter(Type type, FormDataMapperOptions options)
    {
        // Type must implement IDictionary<TKey, TValue> IReadOnlyDictionary<TKey, TValue>
        // Note that IDictionary doesn't extend IReadOnlyDictionary, hence the need for two checks
        var dictionaryType = ClosedGenericMatcher.ExtractGenericInterface(type, typeof(IDictionary<,>)) ??
            ClosedGenericMatcher.ExtractGenericInterface(type, typeof(IReadOnlyDictionary<,>));
        if (dictionaryType == null)
        {
            throw new InvalidOperationException($"Unable to create converter for '{type.FullName}'.");
        }
 
        // Key type must implement IParsable<T>
        var keyType = dictionaryType?.GetGenericArguments()[0];
        if (keyType == null)
        {
            throw new InvalidOperationException($"Unable to create converter for '{type.FullName}'.");
        }
 
        var parsableKeyType = ClosedGenericMatcher.ExtractGenericInterface(keyType, typeof(IParsable<>));
        if (parsableKeyType == null)
        {
            throw new InvalidOperationException($"Unable to create converter for '{type.FullName}'.");
        }
 
        // Value must have a converter
        var valueType = dictionaryType?.GetGenericArguments()[1];
        if (valueType == null)
        {
            throw new InvalidOperationException($"Unable to create converter for '{type.FullName}'.");
        }
 
        var converter = options.ResolveConverter(valueType);
        if (converter == null)
        {
            throw new InvalidOperationException($"Unable to create converter for '{type.FullName}'.");
        }
 
        var factory = Activator.CreateInstance(typeof(TypedDictionaryConverterFactory<,,>)
            .MakeGenericType(type, keyType, valueType)) as IFormDataConverterFactory;
 
        if (factory == null)
        {
            throw new InvalidOperationException($"Unable to create converter for '{type.FullName}'.");
        }
 
        return factory.CreateConverter(type, options);
    }
}