package mnm.mods.tabbychat.util.config

import com.google.common.reflect.TypeToken
import kotlin.reflect.KProperty

sealed class AbstractValue<T> {
    abstract val type: TypeToken<T>?
    abstract val value: T

    override fun toString(): String {
        return value.toString()
    }
}

class Value<T>(
        override val type: TypeToken<T>,
        val default: () -> T) : AbstractValue<T>() {
    override var value = default()

    fun reset() {
        value = default()
    }
}

class ValueList<T>(
        override val type: TypeToken<MutableList<T>>,
        override val value: MutableList<T> = mutableListOf()
) : AbstractValue<MutableList<T>>(), MutableList<T> by value

class ValueMap<T>(
        override val type: TypeToken<MutableMap<String, T>>,
        override val value: MutableMap<String, T> = mutableMapOf()
) : AbstractValue<MutableMap<String, T>>(), MutableMap<String, T> by value

abstract class ValueObject<T : ValueObject<T>> : AbstractValue<T>() {
    override val type: Nothing? = null
    @Suppress("UNCHECKED_CAST")
    override val value: T
        get() = this as T

    internal val properties: MutableMap<String, AbstractValue<out Any>> = mutableMapOf()

    protected inline fun <reified T : Any> value(noinline default: () -> T) = ValueDelegate {
        Value(typeToken(), default)
    }

    protected inline fun <reified T : Any> list() = ValueDelegate {
        ValueList<T>(typeToken())
    }

    protected inline fun <reified T> map() = ValueDelegate {
        ValueMap<T>(typeToken())
    }

    protected fun <T : ValueObject<T>> obj(default: () -> T) = ValueDelegate(default)

    protected inline fun <reified T> typeToken() = object : TypeToken<T>() {}
}


class ValueDelegate<V : AbstractValue<T>, T : Any>(val factory: () -> V) {

    @Suppress("UNCHECKED_CAST")
    operator fun getValue(thisRef: ValueObject<*>, property: KProperty<*>): V {
        return thisRef.properties.getOrPut(property.name) {
            factory()
        } as V
    }
}