// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System;
using System.Collections.Immutable;
using MessagePack;
using MessagePack.Formatters;
using MessagePack.Resolvers;
using Microsoft.ServiceHub.Framework;
using Nerdbank.Streams;
using Newtonsoft.Json;
using StreamJsonRpc;
 
namespace Microsoft.CodeAnalysis.Remote;
 
/// <summary>
/// Wraps MessagePack or JSON serialization options/converters.
/// </summary>
internal readonly struct RemoteSerializationOptions
{
    internal static readonly RemoteSerializationOptions Default = new([], []);
 
    // Enables remote APIs to pass Stream as parameter.
    private static readonly MultiplexingStream.Options s_multiplexingStreamOptions = new MultiplexingStream.Options
    {
        ProtocolMajorVersion = 3
    }.GetFrozenCopy();
 
    private readonly object _options;
 
    public RemoteSerializationOptions(ImmutableArray<IMessagePackFormatter> additionalFormatters, ImmutableArray<IFormatterResolver> additionalResolvers)
        => _options = StandardResolverAllowPrivate.Options
            .WithSecurity(MessagePackSecurity.UntrustedData.WithHashCollisionResistant(false))
            .WithResolver(MessagePackFormatters.CreateResolver(additionalFormatters, additionalResolvers));
 
    public RemoteSerializationOptions(ImmutableArray<JsonConverter> jsonConverters)
        => _options = jsonConverters;
 
    public RemoteSerializationOptions(ImmutableArray<System.Text.Json.Serialization.JsonConverter> jsonConverters)
        => _options = jsonConverters;
 
    public MessagePackSerializerOptions MessagePackOptions => (MessagePackSerializerOptions)_options;
    public ImmutableArray<JsonConverter> JsonConverters => (ImmutableArray<JsonConverter>)_options;
    public ImmutableArray<System.Text.Json.Serialization.JsonConverter> SystemTextJsonConverters => (ImmutableArray<System.Text.Json.Serialization.JsonConverter>)_options;
 
    public ServiceJsonRpcDescriptor.Formatters Formatter
        => _options switch
        {
            MessagePackSerializerOptions => ServiceJsonRpcDescriptor.Formatters.MessagePack,
            ImmutableArray<JsonConverter> => ServiceJsonRpcDescriptor.Formatters.UTF8,
            ImmutableArray<System.Text.Json.Serialization.JsonConverter> => ServiceJsonRpcDescriptor.Formatters.UTF8SystemTextJson,
            _ => throw new InvalidOperationException()
        };
 
    public ServiceJsonRpcDescriptor.MessageDelimiters MessageDelimiters
       => _options is MessagePackSerializerOptions
           ? ServiceJsonRpcDescriptor.MessageDelimiters.BigEndianInt32LengthHeader
           : ServiceJsonRpcDescriptor.MessageDelimiters.HttpLikeHeaders;
 
    public MultiplexingStream.Options? MultiplexingStreamOptions
        => _options is MessagePackSerializerOptions ? s_multiplexingStreamOptions : null;
 
    internal IJsonRpcMessageFormatter ConfigureFormatter(IJsonRpcMessageFormatter formatter)
    {
        if (formatter is MessagePackFormatter messagePackFormatter)
        {
            // See https://github.com/neuecc/messagepack-csharp.
            messagePackFormatter.SetMessagePackSerializerOptions(MessagePackOptions);
        }
        else if (formatter is SystemTextJsonFormatter stjFormatter)
        {
            var converters = stjFormatter.JsonSerializerOptions.Converters;
 
            foreach (var converter in SystemTextJsonConverters)
            {
                converters.Add(converter);
            }
        }
        else
        {
            var converters = ((JsonMessageFormatter)formatter).JsonSerializer.Converters;
 
            foreach (var converter in JsonConverters)
            {
                converters.Add(converter);
            }
        }
 
        return formatter;
    }
}