import { writeFileSync } from "fs"

import { compileFile, devsFactory } from "./build"

import { BINDIR, fatal, log, verboseLog } from "./command"

import {

SRV_DEVICE_SCRIPT_MANAGER,

SRV_SETTINGS,

delay,

isTimeoutError,

} from "jacdac-ts"

import { devtools } from "./devtools"

import { devtoolsIface } from "./sidedata"

import { deployToService } from "./deploy"

import { BuildOptions } from "./sideprotocol"

import { FlashOptions, fetchFW, resolveBoard } from "./flash"

import { patchFstorToBoard } from "./binpatch"

import { writeFile } from "fs/promises"

export interface BundleOptions {

flashSize?: string

flashFile?: string

}

export async function bundle(

filename: string | undefined,

options: BundleOptions & BuildOptions & FlashOptions

) {

const { board, arch } = await resolveBoard("", options)

await devtools(undefined, {})

const inst = await devsFactory()

await inst.setupWebsocketTransport("ws://127.0.0.1:8081")

const pageSize = board.flashPageSize ?? arch.flashPageSize ?? 4096

if (options.flashSize) {

inst.flashSize = +options.flashSize * 1024

} else {

const pages = board.fstorPages ?? arch.fstorPages

if (!pages)

fatal(`fstorPages not specified for ${board.id} nor ${arch.id}`)

inst.flashSize = pages * pageSize

}

const flashKB = inst.flashSize / 1024

verboseLog(`board:${board.id}, arch:${arch.id}, flashSize:${flashKB}kB`)

if (inst.flashSize < pageSize * 2 || (inst.flashSize & (pageSize - 1)) != 0)

fatal("invalid flash size")

let fstor = new Uint8Array(0)

inst.flashLoad = () => {

return fstor.slice()

}

inst.flashSave = buf => {

verboseLog(`flash save ${buf.length}`)

fstor = new Uint8Array(buf)

}

inst.devsStart()

const res = await compileFile(filename, options)

if (!res.success) process.exit(1)

const RETRY_DELAY = 100

const bus = devtoolsIface.bus

for (let i = 0; i < 20; i++) {

const service = bus.services({

serviceClass: SRV_DEVICE_SCRIPT_MANAGER,

})[0]

if (service) {

const settingsService = service?.device?.services({

serviceClass: SRV_SETTINGS,

})?.[0]

try {

await deployToService(service, res.binary, {

noRun: true,

settingsService,

settings: res.settings,

})

} catch (e) {

if (isTimeoutError(e)) {

// reset?

// keep retrying

await delay(RETRY_DELAY)

continue

}

throw e

}

await delay(300)

const fwPath = await fetchFW(board, options)

const buf = await patchFstorToBoard(fwPath, board, arch, fstor)

const bn = fwPath.replace(/.*[\/\\]/, "")

const fn =

options.flashFile ||

(options.outDir || BINDIR) + "/bundle-" + bn

log(`writing ${buf.length} bytes to ${fn}`)

await writeFile(fn, buf)

process.exit(0)

}

await delay(RETRY_DELAY)

}

throw new Error("no service")

}