LazyValueVisualizer.kt

@file:afield.runtime.completion.CompletionCategory("Visualization")

package afield.ui.visualization

import afield.app.protocol.put
import afield.data.table.div
import afield.data.table.minus
import afield.data.table.plus
import afield.data.table.rem
import afield.data.table.times
import afield.document.graph.box
import afield.document.graph.nested
import afield.document.graph.nestedIn
import afield.document.graph.offline
import afield.runtime.completion.CompletionCategory
import afield.runtime.execution.plus
import afield.runtime.lifecycle.lazyVar
import afield.runtime.lifecycle.loop
import afield.runtime.lifecycle.plus
import afield.runtime.lifecycle.rem
import afield.runtime.lifecycle.then
import afield.ui.notation.center
import afield.ui.notation.string
import afield.ui.notation.with
import afield.ui.output.column
import afield.ui.output.tree

import afield.audio.synth.*
import afield.data.table.cell
import afield.data.table.get
import afield.document.graph.Box
import afield.document.workspace.Entry
import afield.graphics.vulkan.*
import afield.media.stream.*
import afield.media.video.*
import afield.runtime.lifecycle.end
import afield.runtime.lifecycle.map
import afield.tools.docs.format
import afield.ui.output.FieldMarkdown
import afield.app.server.Browsable
import afield.app.server.Inspector
import afield.math.units.Quantity
import afield.math.units.formatExpression
import afield.math.units.formatQuantityDisplay
import eu.sirotin.kotunil.core.Expression
import java.nio.FloatBuffer
import java.nio.IntBuffer
import java.util.LinkedHashMap
import java.util.UUID
import kotlin.math.abs

    private fun findInInterfaceClosure(roots: Array<Class<*>>): ((Any) -> H2ValueSnapshot)? {
        val queue = ArrayDeque(roots.toList())
        val seen = HashSet<Class<*>>(roots.toList())
        while (queue.isNotEmpty()) {
            val iface = queue.removeFirst()
            adapters[iface]?.let { return it }
            iface.interfaces.forEach { if (seen.add(it)) queue.addLast(it) }
        }
        return null
    }
}

private object H2TokenRetention {
    private data class Entry(val raw: Any?, val createdAtMs: Long)

    private val retained = LinkedHashMap<String, Entry>()

    @Synchronized
    fun remember(token: String, raw: Any?) {
        val now = System.currentTimeMillis()
        retained[token] = Entry(raw, now)
        cleanup(now)
    }

    @Synchronized
    fun fetch(token: String): Any? {
        val now = System.currentTimeMillis()
        cleanup(now)
        return retained[token]?.raw
    }

    @Synchronized
    private fun cleanup(now: Long) {
        val it = retained.entries.iterator()
        while (it.hasNext()) {
            val (_, entry) = it.next()
            if (now - entry.createdAtMs > H2_TOKEN_TTL_MS) {
                it.remove()
            }
        }
        while (retained.size > H2_TOKEN_MAX) {
            val eldestKey = retained.entries.firstOrNull()?.key ?: break
            retained.remove(eldestKey)
        }
    }
}

    private fun outputAreaLinkHtml(
        path: String,
        label: String,
        colour: String,
        ownerUid: String?,
        viewTitle: String
    ): String = buildString {
        append("<a href='")
        append(escapeHtmlAttr(path))
        if (!ownerUid.isNullOrBlank()) {
            append("' data-afield-view-src='")
            append(escapeHtmlAttr(path))
            append("' data-afield-box-uid='")
            append(escapeHtmlAttr(ownerUid))
            append("' data-afield-view-title='")
            append(escapeHtmlAttr("$viewTitle — $label"))
            append("' onclick='window.afieldOpenLazyValueInOutputArea && window.afieldOpenLazyValueInOutputArea(this); return false;'")
            append(" style='color:$colour;text-decoration:none;cursor:pointer;'>")
        } else {
            append("' target='_blank' style='color:$colour;text-decoration:none;'>")
        }
        append(label)
        append("</a>")
    }

    private fun summary(value: Any?): String = when (value) {
        null -> "null"
        is Map<*, *> -> "${value::class.simpleName ?: "Map"} (size=${value.size})"
        is List<*> -> unitCollectionSummary(value, value::class.simpleName ?: "List")
            ?: "${value::class.simpleName ?: "List"} (size=${value.size})"
        is Array<*> -> unitCollectionSummary(value.asList(), value::class.simpleName ?: "Array")
            ?: "${value::class.simpleName ?: "Array"} (size=${value.size})"
        is Collection<*> -> "${value::class.simpleName ?: "Collection"} (size=${value.size})"
        is IntArray -> "IntArray (size=${value.size})"
        is LongArray -> "LongArray (size=${value.size})"
        is FloatArray -> "FloatArray (size=${value.size})"
        is DoubleArray -> "DoubleArray (size=${value.size})"
        is FloatBuffer -> "FloatBuffer (pos=${value.position()}, limit=${value.limit()}, capacity=${value.capacity()})"
        is IntBuffer -> "IntBuffer (pos=${value.position()}, limit=${value.limit()}, capacity=${value.capacity()})"
        // A reflected domain object gets a property count, because "Foo" alone tells a person
        // nothing about whether the tree below it is worth opening.
        else -> if (H2Reflect.isExplorableObject(value)) H2Reflect.summaryLine(value)
        else value::class.simpleName ?: value::class.java.simpleName
    }

    private fun unitCollectionSummary(values: List<*>, kind: String): String? {
        if (values.isEmpty()) return null
        val symbols = values.mapNotNull {
            when (it) {
                is Quantity -> formatQuantityDisplay(it).second
                is Expression -> formatExpression(it).second
                else -> return null
            }
        }.distinct()
        val suffix = if (symbols.size == 1 && symbols.single().isNotBlank()) " · ${symbols.single()}" else " · mixed units"
        return "$kind (size=${values.size})$suffix"
    }

