templating.kt

package afield.app.server

import afield.ai.agent.*
import afield.ai.conversation.*
import afield.ai.tools.*
import afield.animation.gesture.*
import afield.animation.interpolation.*
import afield.animation.keyframes.*
import afield.app.diagnostics.*
import afield.app.notifications.*
import afield.app.protocol.*
import afield.app.server.*
import afield.app.settings.*
import afield.audio.synth.*
import afield.data.table.*
import afield.document.context.*
import afield.document.graph.*
import afield.document.history.*
import afield.document.persistence.*
import afield.document.properties.*
import afield.document.workspace.*
import afield.graphics.color.*
import afield.graphics.paint.*
import afield.graphics.vulkan.*
import afield.math.functions.*
import afield.media.capture.*
import afield.media.stream.*
import afield.media.video.*
import afield.runtime.completion.*
import afield.runtime.execution.*
import afield.runtime.kotlin.*
import afield.runtime.lifecycle.*
import afield.tools.automation.*
import afield.tools.docs.*
import afield.ui.controls.*
import afield.ui.layout.*
import afield.ui.notation.*
import afield.ui.output.*
import afield.ui.output.templates.*
import afield.ui.slides.*
import afield.ui.visualization.*
import afield.app.diagnostics.logging.lprintln
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.decodeFromJsonElement
import kotlinx.serialization.json.encodeToJsonElement
import java.io.File
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.time.Duration
import java.util.concurrent.ConcurrentHashMap
import kotlin.uuid.ExperimentalUuidApi
import kotlin.uuid.Uuid

private fun extractTemplateMetadata(templatePath: String, templateName: String, source: String): TemplateMetadata? {
    try {
        val file = File(templatePath)
        if (!file.exists()) return null

        val lastModified = file.lastModified()
        val ednContent = file.readText()

        val directory = file.parentFile?.absolutePath ?: File(".").absolutePath
        val savingContext = SavingContext()
        val transfers = savingContext.readEdnTransfersFromString(ednContent)

        // Sort boxes by frame.y (increasing) without instantiating boxes
        val sortedTransfers = transfers.sortedBy { transfer ->
            val frame = savingContext.resolveStoredValue(transfer.properties["frame"], directory) as? Rect
            frame?.y ?: 0.0
        }

        // Sidecar-able properties (excluding "code")
        val sidecarProperties = listOf(
            "vertex",
            "fragment",
            "vertex_fragment",
            "compute",
            "task",
            "mesh",
            "raygen",
            "miss",
            "closesthit",
            "anyhit",
            "intersection",
            "callable",
            "vertex_s",
            "fragment_s",
            "compute_s",
            "task_s",
            "mesh_s",
            "raygen_s",
            "miss_s",
            "closesthit_s",
            "anyhit_s",
            "intersection_s",
            "callable_s"
        )

        // Build documentation from metadata properties
        val docBuilder = StringBuilder()

        sortedTransfers.forEach { transfer ->
            val metadata = savingContext.resolveStoredValue(transfer.properties["metadata"], directory) as? String
            if (!metadata.isNullOrEmpty()) {
                try {
                    val parsed = parseMetadata(metadata)

                    parsed["doc"]?.let { doc ->
                        if (doc.toString().isNotEmpty()) {
                            docBuilder.append(doc.toString().trim()).append("\n\n")
                        }
                    }

                    parsed["docPreamble"]?.let { preamble ->
                        if (preamble.toString().isNotEmpty()) {
                            docBuilder.append(preamble.toString().trim()).append("\n\n")
                        }
                    }

                    parsed["boxPreamble"]?.let { boxPreamble ->
                        if (boxPreamble.toString().isNotEmpty()) {
                            docBuilder.append(boxPreamble.toString().trim()).append("\n\n")
                        }
                    }
                } catch (e: Exception) {
                    // Ignore metadata parsing errors
                }
            }
        }

        // Add compressed box description
        val rawDescriptions = sortedTransfers.mapNotNull { transfer ->
            val boxName = savingContext.resolveStoredValue(transfer.properties["name"], directory)
                ?.toString()
                ?.takeIf { it.isNotEmpty() }
                ?: return@mapNotNull null

            // Find which sidecar properties this box has
            val properties = sidecarProperties.filter { prop ->
                val value = savingContext.resolveStoredValue(transfer.properties[prop], directory)
                value is String && value.trim().isNotEmpty()
            }

            if (properties.isEmpty()) {
                boxName
            } else {
                "$boxName/{${properties.joinToString(",")}}"
            }
        }

        // Compress repeated names to reduce noise (e.g., "Untitled x5")
        val boxDescriptions = LinkedHashMap<String, Int>().apply {
            rawDescriptions.forEach { desc ->
                this[desc] = (this[desc] ?: 0) + 1
            }
        }.map { (desc, count) ->
            if (count > 1) "$desc × $count" else desc
        }

        if (boxDescriptions.isNotEmpty()) {
            if (docBuilder.isNotEmpty()) {
                docBuilder.appendLine()
            }
            docBuilder.append("Boxes: ${boxDescriptions.joinToString(", ")}")
        }

        return TemplateMetadata(
            name = templateName,
            lastModified = lastModified,
            boxDocumentation = docBuilder.toString().trim(),
            source = source
        )
    } catch (e: Exception) {
        lprintln("warning,template", "Failed to extract metadata for $templateName: ${e.message}")
        return null
    }
}

