package afield.lang.nano

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 afield.runtime.TopologyWatcher
import afield.runtime.MainLanguageRuntime
import afield.runtime.applyRuntimeToggle
import afield.runtime.isMainLanguage
import afield.runtime.registerMainLanguageRuntime
import afield.document.properties.Delegation
import afield.document.properties.Inheritance
import io.ktor.websocket.WebSocketSession
import kotlinx.coroutines.delay
import kotlinx.coroutines.yield

    override fun launchAll(
        inside: Box, execute: Execute, code: String, strand: String, reply: (Message) -> Unit
    ) {
        val originSession = thisSession.get()
        val trace = ExecutionTrace.forEngine(inside, execute, "launch", reply)
        inMain {
            val wm = ++inside.fragmentGeneration

            configureOutputProxies(inside, trace.reply, originSession)
            val outputs = mutableListOf<Int>()
            var runtimeError: String? = null
            vm.onOutput = { value ->
                outputs += value and 0xFF
                inside.output.proxy(value.toString(), true, execute.line)
            }
            vm.onError = { msg, pcVal ->
                runtimeError = "Nano VM error at PC=0x${pcVal.toString(16).padStart(2, '0')}: $msg"
                inside.displayError(msg, line = execute.line, property = "code")
                lprintln("error,nano", runtimeError)
            }

            val result = assembler.assembleWithSourceMap(code)
            if (result is NanoAssembler.AssemblyDebugResult.Err) {
                clearStepDecoration()
                result.errors.forEach { e ->
                    inside.displayError(e.message, line = execute.line + e.line - 1, property = "code")
                }
                trace.finish(false, "the program did not assemble")
                send(Message("is-running").payload(IsRunning(execute.uid, false, wm, strand)))
                return@inMain
            }

            result as NanoAssembler.AssemblyDebugResult.Ok
            val assembly = result.info
            val program = assembly.bytes
            clearErrorStatus(reply, originSession)
            clearStepDecoration()

            val generation = inside.runGeneration.getOrPut(strand) { -1 } + 1
            inside.runGeneration[strand] = generation
            send(Message("is-running").payload(IsRunning(execute.uid, true, generation, strand)))

            val memoryBefore = loadProgramIntoVm(vm, program)
            inside.displayOpen("nano")

            var steps = 0
            var lastFocusedLine: Int? = null

            fun publishState(focusPc: Int, changedRegisters: Set<Int>, changedRam: Set<Int>) {
                val focusLine = assembly.pcToLine.getOrNull(focusPc)
                setStepDecoration(code, focusLine)
                if (focusLine != null && focusLine != lastFocusedLine) {
                    focusEditorLine(focusLine, originSession)
                    lastFocusedLine = focusLine
                }
                inside.nanoMemoryBefore = memoryBefore
                inside.nanoMemoryAfter = vm.ram.toList()
                send(
                    Message("set-output").payload(
                        Set_output(
                            inside.id,
                            "outputarea",
                            "nano",
                            vm.toNanoRunReport(
                                program = program,
                                source = code,
                                steps = steps,
                                outputs = outputs,
                                focusPc = focusPc,
                                focusLine = focusLine,
                                changedRegisters = changedRegisters,
                                changedRam = changedRam,
                                runtimeError = runtimeError
                            ).toHtml(
                                title = "Nano state",
                                includeSource = false,
                                includeDisassembly = true,
                                includeProgramBytes = true
                            )
                        )
                    )
                )
            }

            publishState(vm.pc, emptySet(), emptySet())

            // The program assembled, loaded and published its first state; the stepping loop below
            // is the run, not the setup. Same boundary Kotlin's launch receipt draws.
            trace.finish(runtimeError == null)

            inMain {
                try {
                    while (inside.runGeneration[strand] == generation && !vm.halted) {
                        delay(configuredStepDelayMs())
                        if (inside.runGeneration[strand] != generation || vm.halted) break

                        val previousRegisters = vm.reg.copyOf()
                        val previousRam = vm.ram.copyOf()
                        val stepResult = vm.stepOnce(program)
                        if (!stepResult.executed) break

                        steps++
                        publishState(
                            focusPc = stepResult.executedPc,
                            changedRegisters = diffChangedIndices(previousRegisters, vm.reg),
                            changedRam = diffChangedIndices(previousRam, vm.ram)
                        )
                    }
                } finally {
                    send(Message("is-running").payload(IsRunning(execute.uid, false, generation, strand)))
                }
            }
        }
    }

    override fun complete(inside: Box, completionRequest: CompletionRequest, reply: (Message) -> Unit) {
        val code = completionRequest.allCode
        val cursor = completionRequest.position.coerceIn(0, code.length)

        // Find the token being typed
        var start = cursor
        while (start > 0 && !code[start - 1].isWhitespace() && code[start - 1] != ',') start--
        val prefix = code.substring(start, cursor).lowercase()

        val completions = mutableListOf<Metadata>()

        // Mnemonics
        for ((mnemonic, info) in MNEMONIC_HELP) {
            if (mnemonic.startsWith(prefix)) {
                completions += Metadata(
                    icon = "keyword",
                    tail = "nano",
                    documentation = info,
                    text = mnemonic,
                    displayText = mnemonic
                )
            }
        }

        // Registers
        for (r in listOf("r0", "r1", "r2", "r3")) {
            if (r.startsWith(prefix)) {
                completions += Metadata(
                    icon = "variable",
                    tail = "reg",
                    documentation = "Nano 8-bit register $r (0–255)",
                    text = r,
                    displayText = r
                )
            }
        }

        // Labels from current code
        if (prefix.isNotEmpty() && prefix[0].isLetter()) {
            for (label in assembler.extractLabels(code)) {
                if (label.lowercase().startsWith(prefix)) {
                    completions += Metadata(
                        icon = "symbol",
                        tail = "label",
                        documentation = "Label '$label' defined in this program",
                        text = label,
                        displayText = label
                    )
                }
            }
        }

        if (completions.isNotEmpty()) {
            reply(
                Message("complete").payload(
                    Completion(
                        boundsStart = start,
                        boundsEnd = cursor,
                        metadata = completions
                    )
                )
            )
        }
    }

    private fun runNano(
        code: String,
        executeLine: Int,
        reply: (Message) -> Unit,
        originSession: WebSocketSession?,
        maxSteps: Int = 100_000
    ) {
        val result = assembler.assembleWithSourceMap(code)
        when (result) {
            is NanoAssembler.AssemblyDebugResult.Err -> {
                result.errors.forEach { e ->
                    inside.displayError(e.message, line = executeLine + e.line - 1, property = "code")
                }
                result.errors.firstOrNull()?.let { e ->
                    LastRunNotes.record(inside, "code", code, executeLine, emptyList(), stoppedAt = e.line, stopReason = e.message)
                }
            }
            is NanoAssembler.AssemblyDebugResult.Ok -> {
                clearErrorStatus(reply, originSession)
                val assembly = result.info
                val program = assembly.bytes
                val freshVm = NanoVM(maxSteps = maxSteps)
                val outputs = mutableListOf<Int>()
                var runtimeError: String? = null
                freshVm.onOutput = { value ->
                    outputs += value and 0xFF
                    vm.onOutput(value)
                }
                freshVm.onError = { msg, pc ->
                    runtimeError = "Nano VM error at PC=0x${pc.toString(16).padStart(2, '0')}: $msg"
                    vm.onError(msg, pc)
                }
                val memoryBefore = loadProgramIntoVm(freshVm, program)
                val trace = freshVm.runTracingLines(program, assembly.pcToLine)
                val steps = trace.steps
                LastRunNotes.record(inside, "code", code, executeLine, nanoLineNotes(assembly.pcToLine, trace),
                    stoppedAt = runtimeError?.let { assembly.pcToLine.getOrNull(freshVm.pc) }, stopReason = runtimeError)
                inside.nanoMemoryBefore = memoryBefore
                inside.nanoMemoryAfter = freshVm.ram.toList()
                val html = freshVm
                    .toNanoRunReport(
                        program = program,
                        source = code,
                        steps = steps,
                        outputs = outputs,
                        focusPc = freshVm.pc,
                        focusLine = assembly.pcToLine.getOrNull(freshVm.pc),
                        runtimeError = runtimeError
                    )
                    .toHtml(
                        title = "Nano state",
                        includeSource = false,
                        includeDisassembly = false,
                        includeProgramBytes = false
                    )
                dispatchExecutionOutput(
                    inside,
                    reply,
                    Output(
                        uid = inside.id,
                        line = executeLine + code.lines().size,
                        kind = "ok",
                        html = html,
                        frame = Runloop.runLoop.frame.toInt()
                    ),
                    originSession = originSession
                )
            }
        }
    }

    private fun diffChangedIndices(previous: IntArray, current: IntArray): Set<Int> {
        return previous.indices.filterTo(linkedSetOf()) { index -> previous[index] != current[index] }
    }

    private fun configuredStepDelayMs(): Long {
        val raw = runCatching { inside.nanoLaunchDelayMs }.getOrNull()
        return raw?.toLong()?.coerceAtLeast(0L) ?: stepDelayMs
    }

    private fun loadProgramIntoVm(machine: NanoVM, program: ByteArray): List<Int> {
        machine.load(program)
        applyConfiguredMemory(machine.ram, runCatching { inside.nanoMemoryInit }.getOrNull())
        return machine.ram.toList()
    }

    private fun applyConfiguredMemory(memory: IntArray, spec: Any?) {
        when (spec) {
            null -> return
            is ByteArray -> spec.forEachIndexed { index, value -> writeMemoryValue(memory, index, value.toInt()) }
            is ShortArray -> spec.forEachIndexed { index, value -> writeMemoryValue(memory, index, value.toInt()) }
            is IntArray -> spec.forEachIndexed { index, value -> writeMemoryValue(memory, index, value) }
            is LongArray -> spec.forEachIndexed { index, value -> writeMemoryValue(memory, index, value.toInt()) }
            is FloatArray -> spec.forEachIndexed { index, value -> writeMemoryValue(memory, index, value.toInt()) }
            is DoubleArray -> spec.forEachIndexed { index, value -> writeMemoryValue(memory, index, value.toInt()) }
            is Array<*> -> spec.forEachIndexed { index, value -> value.asNanoByteOrNull()?.let { writeMemoryValue(memory, index, it) } }
            is Iterable<*> -> spec.forEachIndexed { index, value -> value.asNanoByteOrNull()?.let { writeMemoryValue(memory, index, it) } }
            is Map<*, *> -> spec.forEach { (address, value) ->
                val addr = address.asNanoIndexOrNull() ?: return@forEach
                val byte = value.asNanoByteOrNull() ?: return@forEach
                writeMemoryValue(memory, addr, byte)
            }
            else -> lprintln("warning,nano", "Ignoring unsupported nanoMemoryInit value of type ${spec::class.simpleName}")
        }
    }

    private fun writeMemoryValue(memory: IntArray, index: Int, value: Int) {
        if (memory.isEmpty()) return
        memory[index and (memory.size - 1)] = value and 0xFF
    }

    private fun Any?.asNanoIndexOrNull(): Int? {
        return when (this) {
            is Number -> this.toInt()
            is String -> this.trim().toIntOrNull()
            else -> null
        }
    }

    private fun Any?.asNanoByteOrNull(): Int? {
        return when (this) {
            is Number -> this.toInt() and 0xFF
            is String -> parseNanoStringNumber(this)
            else -> null
        }
    }

    private fun parseNanoStringNumber(text: String): Int? {
        val trimmed = text.trim()
        if (trimmed.isEmpty()) return null
        val parsed = when {
            trimmed.startsWith("-0x", ignoreCase = true) ->
                trimmed.substring(3).toIntOrNull(16)?.let { -it }
            trimmed.startsWith("0x", ignoreCase = true) ->
                trimmed.substring(2).toIntOrNull(16)
            else -> trimmed.toIntOrNull()
        } ?: return null
        return parsed and 0xFF
    }

    private fun clearStepDecoration() {
        inside.decorationState.remove(stepDecorationKey)
    }

    private fun setStepDecoration(code: String, focusLine: Int?) {
        if (focusLine == null) {
            clearStepDecoration()
            return
        }
        val lines = code.lines()
        if (focusLine !in 1..lines.size) {
            clearStepDecoration()
            return
        }
        val lineText = lines[focusLine - 1]
        val endColumn = maxOf(1, lineText.length + 1)
        val className = "nanoStep_${inside.id}".map { if (it.isLetterOrDigit()) it else '_' }.joinToString("")
        val css = """
            .${className} {
                background: rgba(217, 115, 38, 0.10);
                border-bottom: 1px solid rgba(217, 115, 38, 0.95);
                border-radius: 2px;
            }
        """.trimIndent().replace("\n", " ")
        inside.decorationState[stepDecorationKey] = RawDecoration(
            lineStart = focusLine,
            colStart = 1,
            lineEnd = focusLine,
            colEnd = endColumn,
            classname = className,
            classDef = mapOf(className to css)
        )
    }

    private fun focusEditorLine(line: Int, originSession: WebSocketSession?) {
        val message = Message("select-and-edit-box").payload(
            SelectAndEditBox(
                uid = inside.id,
                property = "code",
                scrollToLine = line,
                highlightLine = line
            )
        )
        if (originSession != null) {
            _send(originSession, message)
        } else {
            send(message)
        }
    }
}