private fun wrapUnadapted(value: Any?, title: String? = null): Any? {
    return when (value) {
        null -> null
        is Quantity -> QuantityBrowsable(value)
        is Expression -> UnitExpressionBrowsable(value)
        is PagedListBrowsable -> value
        is PagedMapBrowsable -> value
        is FloatBufferBrowsable -> value
        is IntBufferBrowsable -> value
        is Map<*, *> -> PagedMapBrowsable.forMap(value, title)
        is List<*> -> PagedListBrowsable(value, title = title)
        is Array<*> -> PagedListBrowsable(value.asList(), title = title)
        is ByteArray -> PagedListBrowsable(value.asList(), title = title)
        is ShortArray -> PagedListBrowsable(value.asList(), title = title)
        is IntArray -> IntBufferBrowsable(IntBuffer.wrap(value), title = title)
        is LongArray -> PagedListBrowsable(value.asList(), title = title)
        is FloatArray -> FloatBufferBrowsable(FloatBuffer.wrap(value), title = title)
        is DoubleArray -> PagedListBrowsable(value.asList(), title = title)
        is BooleanArray -> PagedListBrowsable(value.asList(), title = title)
        is CharArray -> PagedListBrowsable(value.asList(), title = title)
        is FloatBuffer -> FloatBufferBrowsable(value, title = title)
        is IntBuffer -> IntBufferBrowsable(value, title = title)
        // After `List`, so a list keeps the no-copy path: a `Set` or a `Queue` is snapshotted
        // because the pager addresses rows by index and only a `List` can do that in place.
        is Collection<*> -> PagedListBrowsable(value.toList(), title = title)
        // The reflective default, reached only for types with no registered adapter — `wrapForInspector`
        // has already taken those. Returns null for anything `H2Reflect` declines — a scalar, a
        // platform type, a value whose `.h` rendering is already the whole story — and then the raw
        // value falls through to the Inspector's leaf renderer, exactly as before this existed.
        else -> H2Reflect.browsableFor(value, title) ?: value
    }
}

private class QuantityBrowsable(private val quantity: Quantity) : Browsable {
    override fun heading(): String = quantity.toString()

    override fun dir(): Map<String, Any?> = linkedMapOf(
        "display value" to quantity.displayValue,
        "display unit" to quantity.displaySymbol,
        "SI value" to quantity.value,
        "SI unit" to quantity.unitSymbols.trim()
    )

    override fun html(): String = ValueVisualizer.visualize(quantity)
}

private class UnitExpressionBrowsable(private val expression: Expression) : Browsable {
    private val formatted by lazy { formatExpression(expression) }

    override fun heading(): String = formatted.let { (value, symbol) ->
        if (symbol.isBlank()) value.toString() else "$value $symbol"
    }

    override fun dir(): Map<String, Any?> = linkedMapOf(
        "SI value" to expression.value,
        "SI unit" to expression.unitSymbols().trim()
    )

    override fun html(): String = ValueVisualizer.visualize(expression)
}

