#nullable enable

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text.Json;

using System.Text.Json.Nodes;

using System.Text.Json.Serialization;

​

sealed public class PolymorphicJsonConverter<T> : JsonConverter<T>

{

    private readonly string discriminatorPropName;

    private readonly Func<Type, string> getDiscriminator;

    private readonly IReadOnlyDictionary<string, Type> discriminatorToSubtype;

​

    public PolymorphicJsonConverter(

        string typeDiscriminatorPropertyName,

        Func<Type, string> getDiscriminatorForSubtype,

        IEnumerable<Type> subtypes)

    {

        discriminatorPropName = typeDiscriminatorPropertyName;

        getDiscriminator = getDiscriminatorForSubtype;

        discriminatorToSubtype = subtypes.ToDictionary(getDiscriminator, t => t);

    }

​

    public override bool CanConvert(Type typeToConvert)

        => typeof(T) == typeToConvert;

​

    public override T Read(

        ref Utf8JsonReader reader, Type objectType, JsonSerializerOptions options)

    {

        if (!JsonDocument.TryParseValue(ref reader, out JsonDocument? doc))

        {

            throw new JsonException();

        }

​

        using (doc)

        {

            JsonElement root = doc.RootElement;

            JsonElement typeField = root.GetProperty(discriminatorPropName);

​

            if (typeField.GetString() is not string typeName)

            {

                throw new Exception(

                    $"Could not find string property {discriminatorPropName} " +

                    $"when trying to deserialize {typeof(T).Name}");

            }

​

            if (!discriminatorToSubtype.TryGetValue(typeName, out Type? type))

            {

                throw new Exception($"Unknown type: {typeName}");

            }

​

            if (type.IsGenericTypeDefinition)

            {

                type = type.MakeGenericType(objectType.GetGenericArguments());

            }

​

            if (doc.Deserialize(type, options) is not T result)

            {

                throw new Exception($"Could not deserialize {typeof(T)}");

            }

​

            return result;

        }

    }

​

    public override void Write(

        Utf8JsonWriter writer, T? value, JsonSerializerOptions options)

    {

        // TODO: Find out the proper way to write null

        if (value is null)

        {

            throw new Exception($"Can't serialize null {typeof(T)}");

        }

​

        JsonElement jEl = JsonSerializer.SerializeToElement(value, value.GetType(), options);

        JsonObject jObj = JsonObject.Create(jEl) ?? throw new JsonException();

        jObj[discriminatorPropName] = getDiscriminator(value.GetType());

​

        jObj.WriteTo(writer, options);

    }

}

​

public class Base

{

    public int Base1 { get; set; }

}

​

public class Foo : Base

{

    public int Foo1 { get; set; }

}

​

public class Bar : Base

{

    public int Bar1 { get; set; }

}

​

public class WithBaseProp

{

    public required Base BaseProp { get; set; }

}

​

public class Program

{

    public static void Main()

    {

        string fooJson = """

            {

                "type": "Foo",

                "Base1": 1,

                "Foo1": 2

            }

            """;

​

        string barJson = """

            {

                "type": "Bar",

                "Base1": 3,

                "Bar1": 4

            }

            """;

        string basePropJson = """

            {

                "BaseProp": {

                    "type": "Foo",

                    "Base1": 5,

                    "Bar1": 6

                }

            }

            """;

        Type[] types = new[] { typeof(Foo), typeof(Bar) };

        JsonSerializerOptions options = new()

        {

            Converters = { new PolymorphicJsonConverter<Base>("type", t => t.Name, types) }

        };

        Base foo = JsonSerializer.Deserialize<Base>(fooJson, options)!;

        Base bar = JsonSerializer.Deserialize<Base>(barJson, options)!;

        WithBaseProp baseProp = JsonSerializer.Deserialize<WithBaseProp>(basePropJson, options)!;

        Console.WriteLine($"{nameof(foo)}'s type: {foo.GetType()}");

        Console.WriteLine($"{nameof(bar)}'s type: {bar.GetType()}");

        Console.WriteLine($"{nameof(baseProp)}'s property type: {baseProp.BaseProp.GetType()}");

        Console.WriteLine();

        Console.WriteLine($"{nameof(foo)}'s JSON: {JsonSerializer.Serialize<Base>(foo, options)}");

        Console.WriteLine($"{nameof(bar)}'s JSON: {JsonSerializer.Serialize<Base>(bar, options)}");

        Console.WriteLine($"{nameof(baseProp)}'s JSON: {JsonSerializer.Serialize<WithBaseProp>(baseProp, options)}");

    }

}