// Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name>
// SPDX-License-Identifier: 0BSD
import * as Relay from './proto.js'

// ---- RPC --------------------------------------------------------------------

class RelayRPC extends EventTarget {
	constructor(url) {
		super()
		this.url = url
		this.commandSeq = 0
	}

	connect() {
		// We can't close the connection immediately, as that queues a task.
		if (this.ws !== undefined)
			throw "Already connecting or connected"

		return new Promise((resolve, reject) => {
			let ws = this.ws = new WebSocket(this.url)
			ws.onopen = event => {
				this._initialize()
				resolve()
			}
			// It's going to be code 1006 with no further info.
			ws.onclose = event => {
				this.ws = undefined
				reject()
			}
		})
	}

	_initialize() {
		this.ws.binaryType = 'arraybuffer'
		this.ws.onopen = undefined
		this.ws.onmessage = event => {
			this._process(event.data)
		}
		this.ws.onerror = event => {
			this.dispatchEvent(new CustomEvent('error'))
		}
		this.ws.onclose = event => {
			let message = "Connection closed: " +
				event.reason + " (" + event.code + ")"
			for (const seq in this.promised)
				this.promised[seq].reject(message)

			this.ws = undefined
			this.dispatchEvent(new CustomEvent('close', {
				detail: {message, code: event.code, reason: event.reason},
			}))

			// Now connect() can be called again.
		}

		this.promised = {}
	}

	_process(data) {
		if (typeof data === 'string')
			throw "JSON messages not supported"

		const r = new Relay.Reader(data)
		while (!r.empty)
			this._processOne(Relay.EventMessage.deserialize(r))
	}

	_processOne(message) {
		let e = message.data
		switch (e.event) {
		case Relay.Event.Error:
			if (this.promised[e.commandSeq] !== undefined)
				this.promised[e.commandSeq].reject(e.error)
			else
				console.error(`Unawaited error: ${e.error}`)
			break
		case Relay.Event.Response:
			if (this.promised[e.commandSeq] !== undefined)
				this.promised[e.commandSeq].resolve(e.data)
			else
				console.error("Unawaited response")
			break
		default:
			e.eventSeq = message.eventSeq
			this.dispatchEvent(new CustomEvent('event', {detail: e}))
			return
		}

		delete this.promised[e.commandSeq]
		for (const seq in this.promised) {
			// We don't particularly care about wraparound issues.
			if (seq >= e.commandSeq)
				continue

			this.promised[seq].reject("No response")
			delete this.promised[seq]
		}
	}

	send(params) {
		if (this.ws === undefined)
			throw "Not connected"
		if (typeof params !== 'object')
			throw "Method parameters must be an object"

		// Left shifts in Javascript convert to a 32-bit signed number.
		let seq = ++this.commandSeq
		if ((seq << 0) != seq)
			seq = this.commandSeq = 0

		this.ws.send(JSON.stringify({commandSeq: seq, data: params}))

		// Automagically detect if we want a result.
		let data = undefined
		const promise = new Promise(
			(resolve, reject) => { data = {resolve, reject} })
		promise.then = (...args) => {
			this.promised[seq] = data
			return Promise.prototype.then.call(promise, ...args)
		}
		return promise
	}
}

// ---- Utilities --------------------------------------------------------------

function utf8Encode(s) { return new TextEncoder().encode(s) }
function utf8Decode(s) { return new TextDecoder().decode(s) }

function hasShortcutModifiers(event) {
	return (event.altKey || event.escapePrefix) &&
		!event.metaKey && !event.ctrlKey
}

const audioContext = new AudioContext()

function beep() {
	let gain = audioContext.createGain()
	gain.gain.value = 0.5
	gain.connect(audioContext.destination)

	let oscillator = audioContext.createOscillator()
	oscillator.type = "triangle"
	oscillator.frequency.value = 800
	oscillator.connect(gain)
	oscillator.start(audioContext.currentTime)
	oscillator.stop(audioContext.currentTime + 0.1)
}

