const SENDER_FIELD = "__jacdac_sender"

/* eslint-disable @typescript-eslint/no-var-requires */

const WebSocket = require("faye-websocket")

import http from "http"

import https from "https"

import url from "url"

import net from "net"

import { CmdOptions, debug, error, log } from "./command"

import { readFileSync, readJSONSync, watch } from "fs-extra"

import { prettySize } from "@devicescript/compiler"

const dasboardPath = "tools/devicescript-devtools"

function fetchProxy(localhost: boolean): Promise<string> {

const protocol = localhost ? http : https

const url = localhost

? "http://localhost:8000/devtools/proxy.html"

: "https://microsoft.github.io/jacdac-docs/devtools/proxy"

//debug(`fetch jacdac devtools proxy at ${url}`)

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

protocol

.get(url, res => {

if (res.statusCode != 200)

reject(

new Error(`proxy download failed (${res.statusCode})`)

)

res.setEncoding("utf8")

let body = ""

res.on("data", data => (body += data))

res.on("end", () => {

body = body.replace(

/https:\/\/microsoft.github.io\/jacdac-docs\/dashboard/g,

localhost

? `http://localhost:8000/${dasboardPath}/`

: `https://microsoft.github.io/jacdac-docs/${dasboardPath}/`

)

resolve(body)

})

res.on("error", reject)

})

.on("error", reject)

})

}

export interface DevToolsOptions {

internet?: boolean

localhost?: boolean

bytecodeFile?: string

debugFile?: string

}

export async function devtools(options: DevToolsOptions & CmdOptions) {

const { internet, localhost, bytecodeFile, debugFile } = options

const port = 8081

const tcpPort = 8082

const listenHost = internet ? undefined : "127.0.0.1"

log(`starting dev tools at http://localhost:${port}`)

log(` websocket: ws://localhost:${port}`)

log(` tcpsocket: tcp://localhost:${tcpPort}`)

// download proxy sources

const proxyHtml = await fetchProxy(localhost)

// start http server

const clients: WebSocket[] = []

// upload DeviceScript file is needed

const sendDeviceScript = bytecodeFile

? () => {

const bytecode = readFileSync(bytecodeFile)

const dbg = debugFile ? readJSONSync(debugFile) : undefined

debug(

`refresh bytecode ${prettySize(bytecode.length)}...`

)

const msg = JSON.stringify({

type: "bytecode",

channel: "devicescript",

bytecode: bytecode.toString("hex"),

dbg,

})

clients.forEach(c => c.send(msg))

}

: undefined

const server = http.createServer(function (req, res) {

const parsedUrl = url.parse(req.url)

const pathname = parsedUrl.pathname

if (pathname === "/") {

res.setHeader("Cache-control", "no-cache")

res.setHeader("Content-type", "text/html")

res.end(proxyHtml)

} else {

res.statusCode = 404

}

})

function removeClient(client: WebSocket) {

const i = clients.indexOf(client)

clients.splice(i, 1)

log(`client: disconnected (${clients.length} clients)`)

}

server.on("upgrade", (request, socket, body) => {

// is this a socket?

if (WebSocket.isWebSocket(request)) {

const client = new WebSocket(request, socket, body)

const sender = "ws" + Math.random()

let firstDeviceScript = false

// store sender id to deduped packet

client[SENDER_FIELD] = sender

clients.push(client)

log(`webclient: connected (${sender}, ${clients.length} clients)`)

client.on("message", (event: any) => {

const { data } = event

if (!firstDeviceScript && sendDeviceScript) {

firstDeviceScript = true

sendDeviceScript()

}

})

client.on("close", () => removeClient(client))

client.on("error", (ev: Error) => error(ev))

}

})

const tcpServer = net.createServer((client: any) => {

const sender = "tcp" + Math.random()

client[SENDER_FIELD] = sender

client.send = (pkt0: Buffer) => {

const pkt = new Uint8Array(pkt0)

const b = new Uint8Array(1 + pkt.length)

b[0] = pkt.length

b.set(pkt, 1)

try {

client.write(b)

} catch {

try {

client.end()

} catch {} // eslint-disable-line no-empty

}

}

clients.push(client)

log(`tcpclient: connected (${sender} ${clients.length} clients)`)

client.on("end", () => removeClient(client))

client.on("error", (ev: Error) => error(ev))

})

server.listen(port, listenHost)

tcpServer.listen(tcpPort, listenHost)

if (bytecodeFile) {

debug(`watching ${bytecodeFile}...`)

watch(bytecodeFile, sendDeviceScript)

}

}