JSONProcess.kt

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

package afield.io.process

import afield.data.collections.invoke
import afield.data.collections.times
import afield.document.graph.minusAssign
import afield.document.graph.plusAssign
import afield.document.properties.compareTo
import afield.document.workspace.file
import afield.geometry.mesh.expanded
import afield.graphics.render.rangeTo
import afield.math.autodiff.compareTo
import afield.math.autodiff.div
import afield.math.autodiff.minus
import afield.math.autodiff.plus
import afield.math.autodiff.times
import afield.math.linalg.invoke
import afield.math.linalg.remAssign
import afield.math.linalg.times
import afield.math.units.div
import afield.math.units.minus
import afield.math.units.plus
import afield.math.units.times

import afield.audio.synth.*
import afield.data.collections.get
import afield.document.workspace.path
import afield.math.linalg.set
import afield.runtime.execution.start
import afield.document.graph.Box
import afield.runtime.execution.ReturnValueRegistry
import afield.runtime.lifecycle.RunsAt
import afield.app.diagnostics.logging.lprintln
import afield.document.graph.registerLaunchJob
import afield.runtime.lifecycle.returnValueRegistration
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.currentCoroutineContext
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.json.JSONObject
import java.io.File
import java.util.concurrent.atomic.AtomicReference
import kotlin.concurrent.thread

    internal suspend fun runForBox(box: Box, strand: String, generation: Int) {
        stop()

        if (command.isEmpty()) {
            lastErrorRef.set("No command provided")
            return
        }

        val resolvedCommand = command.mapIndexed { index, part ->
            if (index == 0) expandUserPath(part).path else part
        }

        val started = try {
            ProcessBuilder(resolvedCommand).apply {
                workingDirectoryFile?.let(::directory)
                environment().putAll(env)
            }.start()
        } catch (t: Throwable) {
            val message = t.message ?: t.toString()
            lastErrorRef.set("Failed to start process: $message")
            lprintln("error,jsonprocess", "Failed to start ${resolvedCommand.joinToString(" ")}: $message")
            return
        }

        process = started
        running = true
        exitCode = null
        lastErrorRef.set(null)

        val completionHandle = currentCoroutineContext()[Job]?.invokeOnCompletion {
            stop()
        }

        try {
            val stdoutThread = thread(name = "json-process-stdout", isDaemon = true) {
                runCatching {
                    started.inputStream.bufferedReader().useLines { lines ->
                        lines.forEach(::handleStdoutLine)
                    }
                }
            }
            val stderrThread = thread(name = "json-process-stderr", isDaemon = true) {
                runCatching {
                    started.errorStream.bufferedReader().useLines { lines ->
                        lines.forEach(::handleStderrLine)
                    }
                }
            }

            while (started.isAlive && insideLifecycleStillValid(box, strand, generation)) {
                delay(50)
            }

            if (started.isAlive) {
                destroyProcess(started)
            }

            exitCode = withContext(Dispatchers.IO) { started.waitFor() }
            stdoutThread.join(250)
            stderrThread.join(250)
        } finally {
            completionHandle?.dispose()
            process = null
            running = false
        }
    }

    @Synchronized
    fun stop() {
        val proc = process ?: return
        destroyProcess(proc)
        process = null
        running = false
    }

    private fun handleStdoutLine(line: String) {
        latestStdoutLineRef.set(line)
        val trimmed = line.trim()
        if (trimmed.isEmpty()) return

        try {
            JSONObject(trimmed)
            latestJsonLineRef.set(trimmed)
            lastErrorRef.set(null)
        } catch (t: Throwable) {
            val message = "Ignoring non-JSON stdout line: ${t.message ?: trimmed}"
            lastErrorRef.set(message)
            lprintln("warn,jsonprocess", message)
        }
    }

    private fun handleStderrLine(line: String) {
        latestStderrLineRef.set(line)
        if (line.isNotBlank()) {
            lastErrorRef.set(line)
            lprintln("warn,jsonprocess", line)
        }
    }

    private fun insideLifecycleStillValid(box: Box, strand: String, generation: Int): Boolean {
        return running && box.runGeneration[strand] == generation
    }

    private fun destroyProcess(process: Process) {
        runCatching {
            process.destroy()
            if (!process.waitFor(250, java.util.concurrent.TimeUnit.MILLISECONDS)) {
                process.destroyForcibly()
                process.waitFor(250, java.util.concurrent.TimeUnit.MILLISECONDS)
            }
        }
    }

    private fun expandUserPath(path: String): File {
        if (path == "~") return File(System.getProperty("user.home"))
        if (path.startsWith("~/")) return File(System.getProperty("user.home"), path.removePrefix("~/"))
        return File(path)
    }
}