AnySerializer.kt — kotlinx.serializaiton for Map<String, Any>

import kotlinx.serialization.KSerializer
import kotlinx.serialization.Serializer
import kotlinx.serialization.builtins.ListSerializer
import kotlinx.serialization.builtins.MapSerializer
import kotlinx.serialization.builtins.serializer
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.descriptors.buildClassSerialDescriptor
import kotlinx.serialization.descriptors.element
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonDecoder
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.boolean
import kotlinx.serialization.json.booleanOrNull
import kotlinx.serialization.json.double
import kotlinx.serialization.json.doubleOrNull
import kotlinx.serialization.json.int
import kotlinx.serialization.json.intOrNull

@Serializer(forClass = Any::class)
object AnySerializer : KSerializer<Any> {

    override val descriptor: SerialDescriptor =
        buildClassSerialDescriptor("Any") {
            element<String>("String")
            element<Int>("Int")
            element<Double>("Double")
            element<Boolean>("Boolean")
            element<JsonElement>("JsonElement")
        }

    override fun serialize(encoder: Encoder, value: Any) {
        when (value) {
            is String -> encoder.encodeString(value)
            is Int -> encoder.encodeInt(value)
            is Double -> encoder.encodeDouble(value)
            is Boolean -> encoder.encodeBoolean(value)
            is JsonElement -> encoder.encodeSerializableValue(JsonElement.serializer(), value)
            is Map<*, *> -> {
                val mapSerializer = MapSerializer(String.serializer(), AnySerializer)
                encoder.encodeSerializableValue(mapSerializer, uncheckedCast(value))
            }
            is List<*> -> {
                val listSerializer = ListSerializer(AnySerializer)
                encoder.encodeSerializableValue(listSerializer, uncheckedCast(value))
            }
            else -> throw IllegalArgumentException("Unsupported type for AnySerializer: ${value::class}")
        }
    }

    override fun deserialize(decoder: Decoder): Any {
        val json = (decoder as? JsonDecoder)?.json ?: Json
        val element = decoder.decodeSerializableValue(JsonElement.serializer())

        return when (element) {
            is JsonObject -> element.map { (key, value) ->
                val mapSerializer = MapSerializer(String.serializer(), AnySerializer)
                json.decodeFromJsonElement(mapSerializer, element)
            }

            is JsonArray -> {
                val listSerializer = ListSerializer(AnySerializer)
                json.decodeFromJsonElement(listSerializer, element)
            }

            is JsonPrimitive -> {
                when {
                    element.isString -> element.content
                    element.intOrNull != null -> element.int
                    element.doubleOrNull != null -> element.double
                    element.booleanOrNull != null -> element.boolean
                    else -> throw IllegalArgumentException("Unsupported JSON value for AnySerializer: $element")
                }
            }

            else -> throw IllegalArgumentException("Unsupported JSON value for AnySerializer: $element")
        }
    }
}

@Suppress("UNCHECKED_CAST")
fun <T> uncheckedCast(value: Any?): T = (value as T)