let iconLink = undefined
let iconState = undefined

function updateIcon(highlighted) {
	if (iconState === highlighted)
		return

	iconState = highlighted
	let canvas = document.createElement('canvas')
	canvas.width = 32
	canvas.height = 32

	let ctx = canvas.getContext('2d')
	ctx.arc(16, 16, 12, 0, 2 * Math.PI)
	ctx.fillStyle = '#000'
	if (highlighted === true)
		ctx.fillStyle = '#ff5f00'
	if (highlighted === false)
		ctx.fillStyle = '#ccc'
	ctx.fill()

	if (iconLink === undefined) {
		iconLink = document.createElement('link')
		iconLink.type = 'image/png'
		iconLink.rel = 'icon'
		document.getElementsByTagName('head')[0].appendChild(iconLink)
	}

	iconLink.href = canvas.toDataURL();
}

// ---- Event processing -------------------------------------------------------

let rpc = new RelayRPC(proxy)
let rpcEventHandlers = new Map()

let buffers = new Map()
let bufferLast = undefined
let bufferCurrent = undefined
let bufferLog = undefined
let bufferAutoscroll = true

let servers = new Map()

function bufferResetStats(b) {
	b.newMessages = 0
	b.newUnimportantMessages = 0
	b.highlighted = false
}

function bufferActivate(name) {
	rpc.send({command: 'BufferActivate', bufferName: name})
}

function bufferToggleUnimportant(name) {
	rpc.send({command: 'BufferToggleUnimportant', bufferName: name})
}

function bufferToggleLog() {
	// TODO: Try to restore the previous scroll offset.
	if (bufferLog) {
		setTimeout(() =>
			document.getElementById('input')?.focus())

		bufferLog = undefined
		m.redraw()
		return
	}

	let name = bufferCurrent
	rpc.send({
		command: 'BufferLog',
		bufferName: name,
	}).then(resp => {
		if (bufferCurrent !== name)
			return

		bufferLog = utf8Decode(resp.log)
		m.redraw()
	})
}

let connecting = true
rpc.connect().then(result => {
	buffers.clear()
	bufferLast = undefined
	bufferCurrent = undefined
	bufferLog = undefined
	bufferAutoscroll = true

	servers.clear()

	rpc.send({command: 'Hello', version: Relay.version})
	connecting = false
	m.redraw()
}).catch(error => {
	connecting = false
	m.redraw()
})

rpc.addEventListener('close', event => {
	m.redraw()
})

rpc.addEventListener('event', event => {
	const handler = rpcEventHandlers.get(event.detail.event)
	if (handler !== undefined) {
		handler(event.detail)
		if (bufferCurrent !== undefined ||
			event.detail.event !== Relay.Event.BufferLine)
			m.redraw()
	}
})

rpcEventHandlers.set(Relay.Event.Ping, e => {
	rpc.send({command: 'PingResponse', eventSeq: e.eventSeq})
})

// ~~~ Buffer events ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

rpcEventHandlers.set(Relay.Event.BufferLine, e => {
	let b = buffers.get(e.bufferName), line = {...e}
	delete line.event
	delete line.eventSeq
	delete line.leakToActive
	if (b === undefined)
		return

	// Initial sync: skip all other processing, let highlights be.
	if (bufferCurrent === undefined) {
		b.lines.push(line)
		return
	}

	let visible = document.visibilityState !== 'hidden' &&
		bufferLog === undefined &&
		bufferAutoscroll &&
		(e.bufferName == bufferCurrent || e.leakToActive)
	b.lines.push({...line})
	if (!(visible || e.leakToActive) ||
			b.newMessages || b.newUnimportantMessages) {
		if (line.isUnimportant || e.leakToActive)
			b.newUnimportantMessages++
		else
			b.newMessages++
	}

	if (e.leakToActive) {
		let bc = buffers.get(bufferCurrent)
		bc.lines.push({...line, leaked: true})
		if (!visible || bc.newMessages || bc.newUnimportantMessages) {
			if (line.isUnimportant)
				bc.newUnimportantMessages++
			else
				bc.newMessages++
		}
	}

	if (line.isHighlight || (!visible && !line.isUnimportant &&
			b.kind === Relay.BufferKind.PrivateMessage)) {
		beep()
		if (!visible)
			b.highlighted = true
	}
})

