ViewModel.kt

package com.dmm.eikaiwa.viewmodels

import com.dmm.eikaiwa.serialization.json.JsonParser
import com.dmm.eikaiwa.serialization.json.copy
import kotlinx.serialization.KSerializer
import kotlinx.serialization.Serializable
import kotlinx.serialization.Transient
import kotlinx.serialization.modules.SerializersModule
import kotlin.uuid.Uuid

interface ViewModel {
    companion object
}

interface Identifiable {
    val id: Uuid
}

@Serializable
open class ViewModelRecord(override val id: Uuid = Uuid.random()) : ViewModel, Identifiable {
    @Transient
    var isNew: Boolean = true

    @Suppress("UNCHECKED_CAST")
    fun <T> notNew(): T = apply { isNew = false } as T
}

interface ViewModelMetadata: ViewModelVersions {
    val typeName: String
    val version: Int
    val root: Boolean
        get() = false
    val properties: Map<String, ViewModelProperty>
        get() = emptyMap()

    override val nestedVersions: Map<String, Int>
        get() {
            val models = properties.values.filterIsInstance<HasModelVersions>()
            val versions = models.fold<HasModelVersions, Map<String, Int>>(emptyMap()) { acc, it ->
                acc + it.versions.nestedVersions
            }
            val selfVersion = mapOf(typeName to version)
            return selfVersion + versions
        }
}

interface ViewModelMeta : ViewModelVersions

interface ViewModelSupplementary : ViewModelVersions

interface ViewModelVersions {
    val nestedVersions: Map<String, Int>
}

interface PartialMetadata<T> {
    val event: String
    val serializer: KSerializer<T>
}

fun <T: Identifiable> ViewModel.Companion.encode(serializer: KSerializer<T>, model: T): String {
    val referenceCache = ViewModelReferenceCache()
    return JsonViewModelEncoder(
        JsonParser.copy(
            serializersModule = SerializersModule {
                contextual(
                    ViewModelContext::class,
                    ViewModelContextSerializer(referenceCache, listOf(model.id))
                )
            }
        ),
        serializer,
        model
    ).encode()
}

fun <T> ViewModel.Companion.decode(
    modelSerializer: KSerializer<T>,
    string: String
): T {
    val referenceCache = ViewModelReferenceCache()
    val decoder = JsonViewModelDecoder(string,
        JsonParser.copy(
            serializersModule = SerializersModule {
                contextual(ViewModelContext::class, ViewModelContextSerializer(referenceCache, null))
            }
        )
    )
    return decoder.parse(modelSerializer).getOrThrow().first
}

fun <T> ViewModel.Companion.decodePartial(
    modelSerializer: KSerializer<T>,
    string: String
): T {
    return JsonParser.decodeFromString(modelSerializer, string)
}

fun <T, Meta, Supplementary> ViewModel.Companion.decode(
    modelSerializer: KSerializer<T>,
    metaSerializer: KSerializer<Meta>,
    supplementarySerializer: KSerializer<Supplementary>,
    string: String
): ViewModelParseResult<T, Meta, Supplementary> {
    val referenceCache = ViewModelReferenceCache()
    return JsonViewModelDecoder(string,
        JsonParser.copy(
            serializersModule = SerializersModule {
                contextual(ViewModelContext::class, ViewModelContextSerializer(referenceCache, null))
            }
        )
    ).parse(modelSerializer, metaSerializer, supplementarySerializer)
}