private fun rangeLabel(start: Int, endExclusive: Int): String {
    val last = endExclusive - 1
    return if (start > last) "[empty]" else "[$start..$last]"
}

private fun ceilDiv(value: Int, by: Int): Int {
    if (value <= 0) return 0
    return (value + by - 1) / by
}

private fun computeChildSpan(count: Int, leafSpan: Int): Int {
    var span = leafSpan.coerceAtLeast(1)
    while (ceilDiv(count, span) > H2_MAX_CHILDREN_PER_DIR) {
        val next = span * H2_MAX_CHILDREN_PER_DIR
        if (next <= span) {
            return count.coerceAtLeast(leafSpan)
        }
        span = next
    }
    return span
}

private fun clip(text: String, maxChars: Int = 64): String {
    if (text.length <= maxChars) return text
    return text.take(maxChars - 3) + "..."
}

private fun keyPreview(key: Any?): String {
    if (key == null) return "null"
    return clip(key.toString().replace('\n', ' '))
}

private fun fmtFloat(n: Float): String {
    return when {
        n.isNaN() -> "NaN"
        n.isInfinite() -> if (n > 0f) "Infinity" else "-Infinity"
        abs(n) < 0.001f && n != 0f -> "%.2e".format(n)
        abs(n) > 10000f -> "%.2e".format(n)
        else -> "%.4f".format(n).trimEnd('0').trimEnd('.')
    }
}

private class PagedListBrowsable(
    private val list: List<*>,
    private val title: String? = null,
    private val start: Int = 0,
    private val endExclusive: Int = list.size
) : Browsable {

    private val safeStart = start.coerceIn(0, list.size)
    private val safeEnd = endExclusive.coerceIn(safeStart, list.size)
    private val count = safeEnd - safeStart

    override fun heading(): String {
        val base = title ?: "List"
        return if (safeStart == 0 && safeEnd == list.size) "$base (${list.size})" else "$base ${rangeLabel(safeStart, safeEnd)}"
    }

    override fun dir(): Map<String, Any?>? {
        if (count <= 0) return null
        if (count <= H2_LIST_LEAF_SIZE) {
            val out = LinkedHashMap<String, Any?>(count)
            for (i in safeStart until safeEnd) {
                out["[$i]"] = wrapForInspector(list[i], title = "[$i]")
            }
            return out
        }

        val childSpan = computeChildSpan(count, H2_LIST_LEAF_SIZE)
        val out = LinkedHashMap<String, Any?>()
        var s = safeStart
        while (s < safeEnd) {
            val e = minOf(s + childSpan, safeEnd)
            out[rangeLabel(s, e)] = PagedListBrowsable(list, title = title, start = s, endExclusive = e)
            s = e
        }
        return out
    }

    override fun html(): String = "<i>${escapeHtml(heading())}</i>"
}

private data class MapEntryRecord(
    val index: Int,
    val key: Any?,
    val value: Any?
)

private interface MapEntrySource {
    val size: Int
    fun slice(start: Int, endExclusive: Int): List<MapEntryRecord>
}

private class SnapshotMapEntrySource(map: Map<*, *>) : MapEntrySource {
    private val entries: List<Pair<Any?, Any?>> = map.entries.map { it.key to it.value }
    override val size: Int get() = entries.size

    override fun slice(start: Int, endExclusive: Int): List<MapEntryRecord> {
        val safeStart = start.coerceIn(0, size)
        val safeEnd = endExclusive.coerceIn(safeStart, size)
        if (safeStart >= safeEnd) return emptyList()
        val out = ArrayList<MapEntryRecord>(safeEnd - safeStart)
        for (i in safeStart until safeEnd) {
            val (k, v) = entries[i]
            out.add(MapEntryRecord(i, k, v))
        }
        return out
    }
}

private class IteratingMapEntrySource(private val map: Map<*, *>) : MapEntrySource {
    override val size: Int get() = map.size

    override fun slice(start: Int, endExclusive: Int): List<MapEntryRecord> {
        val safeStart = start.coerceIn(0, size)
        val safeEnd = endExclusive.coerceIn(safeStart, size)
        if (safeStart >= safeEnd) return emptyList()
        val out = ArrayList<MapEntryRecord>(safeEnd - safeStart)
        var index = 0
        for ((k, v) in map) {
            if (index >= safeEnd) break
            if (index >= safeStart) out.add(MapEntryRecord(index, k, v))
            index++
        }
        return out
    }
}

private class MapEntryBrowsable(private val record: MapEntryRecord) : Browsable {
    override fun heading(): String = "Entry [${record.index}]"