@OptIn(ExperimentalUuidApi::class)
@RunsAt(installHandlers)
fun templating() {
    // Initialize remote template servers in the background
    initializeTemplateServers()
    handlers["request-templates"] = mutableSetOf({ message, reply ->
        // This runs on the Netty event loop serving the page's websocket, and the listing reads every
        // document in the workspace. It touches no session state, so it runs off the loop and replies
        // from there; a throw still replies, with an empty list, so the palette is never left waiting.
        val currentDocument = thisSessionInfo.get()?.filename
        templateIoScope.launch {
            reply(Message("list").payload(templateListingOrEmpty { listTemplatesWithMetadata(currentDocument) }))
        }
        Handled.yes
    })

    handlers["insert-template"] = mutableSetOf({ message, reply ->

        val exec = Json.decodeFromJsonElement<Directory>(message.payload!!)

        val localTemplates = localTemplateEntries(templateRoots(home, app)).associateBy { it.name }

        val session = thisSession.get()
        val si = thisSessionInfo.get()

        // Inserts the whole request as one unit (the mouse translation is over all of its boxes).
        // `downloaded` holds each remote template's (server, metadata.edn), or null when no server served it.
        fun insert(downloaded: Map<String, Pair<String, String>?>) {
            val loadedBoxes = exec.value.flatMap { templateName ->
                val local = localTemplates[templateName]
                val boxes = if (local != null) {
                    insertTemplateInto(si, templateName, local.path)
                } else {
                    val remote = downloaded[templateName]
                    if (remote == null) {
                        if (templateName in downloaded) notify("Could not download template '$templateName'", "error")
                        else notify("No template named '$templateName'", "error")
                        emptySet()
                    } else {
                        val (serverUrl, ednContent) = remote
                        // Use same ID transformation as cloneInto to generate new UUIDs
                        val seen = mutableMapOf<String, String>("root" to "root")
                        SavingContext().loadFromEdnText(
                            ednContent,
                            si.filename,
                            filterId = { id ->
                                seen.computeIfAbsent(id) { Uuid.random().toString() }
                            }
                        ).also { lprintln("info,template", "Imported template '$templateName' from remote server $serverUrl") }
                    }
                }

                // Set templateId on all loaded boxes
                boxes.forEach { box ->
                    box.templateId = templateName
                }

                boxes
            }

            // Calculate center of mass and translate boxes to mouse position if provided
            if (loadedBoxes.isNotEmpty() && exec.mouseX != null && exec.mouseY != null) {
                // Only translate top-level boxes, not nested children. Nested boxes have frames that are
                // relative to their parent's position (offset by -parent.x, -(parent.y + parent.h)).
                // Translating them would incorrectly add the offset twice since they move with their parent.
                val nestedBoxes = loadedBoxes.flatMap { it.nested }.toSet()
                val topLevelBoxes = loadedBoxes.filter { it !in nestedBoxes }

                if (topLevelBoxes.isNotEmpty()) {
                    // Calculate center of mass (average of all top-level box centers)
                    val centers = topLevelBoxes.map { box ->
                        val frame = box.frame
                        Pair(frame.cx, frame.cy)
                    }

                    val centerX = centers.map { it.first }.average()
                    val centerY = centers.map { it.second }.average()

                    // Calculate translation needed to move center of mass to mouse position
                    val deltaX = exec.mouseX - centerX
                    val deltaY = exec.mouseY - centerY

                    // Apply translation only to top-level boxes
                    topLevelBoxes.forEach { box ->
                        val frame = box.frame
                        box.frame = frame.copy(x = frame.x + deltaX, y = frame.y + deltaY)
                    }

                    lprintln("info,templating", "Translated ${topLevelBoxes.size} boxes by ($deltaX, $deltaY) to center at mouse position (${exec.mouseX}, ${exec.mouseY})")
                }
            }

            loadedBoxes.forEach { box ->
                box.resyncAll()
            }
            si.topologyGeneration++
            si.autorunBoxes(loadedBoxes)
        }

        val remoteNames = exec.value.filter { name ->
            name !in localTemplates && remoteTemplatesCache.values.any { name in it }
        }
        if (remoteNames.isEmpty()) {
            insert(emptyMap())
        } else {
            // The download leaves this socket's event loop; the insertion comes back to the session, so it
            // stays serialised with the session's other handlers. Messages that arrive during the download
            // are handled first, which is the point: the socket keeps answering, keepalive pongs included.
            templateIoScope.launch {
                val downloaded = remoteNames.associateWith { name ->
                    remoteTemplatesCache.entries.filter { name in it.value }.firstNotNullOfOrNull { (serverUrl, _) ->
                        downloadTemplateFromServer(serverUrl, name)?.let { serverUrl to it }
                    }
                }
                session.launch {
                    thisSession.set(session)
                    thisSessionInfo.set(si)
                    try {
                        insert(downloaded)
                    } catch (t: Throwable) {
                        t.printStackTrace()
                    }
                }
            }
        }

        Handled.yes
    })

    handlers["save-as-template"] = mutableSetOf({ message, reply ->
        val request = Json.decodeFromJsonElement<SaveAsTemplate>(message.payload!!)

        val selectedBoxes = request.uids.mapNotNull { uid -> box(uid) }.toSet()
        if (selectedBoxes.isEmpty()) {
            notify("No valid boxes found for template", "error")
        } else {
            try {
                // Recursively collect all nested boxes
                val boxesWithNested = collectAllNestedBoxes(selectedBoxes)
                val templatesDir = "$home/templates"
                File(templatesDir).mkdirs()
                SavingContext().saveAsTemplate(request.templateName, boxesWithNested, templatesDir)
                val countMessage = formatBoxCountMessage(selectedBoxes.size, boxesWithNested.size)
                notify("Template saved: ${request.templateName} ($countMessage)", "success")
            } catch (e: Exception) {
                notify("Failed to save template: ${e.message}", "error")
            }
        }
        Handled.yes
    })
}