package com.betriebsratkanzlei.legalconsenthub.config

import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionNode
import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionOperator
import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionType
import com.fasterxml.jackson.core.JsonGenerator
import com.fasterxml.jackson.core.JsonParser
import com.fasterxml.jackson.databind.DeserializationContext
import com.fasterxml.jackson.databind.JsonDeserializer
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.JsonSerializer
import com.fasterxml.jackson.databind.SerializerProvider
import com.fasterxml.jackson.databind.module.SimpleModule

class VisibilityConditionNodeDeserializer : JsonDeserializer<VisibilityConditionNode>() {
    override fun deserialize(
        p: JsonParser,
        ctxt: DeserializationContext,
    ): VisibilityConditionNode {
        val node = p.codec.readTree<JsonNode>(p)

        val nodeType = node.get("nodeType")?.asText()

        return if (nodeType == "GROUP") {
            val groupOperator =
                node.get("groupOperator")?.asText()?.let {
                    VisibilityConditionNode.GroupOperator.forValue(it)
                }
            val conditions =
                node.get("conditions")?.map { childNode ->
                    val childParser = childNode.traverse(p.codec)
                    childParser.nextToken()
                    deserialize(childParser, ctxt)
                } ?: emptyList()
            VisibilityConditionNode(
                nodeType = VisibilityConditionNode.NodeType.GROUP,
                groupOperator = groupOperator,
                conditions = conditions,
            )
        } else {
            // Default to LEAF for backward compatibility
            val sourceRef = node.get("sourceFormElementReference")?.asText()
            val conditionType =
                node.get("formElementConditionType")?.asText()?.let {
                    VisibilityConditionType.valueOf(it)
                }
            val expectedValue = node.get("formElementExpectedValue")?.asText()
            val formElementOperator =
                node.get("formElementOperator")?.asText()?.let {
                    VisibilityConditionOperator.valueOf(it)
                }
            VisibilityConditionNode(
                nodeType = VisibilityConditionNode.NodeType.LEAF,
                sourceFormElementReference = sourceRef,
                formElementConditionType = conditionType,
                formElementExpectedValue = expectedValue,
                formElementOperator = formElementOperator,
            )
        }
    }
}

class VisibilityConditionNodeSerializer : JsonSerializer<VisibilityConditionNode>() {
    override fun serialize(
        value: VisibilityConditionNode,
        gen: JsonGenerator,
        serializers: SerializerProvider,
    ) {
        gen.writeStartObject()
        gen.writeStringField("nodeType", (value.nodeType ?: VisibilityConditionNode.NodeType.LEAF).value)

        if (value.nodeType == VisibilityConditionNode.NodeType.GROUP) {
            value.groupOperator?.let { gen.writeStringField("groupOperator", it.value) }
            gen.writeArrayFieldStart("conditions")
            value.conditions?.forEach { serialize(it, gen, serializers) }
            gen.writeEndArray()
        } else {
            value.formElementConditionType?.let {
                gen.writeStringField("formElementConditionType", it.value)
            }
            value.sourceFormElementReference?.let {
                gen.writeStringField("sourceFormElementReference", it)
            }
            value.formElementExpectedValue?.let {
                gen.writeStringField("formElementExpectedValue", it)
            }
            value.formElementOperator?.let {
                gen.writeStringField("formElementOperator", it.value)
            }
        }
        gen.writeEndObject()
    }
}

fun visibilityConditionModule(): SimpleModule =
    SimpleModule("VisibilityConditionModule").apply {
        addDeserializer(VisibilityConditionNode::class.java, VisibilityConditionNodeDeserializer())
        addSerializer(VisibilityConditionNode::class.java, VisibilityConditionNodeSerializer())
    }