    override fun dir(): Map<String, Any?> {
        return linkedMapOf(
            "key" to wrapForInspector(record.key, "key"),
            "value" to wrapForInspector(record.value, "value")
        )
    }

    override fun html(): String {
        return "<div>Entry [${record.index}]</div>"
    }
}

private class PagedMapBrowsable(
    private val source: MapEntrySource,
    private val title: String? = null,
    private val start: Int = 0,
    private val endExclusive: Int = source.size
) : Browsable {

    companion object {
        fun forMap(map: Map<*, *>, title: String? = null): PagedMapBrowsable {
            val src = if (map.size <= H2_MAP_SNAPSHOT_THRESHOLD) SnapshotMapEntrySource(map) else IteratingMapEntrySource(map)
            return PagedMapBrowsable(src, title = title, start = 0, endExclusive = src.size)
        }
    }

    private val safeStart = start.coerceIn(0, source.size)
    private val safeEnd = endExclusive.coerceIn(safeStart, source.size)
    private val count = safeEnd - safeStart

    override fun heading(): String {
        val base = title ?: "Map"
        return if (safeStart == 0 && safeEnd == source.size) "$base (${source.size})" else "$base ${rangeLabel(safeStart, safeEnd)}"
    }

    override fun dir(): Map<String, Any?>? {
        if (count <= 0) return null
        if (count <= H2_MAP_LEAF_SIZE) {
            val out = LinkedHashMap<String, Any?>(count)
            source.slice(safeStart, safeEnd).forEach { entry ->
                out["[${entry.index}] ${keyPreview(entry.key)}"] = MapEntryBrowsable(entry)
            }
            return out
        }

        val childSpan = computeChildSpan(count, H2_MAP_LEAF_SIZE)
        val out = LinkedHashMap<String, Any?>()
        var s = safeStart
        while (s < safeEnd) {
            val e = minOf(s + childSpan, safeEnd)
            out[rangeLabel(s, e)] = PagedMapBrowsable(source, title = title, start = s, endExclusive = e)
            s = e
        }
        return out
    }

    override fun html(): String = "<i>${escapeHtml(heading())}</i>"
}

private class FloatBufferBrowsable(
    buffer: FloatBuffer,
    private val title: String? = null
) : Browsable {

    private val readOnly: FloatBuffer = buffer.asReadOnlyBuffer()
    private val position: Int = buffer.position()
    private val limit: Int = buffer.limit()
    private val capacity: Int = buffer.capacity()

    override fun heading(): String = title ?: "FloatBuffer"

    override fun dir(): Map<String, Any?> {
        val out = LinkedHashMap<String, Any?>()
        out["position"] = position
        out["limit"] = limit
        out["capacity"] = capacity

        for (stride in 1..16) {
            val rows = ceilDiv(limit, stride)
            out["stride $stride ($rows rows)"] = FloatBufferRowsBrowsable(
                buffer = readOnly,
                stride = stride,
                rowStart = 0,
                rowEndExclusive = rows,
                title = "stride $stride"
            )
        }
        return out
    }

    override fun html(): String {
        return "<div>FloatBuffer pos=$position limit=$limit capacity=$capacity</div>"
    }
}

private class FloatBufferRowsBrowsable(
    private val buffer: FloatBuffer,
    private val stride: Int,
    private val rowStart: Int,
    private val rowEndExclusive: Int,
    private val title: String
) : Browsable {

    private val safeStride = stride.coerceAtLeast(1)
    private val totalValues = buffer.limit()
    private val totalRows = ceilDiv(totalValues, safeStride)
    private val safeStart = rowStart.coerceIn(0, totalRows)
    private val safeEnd = rowEndExclusive.coerceIn(safeStart, totalRows)
    private val rowCount = safeEnd - safeStart

    override fun heading(): String {
        return "$title ${rangeLabel(safeStart, safeEnd)}"
    }

    override fun dir(): Map<String, Any?>? {
        if (rowCount <= 0) return null
        if (rowCount <= H2_FLOAT_ROWS_LEAF_SIZE) return null

        val childSpan = computeChildSpan(rowCount, H2_FLOAT_ROWS_LEAF_SIZE)
        val out = LinkedHashMap<String, Any?>()
        var s = safeStart
        while (s < safeEnd) {
            val e = minOf(s + childSpan, safeEnd)
            out[rangeLabel(s, e)] = FloatBufferRowsBrowsable(
                buffer = buffer,
                stride = safeStride,
                rowStart = s,
                rowEndExclusive = e,
                title = title
            )
            s = e
        }
        return out
    }

    override fun html(): String {
        if (rowCount <= 0) return "<i>empty</i>"
        if (rowCount > H2_FLOAT_ROWS_LEAF_SIZE) {
            return "<div>${escapeHtml(heading())}</div>"
        }

        return FieldMarkdown.card(
            """
            {muted:rows $safeStart..${safeEnd - 1} | stride $safeStride}

            ${bufferPageTable(safeStart, safeEnd, safeStride, totalValues) { fmtFloat(buffer.get(it)) }}
            """
        )
    }
}