rpcEventHandlers.set(Relay.Event.BufferUpdate, e => {
	let b = buffers.get(e.bufferName)
	if (b === undefined) {
		buffers.set(e.bufferName, (b = {
			lines: [],
			history: [],
			historyAt: 0,
		}))
		bufferResetStats(b)
	}

	b.hideUnimportant = e.hideUnimportant
	b.kind = e.context.kind
	b.server = servers.get(e.context.serverName)
	b.topic = e.context.topic
	b.modes = e.context.modes
})

rpcEventHandlers.set(Relay.Event.BufferStats, e => {
	let b = buffers.get(e.bufferName)
	if (b === undefined)
		return

	b.newMessages = e.newMessages,
	b.newUnimportantMessages = e.newUnimportantMessages
	b.highlighted = e.highlighted
})

rpcEventHandlers.set(Relay.Event.BufferRename, e => {
	buffers.set(e.new, buffers.get(e.bufferName))
	buffers.delete(e.bufferName)
})

rpcEventHandlers.set(Relay.Event.BufferRemove, e => {
	buffers.delete(e.bufferName)
	if (e.bufferName === bufferLast)
		bufferLast = undefined
})

rpcEventHandlers.set(Relay.Event.BufferActivate, e => {
	let old = buffers.get(bufferCurrent)
	if (old !== undefined)
		bufferResetStats(old)

	bufferLast = bufferCurrent
	let b = buffers.get(e.bufferName)
	bufferCurrent = e.bufferName
	bufferLog = undefined
	bufferAutoscroll = true
	if (b !== undefined && document.visibilityState !== 'hidden')
		b.highlighted = false

	let textarea = document.getElementById('input')
	if (textarea === null)
		return

	textarea.focus()
	if (old !== undefined) {
		old.input = textarea.value
		old.inputStart = textarea.selectionStart
		old.inputEnd = textarea.selectionEnd
		old.inputDirection = textarea.selectionDirection
		// Note that we effectively overwrite the newest line
		// with the current textarea contents, and jump there.
		old.historyAt = old.history.length
	}

	textarea.value = ''
	if (b !== undefined && b.input !== undefined) {
		textarea.value = b.input
		textarea.setSelectionRange(b.inputStart, b.inputEnd, b.inputDirection)
	}
})

rpcEventHandlers.set(Relay.Event.BufferClear, e => {
	let b = buffers.get(e.bufferName)
	if (b !== undefined)
		b.lines.length = 0
})

// ~~~ Server events ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

rpcEventHandlers.set(Relay.Event.ServerUpdate, e => {
	let s = servers.get(e.serverName)
	if (s === undefined)
		servers.set(e.serverName, (s = {}))
	s.data = e.data
})

rpcEventHandlers.set(Relay.Event.ServerRename, e => {
	servers.set(e.new, servers.get(e.serverName))
	servers.delete(e.serverName)
})

rpcEventHandlers.set(Relay.Event.ServerRemove, e => {
	servers.delete(e.serverName)
})

// --- Colours -----------------------------------------------------------------

