package me.eater.hefbrug.executor

import me.eater.hefbrug.definition.DefinitionWildcard
import me.eater.hefbrug.dsl.context.extension_util.FactoryRegister
import me.eater.hefbrug.enforcer.AbstractEnforcer
import me.eater.hefbrug.logging.Logging
import me.eater.hefbrug.logging.message.Messages.foundDifference
import me.eater.hefbrug.logging.message.Messages.noDifferences
import me.eater.hefbrug.state.AbstractState

class StateEnforcer(private val context: ExecutionContext) : Logging {
    private val enforcers = mutableMapOf<String, AbstractEnforcer<*>>()

    @Suppress("UNCHECKED_CAST")
    suspend fun <S : AbstractState, D : DefinitionWildcard<S>> enforce(
        definition: D,
        currentState: S
    ) {
        val enforcer = enforcers.getOrPut(
            definition.key.group,
            { FactoryRegister[definition.key.group].createEnforcer(context) }) as AbstractEnforcer<S>

        val diff = definition.state.diff(currentState)

        if (diff.isNotEmpty())
            info(
                foundDifference(
                    definition.key,
                    context.node,
                    mutableMapOf<String, Pair<Any?, Any?>>().apply {
                        for (k in diff) {
                            put(k, currentState[k].get() to definition.state[k].get())
                        }
                    }
                )
            )
        else
            trace(noDifferences(definition.key, context.node))

        return enforcer.enforce(currentState, definition.state, diff)
    }
}