private fun bufferPageTable(
    start: Int,
    end: Int,
    stride: Int,
    total: Int,
    cell: (Int) -> String,
): String {
    val columns = (0 until stride).map { it.toString() }
    val page = Table(listOf("row") + columns)
        .rows(
            (start until end).map { row ->
                listOf<Any?>(row) + columns.indices.map { c ->
                    val index = row * stride + c
                    if (index < total) cell(index) else null
                }
            }
        )
        .role("row", CellRole.ACCENT)
        .align("row", Align.LEFT)
    columns.forEach { page.align(it, Align.RIGHT) }
    page.maxRows = (end - start).coerceAtLeast(1)
    return page.toHTML()
}

private class IntBufferBrowsable(
    buffer: IntBuffer,
    private val title: String? = null
) : Browsable {

    private val readOnly: IntBuffer = buffer.asReadOnlyBuffer()
    private val position: Int = buffer.position()
    private val limit: Int = buffer.limit()
    private val capacity: Int = buffer.capacity()

    override fun heading(): String = title ?: "IntBuffer"

    override fun dir(): Map<String, Any?> {
        val out = LinkedHashMap<String, Any?>()
        out["position"] = position
        out["limit"] = limit
        out["capacity"] = capacity

        for (stride in 1..16) {
            val rows = ceilDiv(limit, stride)
            out["stride $stride ($rows rows)"] = IntBufferRowsBrowsable(
                buffer = readOnly,
                stride = stride,
                rowStart = 0,
                rowEndExclusive = rows,
                title = "stride $stride"
            )
        }
        return out
    }

    override fun html(): String {
        return "<div>IntBuffer pos=$position limit=$limit capacity=$capacity</div>"
    }
}

private class IntBufferRowsBrowsable(
    private val buffer: IntBuffer,
    private val stride: Int,
    private val rowStart: Int,
    private val rowEndExclusive: Int,
    private val title: String
) : Browsable {

    private val safeStride = stride.coerceAtLeast(1)
    private val totalValues = buffer.limit()
    private val totalRows = ceilDiv(totalValues, safeStride)
    private val safeStart = rowStart.coerceIn(0, totalRows)
    private val safeEnd = rowEndExclusive.coerceIn(safeStart, totalRows)
    private val rowCount = safeEnd - safeStart

    override fun heading(): String {
        return "$title ${rangeLabel(safeStart, safeEnd)}"
    }

    override fun dir(): Map<String, Any?>? {
        if (rowCount <= 0) return null
        if (rowCount <= H2_FLOAT_ROWS_LEAF_SIZE) return null

        val childSpan = computeChildSpan(rowCount, H2_FLOAT_ROWS_LEAF_SIZE)
        val out = LinkedHashMap<String, Any?>()
        var s = safeStart
        while (s < safeEnd) {
            val e = minOf(s + childSpan, safeEnd)
            out[rangeLabel(s, e)] = IntBufferRowsBrowsable(
                buffer = buffer,
                stride = safeStride,
                rowStart = s,
                rowEndExclusive = e,
                title = title
            )
            s = e
        }
        return out
    }

    override fun html(): String {
        if (rowCount <= 0) return "<i>empty</i>"
        if (rowCount > H2_FLOAT_ROWS_LEAF_SIZE) {
            return "<div>${escapeHtml(heading())}</div>"
        }

        return FieldMarkdown.card(
            """
            {muted:rows $safeStart..${safeEnd - 1} | stride $safeStride}

            ${bufferPageTable(safeStart, safeEnd, safeStride, totalValues) { buffer.get(it).toString() }}
            """
        )
    }
}

private fun escapeHtml(text: String): String {
    return text
        .replace("&", "&amp;")
        .replace("<", "&lt;")
        .replace(">", "&gt;")
        .replace("\"", "&quot;")
        .replace("'", "&#39;")
}

private fun escapeHtmlAttr(text: String): String = escapeHtml(text)