private val MNEMONIC_HELP: Map<String, String> = mapOf(
    "nop"   to "No operation",
    "hlt"   to "Halt the VM",
    "ret"   to "Return from CALL (pop return address)",
    "inc"   to "inc rX  — increment register rX (wraps mod 256)",
    "dec"   to "dec rX  — decrement register rX (wraps mod 256)",
    "not"   to "not rX  — bitwise NOT of rX",
    "neg"   to "neg rX  — two's-complement negate of rX",
    "clr"   to "clr rX  — clear register rX (set to 0)",
    "out"   to "out rX  — print value of rX as decimal",
    "rng"   to "rng rX  — fill rX with a pseudorandom byte (0–255)",
    "mov"   to "mov rD, rS  — rD = rS",
    "add"   to "add rD, rS  — rD = rD + rS  (wraps mod 256; sets Z/C/S)",
    "sub"   to "sub rD, rS  — rD = rD - rS  (wraps; sets Z/C/S)",
    "mul"   to "mul rD, rS  — rD = (rD * rS) & 0xFF  (sets Z/C)",
    "and"   to "and rD, rS  — rD = rD & rS  (bitwise AND)",
    "or"    to "or  rD, rS  — rD = rD | rS  (bitwise OR)",
    "xor"   to "xor rD, rS  — rD = rD ^ rS  (bitwise XOR)",
    "cmp"   to "cmp rD, rS  — set flags from (rD - rS); registers unchanged",
    "ldr"   to "ldr rD, rS  — rD = RAM[rS]  (load indirect)",
    "str"   to "str rD, rS  — RAM[rD] = rS  (store indirect)",
    "div"   to "div rD, rS  — rD = rD / rS  (integer; rS=0 → rD=0xFF)",
    "ldi"   to "ldi rX, N   — rX = N  (load immediate byte, 0–255)",
    "lda"   to "lda rX, A   — rX = RAM[A]  (load from absolute address 0–31)",
    "sta"   to "sta rX, A   — RAM[A] = rX  (store to absolute address 0–31)",
    "addi"  to "addi rX, N  — rX += N  (signed immediate, -128..127)",
    "ldrr"  to "ldrr rX, N  — rX = RAM[PC + N]  (PC-relative load, N signed)",
    "strr"  to "strr rX, N  — RAM[PC + N] = rX  (PC-relative store, N signed)",
    "shl"   to "shl rX, N   — rX <<= N  (logical shift left)",
    "shr"   to "shr rX, N   — rX >>= N  (logical shift right)",
    "jmp"   to "jmp label   — unconditional relative jump",
    "jz"    to "jz  label   — jump if Zero flag (last result == 0)",
    "jnz"   to "jnz label   — jump if not Zero",
    "jgt"   to "jgt label   — jump if > 0 (not zero and not negative)",
    "jlt"   to "jlt label   — jump if < 0 (negative / sign flag set)",
    "jge"   to "jge label   — jump if >= 0 (not negative)",
    "jle"   to "jle label   — jump if <= 0 (zero or negative)",
    "jc"    to "jc  label   — jump if Carry flag set",
    "jnc"   to "jnc label   — jump if Carry flag clear",
    "call"  to "call label  — relative call (push return address, jump)",
    "jmpa"  to "jmpa label  — absolute jump (0–255)",
    "calla" to "calla label — absolute call (push return address, absolute jump)",
    ".data" to ".data b0 b1 …  — emit raw bytes into the program stream"
)