namespace SOR.Game.Abilities; using System.Reflection; using System.Text.Json; using System.Text.Json.Serialization; using SOR.Game.Abilities.Models; /// /// Generic base converter that fixes polymorphic deserialization when the /// $type discriminator is not the first property in a JSON object. /// /// System.Text.Json requires $type to appear first for abstract base /// classes. Card-definition JSON authored in the admin tool does not guarantee /// that ordering. This converter buffers the entire JSON object, finds /// $type at any position, looks up the concrete type from the /// map on , /// then deserializes via the default converter. /// /// CanConvert returns true only for the exact base type /// — not for concrete derived types — so there is no /// infinite recursion when the default converter processes derived-type properties. /// internal abstract class PolymorphicAbilityConverter : JsonConverter where T : class { // Static fields are per closed type T — each T gets its own map. private static readonly Dictionary s_typeMap; private static readonly Dictionary s_reverseMap; static PolymorphicAbilityConverter() { s_typeMap = new Dictionary(StringComparer.OrdinalIgnoreCase); s_reverseMap = new Dictionary(); foreach (var attr in typeof(T).GetCustomAttributes()) { s_typeMap[attr.Discriminator] = attr.DerivedType; // First [PolyType] for a given concrete type wins for writing (canonical discriminator). // Additional attributes register read-only aliases for backwards compatibility. s_reverseMap.TryAdd(attr.DerivedType, attr.Discriminator); } } /// /// Only intercept the abstract base itself. /// Concrete derived types fall through to the default serializer. /// public override bool CanConvert(Type typeToConvert) => typeToConvert == typeof(T); public override T? Read( ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { using var doc = JsonDocument.ParseValue(ref reader); var root = doc.RootElement; if (!root.TryGetProperty("$type", out var discriminatorProp)) throw new JsonException($"{typeof(T).Name} object is missing the '$type' discriminator."); var discriminator = discriminatorProp.GetString() ?? throw new JsonException($"{typeof(T).Name} '$type' discriminator is null."); if (!s_typeMap.TryGetValue(discriminator, out var concreteType)) throw new JsonException($"Unknown {typeof(T).Name} '$type': '{discriminator}'."); // CanConvert returns false for concrete derived types, so no infinite recursion. return (T?)root.Deserialize(concreteType, options); } public override void Write( Utf8JsonWriter writer, T value, JsonSerializerOptions options) { var concreteType = value.GetType(); if (!s_reverseMap.TryGetValue(concreteType, out var discriminator)) throw new JsonException($"No '$type' discriminator registered for {concreteType.Name}."); // Serialize the concrete object (CanConvert=false for it → no recursion). using var mem = new System.IO.MemoryStream(); using (var inner = new Utf8JsonWriter(mem)) JsonSerializer.Serialize(inner, value, concreteType, options); using var doc = JsonDocument.Parse(mem.ToArray()); // Write with $type first so round-trip JSON is always well-formed. writer.WriteStartObject(); writer.WriteString("$type", discriminator); foreach (var prop in doc.RootElement.EnumerateObject()) prop.WriteTo(writer); writer.WriteEndObject(); } } // ── Concrete converters ─────────────────────────────────────────────────────── internal sealed class EffectPolymorphicConverter : PolymorphicAbilityConverter { } internal sealed class ConditionPolymorphicConverter : PolymorphicAbilityConverter { } internal sealed class TriggerPolymorphicConverter : PolymorphicAbilityConverter{ } internal sealed class FilterPolymorphicConverter : PolymorphicAbilityConverter { }