xK/xM/main.swift

/*
 * main.swift: Cocoa frontend for xC
 *
 * This is in effect a port of xW.cpp to macOS frameworks.
 *
 * Copyright (c) 2023, Přemysl Eric Janouch <p@janouch.name>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

import AppKit
import Network
import os

let projectName = "xM"

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

class RelayRPC {
	var connection: NWConnection?

	// Callbacks:

	var onConnected: (() -> Void)?
	var onFailed: ((String) -> Void)?
	var onEvent: ((RelayEventMessage) -> Void)?

	// Command processing:

	typealias Callback = (String, RelayResponseData?) -> ()

	/// Outgoing message counter
	var commandSeq: UInt32 = 0
	/// Callbacks for messages processed by the server
	var commandCallbacks = Dictionary<UInt32, Callback>()

	func resetState() {
		self.connection = nil

		// TODO(p): Consider cancelling all of them from here.
		self.commandCallbacks.removeAll()
	}

	func connect(host: String, port: String) -> Bool {
		let nwHost = NWEndpoint.Host(host)
		let nwPort = NWEndpoint.Port(port)
		if nwPort == nil {
			return false
		}

		// TODO(p): Consider how to behave after failure.
		self.resetState()

		self.connection = NWConnection(host: nwHost, port: nwPort!, using: .tcp)
		self.connection!.stateUpdateHandler = onStateChange(to:)
		self.receiveFrame()
		// We directly update the UI from callbacks, avoid threading.
		self.connection!.start(queue: .main)
		return true
	}

	func fail(message: String) {
		// We cannot pass a message along with cancellation state transition.
		self.onFailed?(message)
		self.connection!.cancel()
	}

	func onStateChange(to: NWConnection.State) {
		switch to {
		case .waiting(let error):
			// This is most likely fatal, despite what the documentation says.
			self.fail(message: error.localizedDescription)
		case .ready:
			self.onConnected?()
		case .failed(let error):
			self.onFailed?(error.localizedDescription)
		default:
			return
		}
	}

	func processCallbacks(
			commandSeq: UInt32, error: String, response: RelayResponseData?) {
		if let callback = self.commandCallbacks[commandSeq] {
			callback(error, response)
		} else if !error.isEmpty {
			Logger().warning("Unawaited response: \(error)")
		} else {
			Logger().warning("Unawaited response")
		}

		self.commandCallbacks.removeValue(forKey: commandSeq)

		// We don't particularly care about wraparound issues.
		for (seq, callback) in self.commandCallbacks where seq < commandSeq {
			callback("No response.", nil)
			self.commandCallbacks.removeValue(forKey: seq)
		}
	}

	func process(message: RelayEventMessage) {
		switch message.data {
		case let data as RelayEventDataError:
			self.processCallbacks(
				commandSeq: data.commandSeq, error: data.error, response: nil)
		case let data as RelayEventDataResponse:
			self.processCallbacks(
				commandSeq: data.commandSeq, error: "", response: data.data)
		default:
			self.onEvent?(message)
		}
	}

	func receiveMessage(length: Int) {
		self.connection!.receive(
			minimumIncompleteLength: length, maximumLength: length) {
			(content, context, isComplete, error) in
			guard let content = content else {
				// TODO(p): Do we need to bring it down explicitly on error?
				if isComplete {
					self.fail(message: "Connection closed.")
				}
				return
			}

			var r = RelayReader(data: content)
			do {
				self.process(message: try RelayEventMessage(from: &r))
				self.receiveFrame()
			} catch {
				self.fail(message: "Deserialization failed.")
			}
		}
	}

	func receiveFrame() {
		let length = MemoryLayout<UInt32>.size
		self.connection!.receive(
			minimumIncompleteLength: length, maximumLength: length) {
			(content, context, isComplete, error) in
			guard let content = content else {
				// TODO(p): Do we need to bring it down explicitly on error?
				if isComplete {
					self.fail(message: "Connection closed.")
				}
				return
			}

			var r = RelayReader(data: content)
			do {
				let len: UInt32 = try r.read()
				if let len = Int(exactly: len) {
					self.receiveMessage(length: len)
				} else {
					self.fail(message: "Frame length overflow.")
				}
			} catch {
				self.fail(message: "Deserialization failed.")
			}
		}
	}

	func send(data: RelayCommandData, callback: Callback? = nil) {
		self.commandSeq += 1
		let m = RelayCommandMessage(commandSeq: self.commandSeq, data: data)
		if let callback = callback {
			self.commandCallbacks[m.commandSeq] = callback
		}

		var w = RelayWriter()
		m.encode(to: &w)
		var prefix = RelayWriter()
		prefix.append(UInt32(w.data.count))

		self.connection!.batch() {
			self.connection!.send(content: prefix.data,
				completion: .contentProcessed({ error in }))
			self.connection!.send(content: w.data,
				completion: .contentProcessed({ error in }))
		}
	}
}

// --- State -------------------------------------------------------------------

class Server {
	var state: RelayServerState = .disconnected
	var user: String = ""
	var userModes: String = ""
}

struct BufferLine {
	var leaked: Bool = false

	var isUnimportant: Bool = false
	var isHighlight: Bool = false
	var rendition: RelayRendition = .bare
	var when: UInt64 = 0
	var text = NSAttributedString()
}

class Buffer {
	var bufferName: String = ""
	var hideUnimportant: Bool = false
	var kind: RelayBufferKind = .global
	var serverName: String = ""
	var lines: Array<BufferLine> = []

	// Channel:

	var topic = NSAttributedString()
	var modes: String = ""

	// Stats:

	var newMessages: UInt32 = 0
	var newUnimportantMessages: UInt32 = 0
	var highlighted: Bool = false

	// Input:

	var input: String = ""
	var inputSelection: NSRange? = nil
	var history: Array<String> = []
	var historyAt: Int = 0
}

var relayRPC = RelayRPC()

var relayBuffers: Array<Buffer> = []
var relayBufferCurrent: String = ""
var relayBufferLast: String = ""

var relayServers: Dictionary<String, Server> = [:]

// --- Buffers -----------------------------------------------------------------

func bufferBy(name: String) -> Buffer? {
	return relayBuffers.first(where: { b in b.bufferName == name })
}

func bufferActivate(name: String) {
	let activate = RelayCommandDataBufferActivate(bufferName: name)
	relayRPC.send(data: activate)
}

func bufferToggleUnimportant(name: String) {
	let toggle = RelayCommandDataBufferToggleUnimportant(bufferName: name)
	relayRPC.send(data: toggle)
}

// --- GUI ---------------------------------------------------------------------

let app = NSApplication.shared

let menu = NSMenu()
app.mainMenu = menu

let applicationMenuItem = NSMenuItem()
menu.addItem(applicationMenuItem)
let applicationMenu = NSMenu()
applicationMenuItem.submenu = applicationMenu
applicationMenu.addItem(NSMenuItem(title: "Quit " + projectName,
	action: #selector(app.terminate), keyEquivalent: "q"))

let bufferMenuItem = NSMenuItem()
menu.addItem(bufferMenuItem)
let bufferMenu = NSMenu(title: "Buffer")
bufferMenuItem.submenu = bufferMenu

let uiStackView = NSStackView()
uiStackView.orientation = .vertical
uiStackView.spacing = 0
uiStackView.alignment = .leading

func pushWithMargins(view: NSView) {
	let box = NSStackView()
	box.orientation = .horizontal
	box.edgeInsets = NSEdgeInsetsMake(4, 8, 4, 8)
	box.addArrangedSubview(view)
	uiStackView.addArrangedSubview(box)
}

// TODO(p): Consider replacing with NSTextView,
// to avoid font changes when selected.
let uiTopic = NSTextField(wrappingLabelWithString: "")
uiTopic.isEditable = false
uiTopic.isBezeled = false
uiTopic.drawsBackground = false
// Otherwise clicking it removes string attributes.
uiTopic.allowsEditingTextAttributes = true
pushWithMargins(view: uiTopic)

let uiSeparator1 = NSBox()
uiSeparator1.boxType = .separator
uiStackView.addArrangedSubview(uiSeparator1)

let uiBufferList = NSTableView()
uiBufferList.addTableColumn(
	NSTableColumn(identifier: NSUserInterfaceItemIdentifier("Buffer name")))
uiBufferList.headerView = nil
uiBufferList.style = .plain
uiBufferList.rowSizeStyle = .default
uiBufferList.allowsEmptySelection = false

let uiBufferListScroll = NSScrollView()
uiBufferListScroll.setFrameSize(CGSize(width: 1, height: 1))
uiBufferListScroll.documentView = uiBufferList
uiBufferListScroll.hasVerticalScroller = true
uiBufferListScroll.verticalScroller?.refusesFirstResponder = true

let uiBuffer = NSTextView()
uiBuffer.isEditable = false
uiBuffer.focusRingType = .default
// Otherwise it skips a lot when scrolling.
uiBuffer.layoutManager?.allowsNonContiguousLayout = false
uiBuffer.autoresizingMask = [.width, .height]

let uiBufferScroll = NSScrollView()
uiBufferScroll.setFrameSize(CGSize(width: 2, height: 1))
uiBufferScroll.documentView = uiBuffer
uiBufferScroll.hasVerticalScroller = true
uiBufferScroll.verticalScroller?.refusesFirstResponder = true

let uiSplitView = NSSplitView()
uiSplitView.isVertical = true
uiSplitView.dividerStyle = .thin
uiSplitView.addArrangedSubview(uiBufferListScroll)
uiSplitView.addArrangedSubview(uiBufferScroll)
uiStackView.addArrangedSubview(uiSplitView)

NSLayoutConstraint.activate([
	uiSplitView.leadingAnchor.constraint(
		equalTo: uiStackView.leadingAnchor),
	uiSplitView.trailingAnchor.constraint(
		equalTo: uiStackView.trailingAnchor),
])

let uiSeparator2 = NSBox()
uiSeparator2.boxType = .separator
uiStackView.addArrangedSubview(uiSeparator2)

let uiStatus = NSTextField()
uiStatus.isEditable = false
uiStatus.isBezeled = false
uiStatus.drawsBackground = false
uiStatus.stringValue = "Connecting..."
pushWithMargins(view: uiStatus)

let uiSeparator3 = NSBox()
uiSeparator3.boxType = .separator
uiStackView.addArrangedSubview(uiSeparator3)

let uiBottomStackView = NSStackView()
uiBottomStackView.orientation = .horizontal
pushWithMargins(view: uiBottomStackView)

let uiPrompt = NSTextField()
uiPrompt.isEditable = false
uiPrompt.isBezeled = false
uiPrompt.drawsBackground = false
uiPrompt.isHidden = true
uiBottomStackView.addArrangedSubview(uiPrompt)

let uiInput = NSTextField()
uiBottomStackView.addArrangedSubview(uiInput)

let uiWindow = NSWindow(
	contentRect: NSMakeRect(0, 0, 640, 480),
	styleMask: [.titled, .closable, .resizable],
	backing: .buffered, defer: true)
uiWindow.title = projectName
uiWindow.contentView = uiStackView

// --- Current buffer ----------------------------------------------------------

func bufferAtBottom() -> Bool {
	// TODO(p): Actually implement.
	// Consider uiBufferScroll.verticalScroller.floatValue.
	return true
}

func bufferScrollToBottom() {
	uiBuffer.scrollToEndOfDocument(nil)
}

// --- UI state refresh --------------------------------------------------------

func refreshIcon() {
	// TODO(p): Perhaps adjust NSApplication.applicationIconImage.
}

func refreshTopic(topic: NSAttributedString) {
	uiTopic.attributedStringValue = topic
}

func refreshBufferList() {
	uiBufferList.reloadData()
}

func serverStateToString(state: RelayServerState) -> String {
	switch state {
	case .disconnected:
		return "disconnected"
	case .connecting:
		return "connecting"
	case .connected:
		return "connected"
	case .registered:
		return "registered"
	case .disconnecting:
		return "disconnecting"
	}
}

func refreshPrompt() {
	var prompt = String()
	if let b = bufferBy(name: relayBufferCurrent) {
		if let server = relayServers[b.serverName] {
			prompt = server.user
			if !server.userModes.isEmpty {
				prompt += "(\(server.userModes))"
			}
			if prompt.isEmpty {
				prompt = "(\(serverStateToString(state: server.state)))"
			}
		}
	}

	if prompt.isEmpty {
		uiPrompt.isHidden = true
	} else {
		uiPrompt.isHidden = false
		uiPrompt.stringValue = prompt
	}
}

func refreshStatus() {
	var status = relayBufferCurrent
	if let b = bufferBy(name: relayBufferCurrent) {
		if !b.modes.isEmpty {
			status += "(+\(b.modes))"
		}
		if b.hideUnimportant {
			status += "<H>"
		}
	} else {
		status = "Synchronizing..."
	}

	// XXX: This indicator should probably be on the right side of the window.
	if !bufferAtBottom() {
		status += " ^"
	}

	uiStatus.stringValue = status
}

// --- Buffer output -----------------------------------------------------------

func convertColor(color: Int16) -> NSColor {
	let base16: [UInt16] = [
		0x000, 0x800, 0x080, 0x880, 0x008, 0x808, 0x088, 0xccc,
		0x888, 0xf00, 0x0f0, 0xff0, 0x00f, 0xf0f, 0x0ff, 0xfff,
	]
	if color < 16 {
		let r = CGFloat(0xf & (base16[Int(color)] >> 8)) / 0xf
		let g = CGFloat(0xf & (base16[Int(color)] >> 4)) / 0xf
		let b = CGFloat(0xf & (base16[Int(color)] >> 0)) / 0xf
		return NSColor(red: r, green: g, blue: b, alpha: 1)
	}
	if color >= 216 {
		let g = CGFloat(8 + (color - 216) * 10) / 0xff
		return NSColor(white: g, alpha: 1)
	}

	let i = color - 16
	let r = (i / 36)
	let g = (i / 6) % 6
	let b = (i % 6)
	let rr = r > 0 ? CGFloat(55 + 40 * r) / 0xff : 0
	let gg = g > 0 ? CGFloat(55 + 40 * g) / 0xff : 0
	let bb = b > 0 ? CGFloat(55 + 40 * b) / 0xff : 0
	return NSColor(red: rr, green: gg, blue: bb, alpha: 1)
}

func convertItemFormatting(item: RelayItemData,
		attrs: inout [NSAttributedString.Key : Any], inverse: inout Bool) {
	switch item {
	case is RelayItemDataReset:
		attrs.removeAll()
		inverse = false
	case is RelayItemDataFlipBold:
		// TODO(p): Need to select a font: applyFontTraits(_:range:)?
		break
	case is RelayItemDataFlipItalic:
		// TODO(p): Need to select a font: applyFontTraits(_:range:)?
		break
	case is RelayItemDataFlipUnderline:
		if attrs[.underlineStyle] != nil {
			attrs.removeValue(forKey: .underlineStyle)
		} else {
			attrs[.underlineStyle] = NSUnderlineStyle.single.rawValue
		}
	case is RelayItemDataFlipCrossedOut:
		if attrs[.strikethroughStyle] != nil {
			attrs.removeValue(forKey: .strikethroughStyle)
		} else {
			attrs[.strikethroughStyle] = NSUnderlineStyle.single.rawValue
		}
	case is RelayItemDataFlipInverse:
		inverse = !inverse
	case is RelayItemDataFlipMonospace:
		// TODO(p): Need to select a font: applyFontTraits(_:range:)?
		break
	case let data as RelayItemDataFgColor:
		if data.color < 0 {
			attrs.removeValue(forKey: .foregroundColor)
		} else {
			attrs[.foregroundColor] = convertColor(color: data.color)
		}
	case let data as RelayItemDataBgColor:
		if data.color < 0 {
			attrs.removeValue(forKey: .backgroundColor)
		} else {
			attrs[.backgroundColor] = convertColor(color: data.color)
		}
	default:
		return
	}
}

func convertItems(items: [RelayItemData]) -> NSAttributedString {
	let result = NSMutableAttributedString()
	var attrs = [NSAttributedString.Key : Any]()
	var inverse = false
	for item in items {
		guard let text = item as? RelayItemDataText else {
			convertItemFormatting(item: item, attrs: &attrs, inverse: &inverse)
			continue
		}

		// TODO(p): Handle inverse text.
		result.append(NSAttributedString(string: text.text, attributes: attrs))
	}
	if let detector = try? NSDataDetector(types:
		NSTextCheckingResult.CheckingType.link.rawValue) {
		for m in detector.matches(
			in: result.string, range: NSMakeRange(0, result.length)) {
			guard let url = m.url else {
				continue
			}
			let raw = (result.string as NSString).substring(with: m.range)
			if raw.contains("://") {
				result.addAttribute(.link, value: url, range: m.range)
			}
		}
	}
	return result
}

func convertBufferLine(line: RelayEventDataBufferLine) -> BufferLine {
	var bl = BufferLine()
	bl.isUnimportant = line.isUnimportant
	bl.isHighlight = line.isHighlight
	bl.rendition = line.rendition
	bl.when = line.when
	bl.text = convertItems(items: line.items)
	return bl
}

func bufferPrintLine(line: BufferLine) {
	guard let ts = uiBuffer.textStorage else {
		return
	}

	let current = Date(timeIntervalSince1970: Double(line.when / 1000))

	// TODO(p): Print date changes.
	if ts.length != 0 {
		ts.append(NSAttributedString(string: "\n"))
	}

	let formatter = DateFormatter()
	formatter.dateFormat = "HH:mm:ss"
	ts.append(NSAttributedString(
		string: formatter.string(from: current),
		attributes: [
			.foregroundColor: NSColor(white: 0xbb / 0xff, alpha: 1),
			.backgroundColor: NSColor(white: 0xf8 / 0xff, alpha: 1),
			.font: NSFont.monospacedDigitSystemFont(
				ofSize: uiBuffer.font!.pointSize, weight: .regular)
		]))

	ts.append(NSAttributedString(string: " "))

	let prefix = NSMutableAttributedString()
	var foreground: NSColor? = nil
	switch line.rendition {
	case .bare:
		break
	case .indent:
		prefix.mutableString.append("    ")
	case .status:
		prefix.mutableString.append(" -  ")
	case .error:
		prefix.mutableString.append("=!= ")
		foreground = NSColor.red
	case .join:
		prefix.mutableString.append("--> ")
		foreground = NSColor(red: 0, green: 0.5, blue: 0, alpha: 1)
	case .part:
		prefix.mutableString.append("<-- ")
		foreground = NSColor(red: 0.5, green: 0, blue: 0, alpha: 1)
	case .action:
		prefix.mutableString.append(" *  ")
		foreground = NSColor(red: 0.5, green: 0, blue: 0, alpha: 1)
	}
	if let color = foreground {
		prefix.addAttribute(.foregroundColor, value: color,
			range: NSMakeRange(0, prefix.length))
	}

	// FIXME: Fixed pitch doesn't actually work.
	prefix.applyFontTraits(.boldFontMask,
		range: NSMakeRange(0, prefix.length))
	prefix.applyFontTraits(.fixedPitchFontMask,
		range: NSMakeRange(0, prefix.length))

	if line.leaked {
		let deattributed = NSMutableAttributedString(attributedString: prefix)
		deattributed.append(line.text)
		let whole = NSMakeRange(0, deattributed.length)
		deattributed.removeAttribute(.backgroundColor, range: whole)
		deattributed.addAttributes(
			[.foregroundColor: NSColor(white: 0.5, alpha: 1)], range: whole)
		ts.append(deattributed)
	} else {
		ts.append(prefix)
		ts.append(line.text)
	}
}

func bufferPrintSeparator() {
	guard let ts = uiBuffer.textStorage else {
		return
	}
	if ts.length != 0 {
		ts.append(NSAttributedString(string: "\n"))
	}

	// TODO(p): Figure out if we can't add an actual horizontal line.
	ts.append(NSAttributedString(
		string: "---",
		attributes: [.foregroundColor: NSColor.controlAccentColor]))
}

func refreshBuffer(b: Buffer) {
	// TODO(p): See if we can pause updating.
	// If not, consider updating textStorage atomically.
	if let ts = uiBuffer.textStorage {
		ts.setAttributedString(NSAttributedString())
	}

	var i: Int = 0
	let markBefore = b.lines.count
		- Int(b.newMessages) - Int(b.newUnimportantMessages)
	for line in b.lines {
		if i == markBefore {
			bufferPrintSeparator()
		}
		if !line.isUnimportant || !b.hideUnimportant {
			bufferPrintLine(line: line)
		}

		i += 1
	}

	// TODO(p): Output any trailing date change.
	// FIXME: When the topic wraps, this doesn't scroll correctly.
	bufferScrollToBottom()
}

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

relayRPC.onConnected = {
	let hello = RelayCommandDataHello(version: UInt32(relayVersion))
	relayRPC.send(data: hello)
}

relayRPC.onFailed = { error in
	let alert = NSAlert()
	alert.messageText = "Relay connection failed"
	alert.informativeText = error
	alert.addButton(withTitle: "OK")
	alert.runModal()
	exit(EXIT_FAILURE)
}

func onBufferLine(b: Buffer, m: RelayEventDataBufferLine) {
	// Initial sync: skip all other processing, let highlights be.
	guard let bc = bufferBy(name: relayBufferCurrent) else {
		b.lines.append(convertBufferLine(line: m))
		return
	}

	let display = (!m.isUnimportant || !bc.hideUnimportant) &&
		(b.bufferName == relayBufferCurrent || m.leakToActive)
	let toBottom = display &&
		bufferAtBottom()
	// TODO(p): Once the log view is implemented, replace the "true" here.
	let visible = display &&
		toBottom &&
		!uiWindow.isMiniaturized &&
		true
	let separate = display &&
		!visible && bc.newMessages == 0 && bc.newUnimportantMessages == 0

	var line = convertBufferLine(line: m)
	if !(visible || m.leakToActive) ||
		b.newMessages != 0 || b.newUnimportantMessages != 0 {
		if line.isUnimportant || m.leakToActive {
			b.newUnimportantMessages += 1
		} else {
			b.newMessages += 1
		}
	}

	b.lines.append(line)
	if m.leakToActive {
		line.leaked = true
		bc.lines.append(line)
		if !visible || bc.newMessages != 0 || bc.newUnimportantMessages != 0 {
			if line.isUnimportant {
				bc.newUnimportantMessages += 1
			} else {
				bc.newMessages += 1
			}
		}
	}

	if separate {
		bufferPrintSeparator()
	}
	if display {
		bufferPrintLine(line: line)
	}
	if toBottom {
		bufferScrollToBottom()
	}

	if line.isHighlight || (!visible && !line.isUnimportant &&
		b.kind == .privateMessage) {
		NSSound.beep()

		if !visible {
			b.highlighted = true
			refreshIcon()
		}
	}

	refreshBufferList()
}

relayRPC.onEvent = { message in
	Logger().debug("Processing message \(message.eventSeq)")

	switch message.data {
	case _ as RelayEventDataPing:
		let pong = RelayCommandDataPingResponse(eventSeq: message.eventSeq)
		relayRPC.send(data: pong)

	case let data as RelayEventDataBufferLine:
		guard let b = bufferBy(name: data.bufferName) else {
			break
		}

		onBufferLine(b: b, m: data)

	case let data as RelayEventDataBufferUpdate:
		let b: Buffer
		if let buffer = bufferBy(name: data.bufferName) {
			b = buffer
		} else {
			b = Buffer()
			b.bufferName = data.bufferName
			relayBuffers.append(b)
			refreshBufferList()
		}

		let hidingToggled = b.hideUnimportant != data.hideUnimportant
		b.hideUnimportant = data.hideUnimportant
		b.kind = data.context.kind
		b.serverName.removeAll()
		switch data.context {
		case let context as RelayBufferContextServer:
			b.serverName = context.serverName
		case let context as RelayBufferContextChannel:
			b.serverName = context.serverName
			b.modes = context.modes
			b.topic = convertItems(items: context.topic)
		case let context as RelayBufferContextPrivateMessage:
			b.serverName = context.serverName
		default:
			break
		}

		if b.bufferName == relayBufferCurrent {
			refreshTopic(topic: b.topic)
			refreshStatus()

			if hidingToggled {
				refreshBuffer(b: b)
			}
		}

	case let data as RelayEventDataBufferStats:
		guard let b = bufferBy(name: data.bufferName) else {
			break
		}

		b.newMessages = data.newMessages
		b.newUnimportantMessages = data.newUnimportantMessages
		b.highlighted = data.highlighted

		refreshIcon()

	case let data as RelayEventDataBufferRename:
		guard let b = bufferBy(name: data.bufferName) else {
			break
		}

		b.bufferName = data.new

		refreshBufferList()
		if b.bufferName == relayBufferCurrent {
			relayBufferCurrent = data.new
			refreshStatus()
		}
		if b.bufferName == relayBufferLast {
			relayBufferLast = data.new
		}

	case let data as RelayEventDataBufferRemove:
		guard let b = bufferBy(name: data.bufferName) else {
			break
		}

		relayBuffers.removeAll(where: { $0 === b })
		refreshBufferList()

		refreshIcon()

	case let data as RelayEventDataBufferActivate:
		let old = bufferBy(name: relayBufferCurrent)
		relayBufferLast = relayBufferCurrent
		relayBufferCurrent = data.bufferName
		guard let b = bufferBy(name: data.bufferName) else {
			break
		}

		if let old = old {
			old.newMessages = 0
			old.newUnimportantMessages = 0
			old.highlighted = false

			old.input = uiInput.stringValue
			// As in the textShouldBeginEditing delegate method.
			if let editor = uiInput.currentEditor() {
				old.inputSelection = editor.selectedRange
			}

			old.historyAt = old.history.count
		}

		// TODO(p): Disable log display, once implemented.
		if !uiWindow.isMiniaturized {
			b.highlighted = false
		}

		if let i = relayBuffers.firstIndex(where: { $0 === b }) {
			uiBufferList.selectRowIndexes(
				IndexSet(integer: i), byExtendingSelection: false)
		}

		refreshIcon()
		refreshTopic(topic: b.topic)
		refreshBuffer(b: b)
		refreshPrompt()
		refreshStatus()

		uiInput.stringValue = b.input
		uiWindow.makeFirstResponder(uiInput)
		if let editor = uiInput.currentEditor() {
			// As in the textShouldEndEditing delegate method.
			if let selection = b.inputSelection {
				editor.selectedRange = selection
			} else {
				editor.selectedRange = NSMakeRange(editor.string.count, 0)
			}
		}

	case let data as RelayEventDataBufferInput:
		guard let b = bufferBy(name: data.bufferName) else {
			break
		}
		if b.historyAt == b.history.count {
			b.historyAt += 1
		}

		b.history.append(data.text)

	case let data as RelayEventDataBufferClear:
		guard let b = bufferBy(name: data.bufferName) else {
			break
		}

		b.lines.removeAll()
		if b.bufferName == relayBufferCurrent {
			refreshBuffer(b: b)
		}

	case let data as RelayEventDataServerUpdate:
		let s: Server
		if let server = relayServers[data.serverName] {
			s = server
		} else {
			s = Server()
			relayServers[data.serverName] = s
		}

		s.state = data.data.state
		s.user.removeAll()
		s.userModes.removeAll()
		if let registered = data.data as? RelayServerDataRegistered {
			s.user = registered.user
			s.userModes = registered.userModes
		}

		refreshPrompt()

	case let data as RelayEventDataServerRename:
		relayServers[data.new] = relayServers[data.serverName]
		relayServers.removeValue(forKey: data.serverName)

	case let data as RelayEventDataServerRemove:
		relayServers.removeValue(forKey: data.serverName)

	default:
		return
	}
}

// --- Input line --------------------------------------------------------------

struct InputStamp: Equatable {
	let input: String
	let selection: NSRange

	init?() {
		guard let textView = uiInput.currentEditor() as? NSTextView else {
			return nil
		}

		self.input = textView.string
		self.selection = textView.selectedRange()
	}
}

class InputDelegate: NSObject, NSTextFieldDelegate {
	func inputSubmit() -> Bool {
		guard let b = bufferBy(name: relayBufferCurrent) else {
			return false
		}

		let input = RelayCommandDataBufferInput(
			bufferName: b.bufferName, text: uiInput.stringValue)

		// Buffer.history[Buffer.history.count] is virtual,
		// and is represented either by edit contents when it's currently
		// being edited, or by Buffer.input in all other cases.
		b.history.append(uiInput.stringValue)
		b.historyAt = b.history.count
		uiInput.stringValue = ""

		relayRPC.send(data: input)
		return true
	}

	func inputComplete(state: InputStamp,
			error: String, data: RelayResponseDataBufferComplete?) {
		guard let data = data else {
			NSSound.beep()
			Logger().warning("\(error)")
			return
		}

		guard let textView = uiInput.currentEditor() as? NSTextView else {
			return
		}
		guard let preceding =
				String(state.input.utf8.prefix(Int(data.start))) else {
			return
		}

		if var insert = data.completions.first {
			if data.completions.count == 1 {
				insert += " "
			}

			textView.insertText(insert, replacementRange: NSMakeRange(
				preceding.count, NSMaxRange(state.selection) - preceding.count))
		}

		if data.completions.count != 1 {
			NSSound.beep()
		}

		// TODO(p): Show all completion options.
		// Cocoa text completion isn't useful, because it searches for word
		// boundaries on its own (otherwise see NSControlTextEditingDelegate).
	}

	func inputComplete(textView: NSTextView) -> Bool {
		// TODO(p): Also add an increasing counter to the stamp.
		guard let state = InputStamp() else {
			return false
		}
		if state.selection.length != 0 {
			return false
		}

		let prefix = state.input.prefix(state.selection.location)
		let complete = RelayCommandDataBufferComplete(
			bufferName: relayBufferCurrent,
			text: state.input,
			position: UInt32(prefix.utf8.count))
		relayRPC.send(data: complete) { (error, data) in
			if state != InputStamp() {
				return
			}

			self.inputComplete(state: state, error: error,
				data: data as? RelayResponseDataBufferComplete)
		}
		return true
	}

	func inputUp(textView: NSTextView) -> Bool {
		guard let b = bufferBy(name: relayBufferCurrent) else {
			return false
		}
		if b.historyAt < 1 {
			return false
		}

		if b.historyAt == b.history.count {
			b.input = uiInput.stringValue
		}
		b.historyAt -= 1
		uiInput.stringValue = b.history[b.historyAt]
		textView.selectedRange = NSMakeRange(textView.string.count, 0)
		return true
	}

	func inputDown(textView: NSTextView) -> Bool {
		guard let b = bufferBy(name: relayBufferCurrent) else {
			return false
		}
		if b.historyAt >= b.history.count {
			return false
		}

		b.historyAt += 1
		if b.historyAt == b.history.count {
			uiInput.stringValue = b.input
		} else {
			uiInput.stringValue = b.history[b.historyAt]
		}
		textView.selectedRange = NSMakeRange(textView.string.count, 0)
		return true
	}

	func control(_ control: NSControl,
		    textShouldBeginEditing fieldEditor: NSText) -> Bool {
		guard let b = bufferBy(name: relayBufferCurrent) else {
			return false
		}
		if let selection = b.inputSelection {
			fieldEditor.selectedRange = selection
		} else {
			fieldEditor.selectedRange = NSMakeRange(fieldEditor.string.count, 0)
		}
		return true
	}

	func control(_ control: NSControl,
		    textShouldEndEditing fieldEditor: NSText) -> Bool {
		guard let b = bufferBy(name: relayBufferCurrent) else {
			return true
		}
		b.inputSelection = fieldEditor.selectedRange
		return true
	}

	func control(_ control: NSControl, textView: NSTextView,
			doCommandBy commandSelector: Selector) -> Bool {
		// TODO(p): Emacs-style cursor movement shortcuts.
		// TODO(p): Once the log is implemented, scroll that if visible.
		var success = true
		switch commandSelector {
		case #selector(NSStandardKeyBindingResponding.insertTab(_:)):
			success = self.inputComplete(textView: textView)
		case #selector(NSStandardKeyBindingResponding.insertNewline(_:)):
			success = self.inputSubmit()
		case #selector(NSStandardKeyBindingResponding.scrollPageUp(_:)):
			uiBuffer.doCommand(by: commandSelector)
		case #selector(NSStandardKeyBindingResponding.scrollPageDown(_:)):
			uiBuffer.doCommand(by: commandSelector)
		case #selector(NSStandardKeyBindingResponding.moveUp(_:)):
			success = self.inputUp(textView: textView)
		case #selector(NSStandardKeyBindingResponding.moveDown(_:)):
			success = self.inputDown(textView: textView)
		default:
			return false
		}
		if !success {
			NSSound.beep()
		}
		return true
	}
}

// --- General UI --------------------------------------------------------------

class BufferListDataSource: NSObject, NSTableViewDataSource {
	func numberOfRows(in tableView: NSTableView) -> Int {
		return relayBuffers.count
	}

	func tableView(_ tableView: NSTableView,
			objectValueFor tableColumn: NSTableColumn?, row: Int) -> Any? {
		let b = relayBuffers[row]
		let result = NSMutableAttributedString(string: b.bufferName)
		if b.bufferName != relayBufferCurrent && b.newMessages != 0 {
			result.mutableString.append(" (\(b.newMessages))")
			result.applyFontTraits(.boldFontMask,
				range: NSMakeRange(0, result.length))
		}
		if b.highlighted {
			result.addAttribute(.foregroundColor,
				value: NSColor.controlAccentColor,
				range: NSMakeRange(0, result.length))
		}
		return result
	}
}

class BufferListDelegate: NSObject, NSTableViewDelegate {
	func tableView(_ tableView: NSTableView,
			shouldEdit: NSTableColumn?, row: Int) -> Bool {
		return false
	}

	func tableView(_ tableView: NSTableView,
			shouldSelectRow row: Int) -> Bool {
		// The framework would select a row during synchronization.
		if !relayBufferCurrent.isEmpty && row < relayBuffers.count {
			bufferActivate(name: relayBuffers[row].bufferName)
		}
		return false
	}
}

class ApplicationDelegate: NSObject, NSApplicationDelegate {
	func applicationDidFinishLaunching(_ notification: Notification) {
		// We need to call them from here,
		// or the menu wouldn't be clickable right after activation.
		app.setActivationPolicy(.regular)
		app.activate(ignoringOtherApps: true)
	}
}

class WindowDelegate: NSObject, NSWindowDelegate {
	func windowWillClose(_ notification: Notification) {
		app.terminate(nil)
	}

	func windowDidDeminiaturize(_ notification: Notification) {
		guard let b = bufferBy(name: relayBufferCurrent) else {
			return
		}

		b.highlighted = false
		refreshIcon()
	}

	// Buffer indexes rotated to start after the current buffer.
	func rotatedBuffers() -> Array<Buffer> {
		guard let i = relayBuffers.firstIndex(
			where: { $0.bufferName == relayBufferCurrent }) else {
			return relayBuffers
		}
		let start = i + 1
		return Array<Buffer>(relayBuffers[start...] + relayBuffers[..<start])
	}

	@objc func actionPreviousBuffer() {
		let rotated = self.rotatedBuffers()
		if rotated.count > 1 {
			bufferActivate(name: rotated[rotated.count - 2].bufferName)
		}
	}

	@objc func actionNextBuffer() {
		if let following = self.rotatedBuffers().first {
			bufferActivate(name: following.bufferName)
		}
	}

	@objc func actionSwitchBuffer() {
		if !relayBufferLast.isEmpty {
			bufferActivate(name: relayBufferLast)
		}
	}

	@objc func actionGotoHighlight() {
		for b in rotatedBuffers() {
			if b.highlighted {
				bufferActivate(name: b.bufferName)
				return
			}
		}
	}

	@objc func actionGotoActivity() {
		for b in rotatedBuffers() {
			if b.newMessages != 0 {
				bufferActivate(name: b.bufferName)
				return
			}
		}
	}

	@objc func actionToggleUnimportant() {
		if let b = bufferBy(name: relayBufferCurrent) {
			bufferToggleUnimportant(name: b.bufferName)
		}
	}
}

// --- Accelerators ------------------------------------------------------------

func pushAccelerator(_ title: String, _ action: Selector,
	_ keyEquivalent: String, _ modifiers: NSEvent.ModifierFlags,
	hidden: Bool = false) {
	let item = NSMenuItem(
		title: title, action: action, keyEquivalent: keyEquivalent)
	item.keyEquivalentModifierMask = modifiers

	// isAlternate doesn't really cover our needs.
	if hidden {
		item.isHidden = true
		item.allowsKeyEquivalentWhenHidden = true
	}
	bufferMenu.addItem(item)
}

pushAccelerator("Previous buffer",
	#selector(WindowDelegate.actionPreviousBuffer),
	"p", [.control])
pushAccelerator("Next buffer",
	#selector(WindowDelegate.actionNextBuffer),
	"n", [.control])
pushAccelerator("Previous buffer",
	#selector(WindowDelegate.actionPreviousBuffer),
	String(UnicodeScalar(NSF5FunctionKey)!), [], hidden: true)
pushAccelerator("Next buffer",
	#selector(WindowDelegate.actionNextBuffer),
	String(UnicodeScalar(NSF6FunctionKey)!), [], hidden: true)
pushAccelerator("Previous buffer",
	#selector(WindowDelegate.actionPreviousBuffer),
	String(UnicodeScalar(NSPageUpFunctionKey)!), [.control], hidden: true)
pushAccelerator("Next buffer",
	#selector(WindowDelegate.actionNextBuffer),
	String(UnicodeScalar(NSPageDownFunctionKey)!), [.control], hidden: true)

// Let's add macOS browser shortcuts for good measure.
pushAccelerator("Previous buffer",
	#selector(WindowDelegate.actionPreviousBuffer),
	"[", [.shift, .command], hidden: true)
pushAccelerator("Next buffer",
	#selector(WindowDelegate.actionNextBuffer),
	"]", [.shift, .command], hidden: true)

pushAccelerator("Switch buffer",
	#selector(WindowDelegate.actionSwitchBuffer),
	"\t", [.control])

// TODO(p): Remove .command, and ignore these with the right Option key.
bufferMenu.addItem(NSMenuItem.separator())
pushAccelerator("Go to highlight",
	#selector(WindowDelegate.actionGotoHighlight),
	"!", [.command, .option])
pushAccelerator("Go to activity",
	#selector(WindowDelegate.actionGotoActivity),
	"a", [.command, .option])

bufferMenu.addItem(NSMenuItem.separator())
pushAccelerator("Toggle unimportant",
	#selector(WindowDelegate.actionToggleUnimportant),
	"H", [.command, .option])

// --- Delegation setup --------------------------------------------------------

let uiInputDelegate = InputDelegate()
uiInput.delegate = uiInputDelegate
let uiBufferListDataSource = BufferListDataSource()
uiBufferList.dataSource = uiBufferListDataSource
let uiBufferListDelegate = BufferListDelegate()
uiBufferList.delegate = uiBufferListDelegate

let appDelegate = ApplicationDelegate()
app.delegate = appDelegate
let uiWindowDelegate = WindowDelegate()
uiWindow.delegate = uiWindowDelegate

// --- Startup -----------------------------------------------------------------

// TODO(p): Ideally, we would show a dialog to enter this information.
let defaults = UserDefaults.standard
var relayHost: String? = defaults.string(forKey: "relayHost")
var relayPort: String? = defaults.string(forKey: "relayPort")

if CommandLine.arguments.count >= 3 {
	relayHost = CommandLine.arguments[1]
	relayPort = CommandLine.arguments[2]
}

if relayHost == nil || relayPort == nil {
	CFUserNotificationDisplayAlert(
		0, kCFUserNotificationStopAlertLevel, nil, nil, nil,
		"\(projectName): Usage error" as CFString,
		("The relay address and port either need to be stored " +
		"in your user defaults, or passed on the command line.") as CFString,
		nil, nil, nil, nil)
	exit(EXIT_FAILURE)
}

if !relayRPC.connect(host: relayHost!, port: relayPort!) {
	CFUserNotificationDisplayAlert(
		0, kCFUserNotificationStopAlertLevel, nil, nil, nil,
		"\(projectName): Usage error" as CFString,
		"Invalid relay address." as CFString,
		nil, nil, nil, nil)
	exit(EXIT_FAILURE)
}

uiWindow.center()
uiWindow.makeFirstResponder(uiInput)
uiWindow.makeKeyAndOrderFront(nil)
app.run()