const fs = require("fs")

const path = require("path")

const child_process = require("child_process")

const ctest = "jacs/compiler-tests"

const samples = "jacs/samples"

const rtest = "jacs/run-tests"

const distPath = "built"

let verbose = false

let useC = false

let testMode = false

let doDeploy = false

let disassemble = false

let logParse = false

let serialPort = ""

let jacsFile = ""

let isLibrary = false

function jacsFactory() {

d = require("@devicescript/vm")

try {

require("websocket-polyfill")

// @ts-ignore

global.Blob = require("buffer").Blob

} catch {

console.log("can't load websocket-polyfill")

}

return d()

}

let jacsHost

async function getHost() {

if (jacsHost) return jacsHost

const inst = await jacsFactory()

inst.jacsInit()

const specs = JSON.parse(

fs.readFileSync("runtime/jacdac-c/jacdac/dist/services.json", "utf8")

)

jacsHost = {

write: (fn, cont) => {

fs.writeFileSync(path.join(distPath, fn), cont)

if (fn.endsWith(".jasm") && cont.indexOf("???oops") >= 0)

throw new Error("bad disassembly")

},

log: msg => {

if (verbose) console.log(msg)

},

mainFileName: () => jacsFile,

getSpecs: () => specs,

verifyBytecode: buf => {

if (useC) return

const res = inst.jacsDeploy(buf)

if (res != 0) throw new Error("verification error: " + res)

},

}

return jacsHost

}

async function compile(buf) {

const compiler = require("./compiler/built/devicescript-compiler.node.cjs")

const host = await getHost()

const res = compiler.compile(buf.toString("utf8"), { host, isLibrary })

if (!res.success) throw new Error("compilation failed")

return res.binary

}

async function readCompiled(fn) {

const buf = fs.readFileSync(fn)

if (buf.slice(0, 8).toString("hex") == "4a6163530a7e6a9a") return buf

if (buf.slice(0, 16).toString("binary") == "4a6163530a7e6a9a")

return Buffer.from(buf.toString("binary").replace(/\s*/g, ""), "hex")

jacsFile = fn

return await compile(buf)

}

async function runTest(fn) {

const prog = await readCompiled(fn)

const inst = await jacsFactory()

const devid = "12abdd2289421234"

return new Promise((resolve, reject) => {

// both handlePacket and sendPacket take UInt8Array of the frame

// addEventListener("message", ev => inst.handlePacket(ev.data))

// inst.sendPacket = pkt => console.log("send", pkt)

inst.sendPacket = pkt => {

// only react to packets from our device

if (!Buffer.from(devid, "hex").equals(pkt.slice(4, 4 + 8))) return

const idx = pkt[13]

const cmd = pkt[14] | (pkt[15] << 8)

// see if it's "panic event"

if (idx == 2 && cmd & 0x8000 && (cmd & 0xff) == 0x80) {

const panic_code = pkt[16] | (pkt[16] << 8)

if (panic_code) {

console.log("test failed")

resolve = null

reject(new Error("test failed"))

} else {

console.log("test OK")

const f = resolve

resolve = null

f()

}

}

}

inst.jacsSetDeviceId(devid) // use 8-byte hex-encoded ID (used directly), or any string (hashed)

inst.jacsStart()

inst.jacsDeploy(prog)

setTimeout(() => {

if (resolve) {

console.log("timeout")

reject(new Error("timeout"))

}

}, 2000)

})

}

async function runServer(args) {

const fn = args.shift()

if (logParse) {

const compiler = require("./compiler/built/devicescript-compiler.node.cjs")

const fsp = require("node:fs/promises")

const h = await fsp.open(fn, "r")

const r = await compiler.parseLog((off, size) => {

const r = Buffer.alloc(size)

return h.read(r, 0, r.length, off).then(() => r)

})

console.log(await r.dump())

const genidx = parseInt(args[0])

if (genidx) {

const gen = await r.generation(genidx)

if (args[1] == "stats") console.log(await gen.computeStats())

else await gen.forEachEvent()

}

return

}

if (useC) {

const prog = await readCompiled(fn)

const compfn = distPath + "/compiled.jacs"

fs.writeFileSync(compfn, prog)

const args = [compfn]

if (testMode) args.unshift("-X")

if (serialPort) args.unshift(serialPort)

else if (!testMode) args.unshift("8082")

console.log("run", args)

const child = child_process.spawn("runtime/built/jdcli", args, {

stdio: "inherit",

})

child.on("exit", (code, err) => {

if (!code && err) code = 2

process.exit(code)

})

testMode = false

return

}

if (disassemble) {

const prog = await readCompiled(fn)

console.log(require("./compiler/built/devicescript-compiler.node.cjs").disassemble(prog))

return

}

if (isLibrary) {

const prog = await readCompiled(fn)

return

}

const inst = await jacsFactory()

if (testMode) inst.sendPacket = () => {}

else await inst.setupNodeTcpSocketTransport(require, "127.0.0.1", 8082)

inst.jacsStart()

if (fn) {

const prog = await readCompiled(fn)

const r = doDeploy ? inst.jacsClientDeploy(prog) : inst.jacsDeploy(prog)

if (r) throw new Error("deploy error: " + r)

console.log(`deployed ${fn}`)

} else {

console.log(`waiting for external deploy`)

}

}

function readdir(folder) {

return fs.readdirSync(folder).map(bn => path.join(folder, bn))

}

async function main() {

const args = process.argv.slice(2)

try {

fs.mkdirSync(distPath)

} catch {}

while (true) {

if (args[0] == "-v") {

args.shift()

verbose = true

continue

}

if (args[0] == "-c") {

args.shift()

useC = true

continue

}

if (args[0] == "-t") {

args.shift()

testMode = true

continue

}

if (args[0] == "-d") {

args.shift()

doDeploy = true

continue

}

if (args[0] == "-D") {

args.shift()

disassemble = true

continue

}

if (args[0] == "-p") {

args.shift()

logParse = true

continue

}

if (args[0] == "-L") {

args.shift()

isLibrary = true

continue

}

if (args[0] && args[0].startsWith("-s:")) {

serialPort = args[0].slice(3)

useC = true

args.shift()

continue

}

break

}

try {

if (args[0] == "empty") {

const buf = await compile(Buffer.from(""))

let r = `__attribute__((aligned(sizeof(void *)))) static const uint8_t devs_empty_program[${buf.length}] = {`

for (let i = 0; i < buf.length; ++i) {

if ((i & 15) == 0) r += "\n"

r += "0x" + ("0" + buf[i].toString(16)).slice(-2) + ", "

}

r += "\n};"

console.log(r)

} else if (args[0] == "test") {

testMode = true

const host = await getHost()

const compiler = require("./compiler/built/devicescript-compiler.node.cjs")

for (const fn of readdir(ctest).concat(readdir(samples))) {

console.log(`*** test ${fn}`)

jacsFile = fn

compiler.testCompiler(host, fs.readFileSync(fn, "utf8"))

}

for (const fn of readdir(rtest)) {

console.log(`*** run ${fn}`)

await runTest(fn)

}

} else {

await runServer(args)

}

} catch (e) {

console.error(e.stack)

process.exit(2)

}

if (testMode) process.exit(0)

}

main()