let palette = [
	'#000', '#800', '#080', '#880', '#008', '#808', '#088', '#ccc',
	'#888', '#f00', '#0f0', '#ff0', '#00f', '#f0f', '#0ff', '#fff',
]
palette.length = 256
for (let i = 0; i < 216; i++) {
	let r = i / 36 >> 0, g = (i / 6 >> 0) % 6, b = i % 6
	r = !r ? '00' : (55 + 40 * r).toString(16)
	g = !g ? '00' : (55 + 40 * g).toString(16)
	b = !b ? '00' : (55 + 40 * b).toString(16)
	palette[16 + i] = `#${r}${g}${b}`
}
for (let i = 0; i < 24; i++) {
	let g = ('0' + (8 + i * 10).toString(16)).slice(-2)
	palette[232 + i] = `#${g}${g}${g}`
}

// ---- UI ---------------------------------------------------------------------

let linkRE = [
	/https?:\/\//,
	/([^\[\](){}<>"'\s]|\([^\[\](){}<>"'\s]*\))+/,
	/([^\[\](){}<>"'\s,.:]|\([^\[\](){}<>"'\s]*\))/,
].map(r => r.source).join('')

let BufferList = {
	view: vnode => {
		let highlighted = false
		let items = Array.from(buffers, ([name, b]) => {
			let classes = [], displayName = name
			if (name == bufferCurrent) {
				classes.push('current')
			} else if (b.newMessages) {
				classes.push('activity')
				displayName += ` (${b.newMessages})`
			}
			if (b.highlighted) {
				classes.push('highlighted')
				highlighted = true
			}
			return m('.item', {
				onclick: event => bufferActivate(name),
				class: classes.join(' '),
			}, displayName)
		})

		updateIcon(rpc.ws === undefined ? null : highlighted)
		return m('.list', {}, items)
	},
}

let Content = {
	applyColor: (fg, bg, inverse) => {
		if (inverse)
			[fg, bg] = [bg >= 0 ? bg : 15, fg >= 0 ? fg : 0]

		let style = {}
		if (fg >= 0)
			style.color = palette[fg]
		if (bg >= 0)
			style.backgroundColor = palette[bg]
		for (const _ in style)
			return style
	},

	linkify: (text, attrs) => {
		let re = new RegExp(linkRE, 'g'), a = [], end = 0, match
		while ((match = re.exec(text)) !== null) {
			if (end < match.index)
				a.push(m('span', attrs, text.substring(end, match.index)))
			a.push(m('a[target=_blank]', {href: match[0], ...attrs}, match[0]))
			end = re.lastIndex
		}
		if (end < text.length)
			a.push(m('span', attrs, text.substring(end)))
		return a
	},

	makeMark: line => {
		switch (line.rendition) {
		case Relay.Rendition.Indent: return m('span.mark',        {}, '')
		case Relay.Rendition.Status: return m('span.mark',        {}, '–')
		case Relay.Rendition.Error:  return m('span.mark.error',  {}, '⚠')
		case Relay.Rendition.Join:   return m('span.mark.join',   {}, '→')
		case Relay.Rendition.Part:   return m('span.mark.part',   {}, '←')
		case Relay.Rendition.Action: return m('span.mark.action', {}, '✶')
		}
	},

	view: vnode => {
		let line = vnode.children[0]
		let classes = new Set()
		let flip = c => {
			if (classes.has(c))
				classes.delete(c)
			else
				classes.add(c)
		}

		let fg = -1, bg = -1, inverse = false
		return m('.content', vnode.attrs, [
			Content.makeMark(line),
			line.items.flatMap(item => {
				switch (item.kind) {
				case Relay.Item.Text:
					return Content.linkify(item.text, {
						class: Array.from(classes.keys()).join(' '),
						style: Content.applyColor(fg, bg, inverse),
					})
				case Relay.Item.Reset:
					classes.clear()
					fg = bg = -1
					inverse = false
					break
				case Relay.Item.FgColor:
					fg = item.color
					break
				case Relay.Item.BgColor:
					bg = item.color
					break
				case Relay.Item.FlipInverse:
					inverse = !inverse
					break
				case Relay.Item.FlipBold:
					flip('b')
					break
				case Relay.Item.FlipItalic:
					flip('i')
					break
				case Relay.Item.FlipUnderline:
					flip('u')
					break
				case Relay.Item.FlipCrossedOut:
					flip('s')
					break
				case Relay.Item.FlipMonospace:
					flip('m')
					break
				}
			}),
		])
	},
}

let Topic = {
	view: vnode => {
		let b = buffers.get(bufferCurrent)
		if (b !== undefined && b.topic !== undefined)
			return m(Content, {}, {items: b.topic})
	},
}

let Buffer = {
	controller: new AbortController(),

	onbeforeremove: vnode => {
		Buffer.controller.abort()
	},

	onupdate: vnode => {
		if (bufferAutoscroll)
			vnode.dom.scrollTop = vnode.dom.scrollHeight
	},

	oncreate: vnode => {
		Buffer.onupdate(vnode)
		window.addEventListener('resize', event => Buffer.onupdate(vnode),
			{signal: Buffer.controller.signal})
	},

	view: vnode => {
		let lines = []
		let b = buffers.get(bufferCurrent)
		if (b === undefined)
			return m('.buffer')

		let lastDateMark = undefined
		let squashing = false
		let markBefore = b.lines.length
			- b.newMessages - b.newUnimportantMessages
		b.lines.forEach((line, i) => {
			if (i == markBefore)
				lines.push(m('.unread'))

			if (!line.isUnimportant || !b.hideUnimportant) {
				squashing = false
			} else if (squashing) {
				return
			} else {
				squashing = true
			}

			let date = new Date(line.when)
			let dateMark = date.toLocaleDateString()
			if (dateMark !== lastDateMark) {
				lines.push(m('.date', {}, dateMark))
				lastDateMark = dateMark
			}
			if (squashing) {
				lines.push(m('.time.hidden'))
				lines.push(m('.content'))
				return
			}

			let attrs = {}
			if (line.leaked)
				attrs.class = 'leaked'

			lines.push(m('.time', {...attrs}, date.toLocaleTimeString()))
			lines.push(m(Content, {...attrs}, line))
		})

		let dateMark = new Date().toLocaleDateString()
		if (dateMark !== lastDateMark && lastDateMark !== undefined)
			lines.push(m('.date', {}, dateMark))
		return m('.buffer', {onscroll: event => {
			const dom = event.target
			bufferAutoscroll =
				dom.scrollTop + dom.clientHeight + 1 >= dom.scrollHeight
		}}, lines)
	},
}

let Log = {
	oncreate: vnode => {
		vnode.dom.scrollTop = vnode.dom.scrollHeight
		vnode.dom.focus()
	},

	linkify: text => {
		let re = new RegExp(linkRE, 'g'), a = [], end = 0, match
		while ((match = re.exec(text)) !== null) {
			if (end < match.index)
				a.push(text.substring(end, match.index))
			a.push(m('a[target=_blank]', {href: match[0]}, match[0]))
			end = re.lastIndex
		}
		if (end < text.length)
			a.push(text.substring(end))
		return a
	},

	view: vnode => {
		return m(".log", {}, Log.linkify(bufferLog))
	},
}

let Completions = {
	entries: [],

	reset: list => {
		Completions.entries = list || []
		m.redraw()
	},

	view: vnode => {
		if (!Completions.entries.length)
			return
		return m('.completions', {},
			Completions.entries.map(option => m('.completion', {}, option)))
	},
}

let BufferContainer = {
	view: vnode => {
		return m('.buffer-container', {}, [
			m('.filler'),
			bufferLog !== undefined ? m(Log) : m(Buffer),
			m(Completions),
		])
	},
}

let Toolbar = {
	format: formatting => {
		let textarea = document.getElementById('input')
		if (textarea !== null)
			Input.format(textarea, formatting)
	},

	view: vnode => {
		let indicators = []
		if (bufferLog === undefined && !bufferAutoscroll)
			indicators.push(m('.indicator', {}, '⇩'))
		if (Input.formatting)
			indicators.push(m('.indicator', {}, '#'))
		return m('.toolbar', {}, [
			indicators,
			m('button', {onclick: event => Toolbar.format('\u0002')},
				m('b', {}, 'B')),
			m('button', {onclick: event => Toolbar.format('\u001D')},
				m('i', {}, 'I')),
			m('button', {onclick: event => Toolbar.format('\u001F')},
				m('u', {}, 'U')),
			m('button', {onclick: event => bufferToggleLog()},
				bufferLog === undefined ? 'Log' : 'Hide log'),
		])
	},
}

let Status = {
	view: vnode => {
		let b = buffers.get(bufferCurrent)
		if (b === undefined)
			return m('.status', {}, 'Synchronizing...')

		let status = `${bufferCurrent}`
		if (b.modes)
			status += `(+${b.modes})`
		if (b.hideUnimportant)
			status += `<H>`
		return m('.status', {}, [status, m(Toolbar)])
	},
}

let Prompt = {
	view: vnode => {
		let b = buffers.get(bufferCurrent)
		if (b === undefined || b.server === undefined)
			return

		if (b.server.data.user !== undefined) {
			let user = b.server.data.user
			if (b.server.data.userModes)
				user += `(${b.server.data.userModes})`
			return m('.prompt', {}, `${user}`)
		}

		// This might certainly be done more systematically.
		let state = b.server.data.state
		for (const s in Relay.ServerState)
			if (Relay.ServerState[s] == state) {
				state = s
				break
			}
		return m('.prompt', {}, `(${state})`)
	},
}

let Input = {
	counter: 0,
	stamp: textarea => {
		return [Input.counter,
			textarea.selectionStart, textarea.selectionEnd, textarea.value]
	},

	complete: (b, textarea) => {
		if (textarea.selectionStart !== textarea.selectionEnd)
			return false

		// Cancel any previous autocomplete, and ensure applicability.
		Input.counter++
		let state = Input.stamp(textarea)
		rpc.send({
			command: 'BufferComplete',
			bufferName: bufferCurrent,
			text: textarea.value,
			position: utf8Encode(
				textarea.value.slice(0, textarea.selectionEnd)).length,
		}).then(resp => {
			if (!Input.stamp(textarea).every((v, k) => v === state[k]))
				return

			let preceding = utf8Encode(textarea.value).slice(0, resp.start)
			let start = utf8Decode(preceding).length
			if (resp.completions.length > 0) {
				textarea.setRangeText(resp.completions[0],
					start, textarea.selectionEnd, 'end')
			}

			if (resp.completions.length == 1) {
				textarea.setRangeText(' ',
					textarea.selectionStart, textarea.selectionEnd, 'end')
			} else {
				beep()
			}

			if (resp.completions.length > 1)
				Completions.reset(resp.completions.slice(1))
		})
		return true
	},

	submit: (b, textarea) => {
		rpc.send({
			command: 'BufferInput',
			bufferName: bufferCurrent,
			text: textarea.value,
		})

		// b.history[b.history.length] is virtual, and is represented
		// either by textarea contents when it's currently being edited,
		// or by b.input in all other cases.
		b.history.push(textarea.value)
		b.historyAt = b.history.length
		textarea.value = ''
		return true
	},

	backward: textarea => {
		if (textarea.selectionStart !== textarea.selectionEnd)
			return false

		let point = textarea.selectionStart
		if (point < 1)
			return false
		while (point && /\s/.test(textarea.value.charAt(--point))) {}
		while (point-- && !/\s/.test(textarea.value.charAt(point))) {}
		point++
		textarea.setSelectionRange(point, point)
		return true
	},

	forward: textarea => {
		if (textarea.selectionStart !== textarea.selectionEnd)
			return false

		let point = textarea.selectionStart, len = textarea.value.length
		if (point + 1 > len)
			return false
		while (point < len && /\s/.test(textarea.value.charAt(point))) point++
		while (point < len && !/\s/.test(textarea.value.charAt(point))) point++
		textarea.setSelectionRange(point, point)
		return true
	},

	modifyWord: (textarea, cb) => {
		let start = textarea.selectionStart
		let end = textarea.selectionEnd
		if (start === end) {
			let len = textarea.value.length
			while (start < len && /\s/.test(textarea.value.charAt(start)))
				start++;
			end = start
			while (end < len && !/\s/.test(textarea.value.charAt(end)))
				end++;
		}
		if (start === end)
			return false

		const text = textarea.value, modified = cb(text.substring(start, end))
		textarea.value = text.slice(0, start) + modified + text.slice(end)
		end = start + modified.length
		textarea.setSelectionRange(end, end)
		return true
	},

	downcase: textarea => {
		return Input.modifyWord(textarea, text => text.toLowerCase())
	},

	upcase: textarea => {
		return Input.modifyWord(textarea, text => text.toUpperCase())
	},

	capitalize: textarea => {
		return Input.modifyWord(textarea, text => {
			const cps = Array.from(text.toLowerCase())
			return cps[0].toUpperCase() + cps.slice(1).join('')
		})
	},

	first: (b, textarea) => {
		if (b.historyAt <= 0)
			return false

		if (b.historyAt == b.history.length)
			b.input = textarea.value
		textarea.value = b.history[(b.historyAt = 0)]
		return true
	},

	last: (b, textarea) => {
		if (b.historyAt >= b.history.length)
			return false

		b.historyAt = b.history.length
		textarea.value = b.input
		return true
	},

	previous: (b, textarea) => {
		if (b.historyAt <= 0)
			return false

		if (b.historyAt == b.history.length)
			b.input = textarea.value
		textarea.value = b.history[--b.historyAt]
		return true
	},

	next: (b, textarea) => {
		if (b.historyAt >= b.history.length)
			return false

		if (++b.historyAt == b.history.length)
			textarea.value = b.input
		else
			textarea.value = b.history[b.historyAt]
		return true
	},

	formatting: false,

	format: (textarea, formatting) => {
		const [start, end] = [textarea.selectionStart, textarea.selectionEnd]
		if (start === end) {
			textarea.setRangeText(formatting)
			textarea.setSelectionRange(
				start + formatting.length, end + formatting.length)
		} else {
			textarea.setRangeText(
				formatting + textarea.value.substr(start, end) + formatting)
		}
		textarea.focus()
	},

	onKeyDown: event => {
		// TODO: And perhaps on other actions, too.
		rpc.send({command: 'Active'})

		let b = buffers.get(bufferCurrent)
		if (b === undefined)
			return

		let textarea = event.currentTarget
		let handled = false
		let success = true
		if (Input.formatting) {
			Input.formatting = false

			// Like process_formatting_escape() within xC.
			handled = true
			switch (event.key) {
			case 'b': Input.format(textarea, '\u0002'); break
			case 'c': Input.format(textarea, '\u0003'); break
			case 'q':
			case 'm': Input.format(textarea, '\u0011'); break
			case 'v': Input.format(textarea, '\u0016'); break
			case 'i':
			case ']': Input.format(textarea, '\u001D'); break
			case 's':
			case 'x':
			case '^': Input.format(textarea, '\u001E'); break
			case 'u':
			case '_': Input.format(textarea, '\u001F'); break
			case 'r':
			case 'o': Input.format(textarea, '\u000F'); break
			default: success = false
			}
		} else if (hasShortcutModifiers(event)) {
			handled = true
			switch (event.key) {
			case 'b': success = Input.backward(textarea);    break
			case 'f': success = Input.forward(textarea);     break
			case 'l': success = Input.downcase(textarea);    break
			case 'u': success = Input.upcase(textarea);      break
			case 'c': success = Input.capitalize(textarea);  break
			case '<': success = Input.first(b, textarea);    break
			case '>': success = Input.last(b, textarea);     break
			case 'p': success = Input.previous(b, textarea); break
			case 'n': success = Input.next(b, textarea);     break
			case 'm': success = Input.formatting = true;     break
			default:  handled = false
			}
		} else if (!event.altKey && !event.ctrlKey && !event.metaKey &&
				!event.shiftKey) {
			handled = true
			switch (event.keyCode) {
			case 9:   success = Input.complete(b, textarea); break
			case 13:  success = Input.submit(b, textarea);   break
			default:  handled = false
			}
		}
		if (!success)
			beep()
		if (handled)
			event.preventDefault()
	},

	onStateChange: event => {
		Completions.reset()
		Input.formatting = false
	},

	view: vnode => {
		return m('textarea#input', {
			rows: 1,
			onkeydown: Input.onKeyDown,
			oninput: Input.onStateChange,
			// Sadly only supported in Firefox as of writing.
			onselectionchange: Input.onStateChange,
			// The list of completions is scrollable without receiving focus.
			onblur: Input.onStateChange,
		})
	},
}

let Main = {
	view: vnode => {
		let overlay = undefined
		if (connecting)
			overlay = m('.overlay', {}, "Connecting...")
		else if (rpc.ws === undefined)
			overlay = m('.overlay', {}, [
				m('', {}, "Disconnected"),
				m('', {}, m('small', {}, "Reload page to reconnect.")),
			])

		return m('.xP', {}, [
			overlay,
			m('.title', {}, [m('b', {}, `xP`), m(Topic)]),
			m('.middle', {}, [m(BufferList), m(BufferContainer)]),
			m(Status),
			m('.input', {}, [m(Prompt), m(Input)]),
		])
	},
}

window.addEventListener('load', () => m.mount(document.body, Main))

document.addEventListener('visibilitychange', event => {
	let b = buffers.get(bufferCurrent)
	if (b !== undefined && document.visibilityState !== 'hidden') {
		b.highlighted = false
		m.redraw()
	}
})

// On macOS, the Alt/Option key transforms characters, which basically breaks
// all event.altKey shortcuts, so implement Escape prefixing on that system.
// This method of detection only works with Blink browsers, as of writing.
let lastWasEscape = false
document.addEventListener('keydown', event => {
	event.escapePrefix = lastWasEscape
	if (lastWasEscape) {
		lastWasEscape = false
	} else if (event.code == 'Escape' &&
			navigator.userAgentData?.platform === 'macOS') {
		event.preventDefault()
		event.stopPropagation()
		lastWasEscape = true
		return
	}

	if (rpc.ws == undefined || !hasShortcutModifiers(event))
		return

	// Rotate names so that the current buffer comes first.
	let names = [...buffers.keys()]
	names.push.apply(names,
		names.splice(0, names.findIndex(name => name == bufferCurrent)))

	switch (event.key) {
	case 'h':
		bufferToggleLog()
		break
	case 'H':
		if (bufferCurrent !== undefined)
			bufferToggleUnimportant(bufferCurrent)
		break
	case 'a':
		for (const name of names.slice(1))
			if (buffers.get(name).newMessages) {
				bufferActivate(name)
				break
			}
		break
	case '!':
		for (const name of names.slice(1))
			if (buffers.get(name).highlighted) {
				bufferActivate(name)
				break
			}
		break
	case 'Tab':
		if (bufferLast !== undefined)
			bufferActivate(bufferLast)
		break
	case 'PageUp':
		if (names.length > 1)
			bufferActivate(names.at(-1))
		break
	case 'PageDown':
		if (names.length > 1)
			bufferActivate(names.at(+1))
		break
	default:
		return
	}

	event.preventDefault()
}, true)