executing.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.server.Server.Companion.stop
import afield.app.diagnostics.logging.lprintln
import afield.runtime.kotlin.SpareEngines
import java.util.concurrent.atomic.AtomicBoolean
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.decodeFromJsonElement

private fun clearEditorOutputsForLaunch(uid: String) {
    send(Message("clear-editor-outputs").payload(ClearEditorOutputs(uid)))
}

@RunsAt(installHandlers)
fun executing() {

    handlers["stop-box"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->

            val exec = Json.decodeFromJsonElement<Stop_box>(message.payload!!)
            stopBoxRequest(box(exec.uid), entrypoint = "stop-box")

            Handled.yes
        })

    handlers["execute-fragment"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->
            val exec = Json.decodeFromJsonElement<Execute>(message.payload!!)
            val box = inItsLanguage(box(exec.uid))
            FlightRecorder.recordExecuteEntrypoint("execute-fragment", box, exec)
            OperationTranscript.recordExecuteFragment(box, exec)
            box.ke.executeFragment(box, exec, verdictTimed("execute.fragment", System.nanoTime(), box.id, reply))
            Handled.yes
        })

    handlers["execute-symbol"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->
            val exec = Json.decodeFromJsonElement<ExecuteSymbol>(message.payload!!)
            val box = inItsLanguage(box(exec.uid))
            FlightRecorder.recordExecuteSymbolEntrypoint("execute-symbol", box, exec)
            box.ke.executeSymbol(box, exec, reply)
            Handled.yes
        })

    handlers["execute-all"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->

            val exec = Json.decodeFromJsonElement<Execute>(message.payload!!)
            executeAllRequest(box(exec.uid), exec, reply, thisSession.get(), thisSessionInfo.get())

            Handled.yes
        })

    handlers["launch-all"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->

            val exec = Json.decodeFromJsonElement<Execute>(message.payload!!)
            launchAllRequest(box(exec.uid), exec, reply)

            Handled.yes
        })

    handlers["launch-batch"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->

            val batch = Json.decodeFromJsonElement<ExecuteBatch>(message.payload!!)
            val requests = batch.executions.map { exec ->
                val box = inItsLanguage(box(exec.uid))
                FlightRecorder.recordLaunchEntrypoint("launch-batch", box, exec, strand = exec.strand)
                OperationTranscript.recordLaunch(box, exec, strand = exec.strand)
                box to exec
            }
            requests.map { it.second.uid }.distinct().forEach(::clearEditorOutputsForLaunch)

            val kotlinRequests = requests.filter { it.first.ke is KotlinExecution }
            if (kotlinRequests.size == requests.size) {
                KotlinExecution.launchBatch(kotlinRequests, reply)
            } else {
                requests.forEach { (box, exec) ->
                    box.ke.launchAll(box, exec, exec.code, strand = exec.strand, reply)
                }
            }

            Handled.yes
        })

    handlers["continue-all"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->

            val exec = Json.decodeFromJsonElement<Execute>(message.payload!!)
            val box = inItsLanguage(box(exec.uid))

            FlightRecorder.recordLaunchEntrypoint("continue-all", box, exec, strand = "default")
            box.ke.continueAll(box, exec, exec.code, "default", reply)


            Handled.yes
        })

    handlers["launch-fragment"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->

            val exec = Json.decodeFromJsonElement<Execute>(message.payload!!)
            val box = inItsLanguage(box(exec.uid))

            clearEditorOutputsForLaunch(exec.uid)
            FlightRecorder.recordLaunchEntrypoint("launch-fragment", box, exec, strand = exec.strand)
            OperationTranscript.recordLaunch(box, exec, strand = exec.strand)
            box.ke.launchAll(box, exec, exec.code, strand = exec.strand, reply)

            Handled.yes
        })

    // Dispatched on the websocket's coroutine, not the Runloop, so it works while box code has the
    // Runloop blocked: the box's next loop back-edge or call throws (afield.runtime.lifecycle.BoxInterrupt).
    handlers["interrupt-box"] = mutableSetOf(
        { _, _: (Message) -> Unit ->
            val asked = afield.runtime.lifecycle.BoxInterrupt.request("Interrupt Running Box command")
            lprintln("info,execution,interrupt", "interrupt-box requested=$asked")
            Handled.yes
        })

    handlers["stop-all"] = mutableSetOf(
        { message, reply: (Message) -> Unit ->

            val exec = Json.decodeFromJsonElement<Execute>(message.payload!!)
            val box = inItsLanguage(box(exec.uid))

            lprintln(
                "info,execution",
                "stop all has been called for '${box.name}' (${box.id}) strand=${exec.strand}"
            )

            OperationTranscript.recordStop(box)
            stop(box, entrypoint = "stop-all")

            Handled.yes
        })
}