/*
 * xT.cpp: Qt frontend for xC
 *
 * Copyright (c) 2024, 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.
 *
 */

#include "xC-proto.cpp"
#include "config.h"

#include <cstdint>
#include <functional>
#include <map>
#include <string>

#include <QtEndian>
#include <QtDebug>

#include <QDateTime>
#include <QRegularExpression>

#include <QApplication>
#include <QFontDatabase>
#include <QFormLayout>
#include <QHBoxLayout>
#include <QKeyEvent>
#include <QLabel>
#include <QLineEdit>
#include <QListWidget>
#include <QMainWindow>
#include <QMessageBox>
#include <QPushButton>
#include <QScrollBar>
#include <QShortcut>
#include <QSplitter>
#include <QStackedWidget>
#include <QTextBrowser>
#include <QTextBlock>
#include <QTextEdit>
#include <QTimer>
#include <QToolButton>
#include <QVBoxLayout>
#include <QWindow>

#include <QSoundEffect>
#include <QTcpSocket>

struct Server {
	Relay::ServerState state = {};
	QString user;
	QString user_modes;
};

struct BufferLineItem {
	QTextCharFormat format = {};
	QString text;
};

struct BufferLine {
	/// Leaked from another buffer, but temporarily staying in another one.
	bool leaked = {};

	bool is_unimportant = {};
	bool is_highlight = {};
	Relay::Rendition rendition = {};
	uint64_t when = {};
	std::vector<BufferLineItem> items;
};

struct Buffer {
	QString buffer_name;
	bool hide_unimportant = {};
	Relay::BufferKind kind = {};
	QString server_name;
	std::vector<BufferLine> lines;

	// Channel:

	std::vector<BufferLineItem> topic;
	QString modes;

	// Stats:

	uint32_t new_messages = {};
	uint32_t new_unimportant_messages = {};
	bool highlighted = {};

	// Input:

	// The input is stored as rich text.
	QString input;
	int input_start = {};
	int input_end = {};
	std::vector<QString> history;
	size_t history_at = {};
};

using Callback = std::function<
	void(std::wstring error, const Relay::ResponseData *response)>;

struct {
	QMainWindow *wMain;                 ///< Main program window
	QLabel *wTopic;                     ///< Channel topic
	QListWidget *wBufferList;           ///< Buffer list
	QStackedWidget *wStack;             ///< Buffer backlog/log stack
	QTextBrowser *wBuffer;              ///< Buffer backlog
	QTextBrowser *wLog;                 ///< Buffer log
	QLabel *wPrompt;                    ///< User name, etc.
	QToolButton *wButtonB;              ///< Toggle bold formatting
	QToolButton *wButtonI;              ///< Toggle italic formatting
	QToolButton *wButtonU;              ///< Toggle underlined formatting
	QLabel *wStatus;                    ///< Buffer name, etc.
	QToolButton *wButtonLog;            ///< Buffer log toggle button
	QToolButton *wButtonDown;           ///< Scroll indicator
	QTextEdit *wInput;                  ///< User input

	QTimer *date_change_timer;          ///< Timer for day changes

	QLineEdit *wConnectHost;            ///< Connection dialog: host
	QLineEdit *wConnectPort;            ///< Connection dialog: port
	QDialog *wConnectDialog;            ///< Connection details dialog

	// Networking:

	QString host;                       ///< Host as given by user
	QString port;                       ///< Post/service as given by user

	QTcpSocket *socket;                 ///< Buffered relay socket

	// Relay protocol:

	uint32_t command_seq;               ///< Outgoing message counter

	std::map<uint32_t, Callback> command_callbacks;

	std::vector<Buffer> buffers;        ///< List of all buffers
	QString buffer_current;             ///< Current buffer name or ""
	QString buffer_last;                ///< Previous buffer name or ""

	std::map<QString, Server> servers;
} g;

static void
show_error_message(const QString &message)
{
	QMessageBox::critical(g.wMain, "Error", message, QMessageBox::Ok);
}

static void
beep()
{
	// We don't want to reuse the same instance.
	auto *se = new QSoundEffect(g.wMain);
	QObject::connect(se, &QSoundEffect::playingChanged, [=] {
		if (!se->isPlaying())
			se->deleteLater();
	});
	QObject::connect(se, &QSoundEffect::statusChanged, [=] {
		if (se->status() == QSoundEffect::Error)
			se->deleteLater();
	});

	se->setSource(QUrl("qrc:/beep.wav"));
	se->setLoopCount(1);
	se->setVolume(0.5);
	se->play();
}

// --- Networking --------------------------------------------------------------

static void
relay_send(Relay::CommandData *data, Callback callback = {})
{
	Relay::CommandMessage m = {};
	m.command_seq = ++g.command_seq;
	m.data.reset(data);
	LibertyXDR::Writer w;
	m.serialize(w);

	if (callback)
		g.command_callbacks[m.command_seq] = std::move(callback);

	auto len = qToBigEndian<uint32_t>(w.data.size());
	auto prefix = reinterpret_cast<const char *>(&len);
	auto mdata = reinterpret_cast<const char *>(w.data.data());
	if (g.socket->write(prefix, sizeof len) < 0 ||
		g.socket->write(mdata, w.data.size()) < 0) {
		g.socket->abort();
	}
}

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

static Buffer *
buffer_by_name(const QString &name)
{
	for (auto &b : g.buffers)
		if (b.buffer_name == name)
			return &b;
	return nullptr;
}

static Buffer *
buffer_by_name(const std::wstring &name)
{
	// The C++ LibertyXDR backend unfortunately targets Win32.
	return buffer_by_name(QString::fromStdWString(name));
}

static bool
buffer_at_bottom()
{
	auto sb = g.wBuffer->verticalScrollBar();
	return sb->value() == sb->maximum();
}

static void
buffer_scroll_to_bottom()
{
	auto sb = g.wBuffer->verticalScrollBar();
	sb->setValue(sb->maximum());
}

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

static void
refresh_icon()
{
	// This blocks Linux themes, but oh well.
	QIcon icon(":/xT.png");
	for (const auto &b : g.buffers)
		if (b.highlighted)
			icon = QIcon(":/xT-highlighted.png");

	g.wMain->setWindowIcon(icon);
}

static void
textedit_replacesel(
	QTextEdit *e, const QTextCharFormat &cf, const QString &text)
{
	auto cursor = e->textCursor();
	if (cf.fontFixedPitch()) {
		auto fixed = QFontDatabase::systemFont(QFontDatabase::FixedFont);
		auto adjusted = cf;
		// For some reason, setting the families to empty also works.
		adjusted.setFontFamilies(fixed.families());
		cursor.setCharFormat(adjusted);
	} else {
		cursor.setCharFormat(cf);
	}
	cursor.insertText(text);
}

static void
refresh_topic(const std::vector<BufferLineItem> &topic)
{
	QTextDocument doc;
	QTextCursor cursor(&doc);
	for (const auto &it : topic) {
		cursor.setCharFormat(it.format);
		cursor.insertText(it.text);
	}
	g.wTopic->setText(doc.toHtml());
}

static void
refresh_buffer_list_item(QListWidgetItem *item, const Buffer &b)
{
	auto text = b.buffer_name;
	QFont font;
	QBrush color;
	if (b.buffer_name != g.buffer_current && b.new_messages) {
		text += " (" + QString::number(b.new_messages) + ")";
		font.setBold(true);
	}
	if (b.highlighted)
		color = QColor(0xff, 0x5f, 0x00);

	item->setForeground(color);
	item->setText(text);
	item->setFont(font);
}

static void
refresh_buffer_list()
{
	for (size_t i = 0; i < g.buffers.size(); i++)
		refresh_buffer_list_item(g.wBufferList->item(i), g.buffers.at(i));
}

static QString
server_state_to_string(Relay::ServerState state)
{
	switch (state) {
	case Relay::ServerState::DISCONNECTED:  return "disconnected";
	case Relay::ServerState::CONNECTING:    return "connecting";
	case Relay::ServerState::CONNECTED:     return "connected";
	case Relay::ServerState::REGISTERED:    return "registered";
	case Relay::ServerState::DISCONNECTING: return "disconnecting";
	}
	return {};
}

static void
refresh_prompt()
{
	QString prompt;
	auto b = buffer_by_name(g.buffer_current);
	if (!b) {
		prompt = "Synchronizing...";
	} else if (auto server = g.servers.find(b->server_name);
			server != g.servers.end()) {
		prompt = server->second.user;
		if (!server->second.user_modes.isEmpty())
			prompt += "(" + server->second.user_modes + ")";
		if (prompt.isEmpty())
			prompt = "(" + server_state_to_string(server->second.state) + ")";
	}
	g.wPrompt->setText(prompt);
}

static void
refresh_status()
{
	g.wButtonDown->setEnabled(!buffer_at_bottom());

	QString status = g.buffer_current;
	if (auto b = buffer_by_name(g.buffer_current)) {
		if (!b->modes.isEmpty())
			status += "(+" + b->modes + ")";
		if (b->hide_unimportant)
			status += "<H>";
	}

	// Buffer scrolling would cause a ton of flickering redraws.
	if (g.wStatus->text() != status)
		g.wStatus->setText(status);
}

static void
recheck_highlighted()
{
	// Corresponds to the logic toggling the bool on.
	auto b = buffer_by_name(g.buffer_current);
	if (b && b->highlighted && buffer_at_bottom() &&
		!g.wMain->isMinimized() && !g.wLog->isVisible()) {
		b->highlighted = false;
		refresh_icon();
		refresh_buffer_list();
	}
}

// --- Buffer actions ----------------------------------------------------------

static void
buffer_activate(const QString &name)
{
	auto activate = new Relay::CommandData_BufferActivate();
	activate->buffer_name = name.toStdWString();
	relay_send(activate);
}

static void
buffer_toggle_unimportant(const QString &name)
{
	auto toggle = new Relay::CommandData_BufferToggleUnimportant();
	toggle->buffer_name = name.toStdWString();
	relay_send(toggle);
}

// FIXME: This works on the wrong level, we should take a vector and output
// a filtered vector--we must disregard individual items during URL matching.
static void
convert_links(const QTextCharFormat &format, const QString &text,
	std::vector<BufferLineItem> &result)
{
	static QRegularExpression link_re(
		R"(https?://)"
		R"((?:[^\[\](){}<>"'\s]|\([^\[\](){}<>"'\s]*\))+)"
		R"((?:[^\[\](){}<>"'\s,.:]|\([^\[\](){}<>"'\s]*\)))");

	qsizetype end = 0;
	for (const QRegularExpressionMatch &m : link_re.globalMatch(text)) {
		if (end < m.capturedStart()) {
			result.emplace_back(BufferLineItem{
				format, text.sliced(end, m.capturedStart() - end)});
		}

		BufferLineItem item{format, m.captured()};
		item.format.setAnchor(true);
		item.format.setAnchorHref(m.captured());
		result.emplace_back(std::move(item));

		end = m.capturedEnd();
	}
	if (!end)
		result.emplace_back(BufferLineItem{format, text});
	else if (end < text.length())
		result.emplace_back(BufferLineItem{format, text.sliced(end)});
}

static void
buffer_toggle_log(
	const std::wstring &error, const Relay::ResponseData_BufferLog *response)
{
	if (!response) {
		show_error_message(QString::fromStdWString(error));
		return;
	}

	std::wstring log;
	if (!LibertyXDR::utf8_to_wstring(
			response->log.data(), response->log.size(), log)) {
		show_error_message("Invalid encoding.");
		return;
	}

	std::vector<BufferLineItem> linkified;
	convert_links({}, QString::fromStdWString(log), linkified);

	g.wButtonLog->setChecked(true);
	g.wLog->setText({});
	for (const auto &it : linkified)
		textedit_replacesel(g.wLog, it.format, it.text);
	g.wStack->setCurrentWidget(g.wLog);

	// This triggers a relayout of some kind.
	auto cursor = g.wLog->textCursor();
	cursor.movePosition(QTextCursor::End);
	g.wLog->setTextCursor(cursor);

	auto sb = g.wLog->verticalScrollBar();
	sb->setValue(sb->maximum());
}

static void
buffer_toggle_log()
{
	if (g.wLog->isVisible()) {
		g.wStack->setCurrentWidget(g.wBuffer);
		g.wLog->setText("");
		g.wButtonLog->setChecked(false);

		recheck_highlighted();
		return;
	}

	auto log = new Relay::CommandData_BufferLog();
	log->buffer_name = g.buffer_current.toStdWString();
	relay_send(log, [name = g.buffer_current](auto error, auto response) {
		if (g.buffer_current != name)
			return;
		buffer_toggle_log(error,
			dynamic_cast<const Relay::ResponseData_BufferLog *>(response));
	});
}

// --- QTextEdit formatting ----------------------------------------------------

static QString
rich_text_to_irc(QTextEdit *textEdit)
{
	QString irc;
	for (auto block = textEdit->document()->begin();
		block.isValid(); block = block.next()) {
		for (auto it = block.begin(); it != block.end(); ++it) {
			auto fragment = it.fragment();
			if (!fragment.isValid())
				continue;

			// TODO(p): Colours.
			QString toggles;
			auto format = fragment.charFormat();
			if (format.fontWeight() >= QFont::Bold)
				toggles += "\x02";
			if (format.fontFixedPitch())
				toggles += "\x11";
			if (format.fontItalic())
				toggles += "\x1d";
			if (format.fontStrikeOut())
				toggles += "\x1e";
			if (format.fontUnderline())
				toggles += "\x1f";
			irc += toggles + fragment.text() + toggles;
		}
		if (block.next().isValid())
			irc += "\n";
	}
	return irc;
}

static QString
irc_to_rich_text(const QString &irc)
{
	QTextDocument doc;
	QTextCursor cursor(&doc);
	QTextCharFormat cf;
	bool bold = false, monospace = false, italic = false, crossed = false,
		underline = false;

	QString current;
	auto apply = [&]() {
		if (!current.isEmpty()) {
			cursor.insertText(current, cf);
			current.clear();
		}
	};

	for (int i = 0; i < irc.length(); ++i) {
		switch (irc[i].unicode()) {
		case '\x02':
			apply();
			bold = !bold;
			cf.setFontWeight(bold ? QFont::Bold : QFont::Normal);
			break;
		case '\x03':
			// TODO(p): Decode colours, see xC.
			break;
		case '\x11':
			apply();
			cf.setFontFixedPitch((monospace = !monospace));
			break;
		case '\x1d':
			apply();
			cf.setFontItalic((italic = !italic));
			break;
		case '\x1e':
			apply();
			cf.setFontItalic((crossed = !crossed));
			break;
		case '\x1f':
			apply();
			cf.setFontUnderline((underline = !underline));
			break;
		case '\x0f':
			apply();
			bold = monospace = italic = crossed = underline = false;
			cf = QTextCharFormat();
			break;
		default:
			current += irc[i];
		}
	}
	apply();
	return doc.toHtml();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static QBrush
convert_color(int16_t color)
{
	static const uint16_t base16[] = {
		0x000, 0x800, 0x080, 0x880, 0x008, 0x808, 0x088, 0xccc,
		0x888, 0xf00, 0x0f0, 0xff0, 0x00f, 0xf0f, 0x0ff, 0xfff,
	};
	if (color < 16) {
		uint8_t r = 0xf & (base16[color] >> 8);
		uint8_t g = 0xf & (base16[color] >> 4);
		uint8_t b = 0xf & (base16[color]);
		return QColor(r * 0x11, g * 0x11, b * 0x11);
	}
	if (color >= 216) {
		uint8_t g = 8 + (color - 216) * 10;
		return QColor(g, g, g);
	}

	uint8_t i = color - 16, r = i / 36 >> 0, g = (i / 6 >> 0) % 6, b = i % 6;
	return QColor(
		!r ? 0 : 55 + 40 * r,
		!g ? 0 : 55 + 40 * g,
		!b ? 0 : 55 + 40 * b);
}

static void
convert_item_formatting(
	Relay::ItemData *item, QTextCharFormat &cf, bool &inverse)
{
	if (dynamic_cast<Relay::ItemData_Reset *>(item)) {
		cf = QTextCharFormat();
		inverse = false;
	} else if (dynamic_cast<Relay::ItemData_FlipBold *>(item)) {
		if (cf.fontWeight() <= QFont::Normal)
			cf.setFontWeight(QFont::Bold);
		else
			cf.setFontWeight(QFont::Normal);
	} else if (dynamic_cast<Relay::ItemData_FlipItalic *>(item)) {
		cf.setFontItalic(!cf.fontItalic());
	} else if (dynamic_cast<Relay::ItemData_FlipUnderline *>(item)) {
		cf.setFontUnderline(!cf.fontUnderline());
	} else if (dynamic_cast<Relay::ItemData_FlipCrossedOut *>(item)) {
		cf.setFontStrikeOut(!cf.fontStrikeOut());
	} else if (dynamic_cast<Relay::ItemData_FlipInverse *>(item)) {
		inverse = !inverse;
	} else if (dynamic_cast<Relay::ItemData_FlipMonospace *>(item)) {
		cf.setFontFixedPitch(!cf.fontFixedPitch());
	} else if (auto data = dynamic_cast<Relay::ItemData_FgColor *>(item)) {
		if (data->color < 0) {
			cf.clearForeground();
		} else {
			cf.setForeground(convert_color(data->color));
		}
	} else if (auto data = dynamic_cast<Relay::ItemData_BgColor *>(item)) {
		if (data->color < 0) {
			cf.clearBackground();
		} else {
			cf.setBackground(convert_color(data->color));
		}
	}
}

static std::vector<BufferLineItem>
convert_items(const std::vector<std::unique_ptr<Relay::ItemData>> &items)
{
	QTextCharFormat cf;
	std::vector<BufferLineItem> result;
	bool inverse = false;
	for (const auto &it : items) {
		auto text = dynamic_cast<Relay::ItemData_Text *>(it.get());
		if (!text) {
			convert_item_formatting(it.get(), cf, inverse);
			continue;
		}

		auto item_format = cf;
		auto item_text = QString::fromStdWString(text->text);
		if (inverse) {
			auto fg = item_format.foreground();
			auto bg = item_format.background();
			item_format.setBackground(fg);
			item_format.setForeground(bg);
		}
		convert_links(item_format, item_text, result);
	}
	return result;
}

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

static BufferLine
convert_buffer_line(Relay::EventData_BufferLine &line)
{
	BufferLine self = {};
	self.items = convert_items(line.items);
	self.is_unimportant = line.is_unimportant;
	self.is_highlight = line.is_highlight;
	self.rendition = line.rendition;
	self.when = line.when;
	return self;
}

static void
buffer_print_date_change(
	bool &sameline, const QDateTime &last, const QDateTime &current)
{
	if (last.date() == current.date())
		return;

	auto timestamp = current.toString(&"\n"[sameline] +
		QLocale::system().dateFormat(QLocale::ShortFormat));
	sameline = false;

	QTextCharFormat cf;
	cf.setFontWeight(QFont::Bold);
	textedit_replacesel(g.wBuffer, cf, timestamp);
}

static bool
buffer_reset_selection()
{
	auto sb = g.wBuffer->verticalScrollBar();
	auto value = sb->value();
	g.wBuffer->moveCursor(QTextCursor::End);
	sb->setValue(value);
	return g.wBuffer->textCursor().atBlockStart();
}

static void
buffer_print_and_watch_trailing_date_changes()
{
	auto current = QDateTime::currentDateTime();
	auto b = buffer_by_name(g.buffer_current);
	if (b && !b->lines.empty()) {
		auto last = QDateTime::fromMSecsSinceEpoch(b->lines.back().when);
		bool sameline = buffer_reset_selection();
		buffer_print_date_change(sameline, last, current);
	}

	QDateTime midnight(current.date().addDays(1), {});
	if (midnight < current)
		return;

	// Note that after printing the first trailing update,
	// follow-up updates may be duplicated if timer events arrive too early.
	g.date_change_timer->start(current.msecsTo(midnight) + 1);
}

static void
buffer_print_line(std::vector<BufferLine>::const_iterator begin,
	std::vector<BufferLine>::const_iterator line)
{
	auto current = QDateTime::fromMSecsSinceEpoch(line->when);
	auto last = line == begin ? QDateTime::currentDateTime()
		: QDateTime::fromMSecsSinceEpoch((line - 1)->when);

	bool sameline = buffer_reset_selection();
	buffer_print_date_change(sameline, last, current);

	auto timestamp = current.toString(&"\nHH:mm:ss"[sameline]);
	sameline = false;

	QTextCharFormat cf;
	cf.setForeground(QColor(0xbb, 0xbb, 0xbb));
	cf.setBackground(QColor(0xf8, 0xf8, 0xf8));
	textedit_replacesel(g.wBuffer, cf, timestamp);
	cf = QTextCharFormat();
	textedit_replacesel(g.wBuffer, cf, " ");

	// Tabstops won't quite help us here, since we need it centred.
	QString prefix;
	QTextCharFormat pcf;
	pcf.setFontFixedPitch(true);
	pcf.setFontWeight(QFont::Bold);
	switch (line->rendition) {
	break; case Relay::Rendition::BARE:
	break; case Relay::Rendition::INDENT:
		prefix = "    ";
	break; case Relay::Rendition::STATUS:
		prefix = " -  ";
	break; case Relay::Rendition::ERROR:
		prefix = "=!= ";
		pcf.setForeground(QColor(0xff, 0, 0));
	break; case Relay::Rendition::JOIN:
		prefix = "——> ";
		pcf.setForeground(QColor(0, 0x88, 0));
	break; case Relay::Rendition::PART:
		prefix = "<—— ";
		pcf.setForeground(QColor(0x88, 0, 0));
	break; case Relay::Rendition::ACTION:
		prefix = " *  ";
		pcf.setForeground(QColor(0x88, 0, 0));
	}

	if (line->leaked) {
		auto color = g.wBuffer->palette().color(
			QPalette::Disabled, QPalette::Text);
		pcf.setForeground(color);
		if (!prefix.isEmpty()) {
			textedit_replacesel(g.wBuffer, pcf, prefix);
		}

		for (auto it : line->items) {
			it.format.setForeground(color);
			it.format.clearBackground();
			textedit_replacesel(g.wBuffer, it.format, it.text);
		}
	} else {
		if (!prefix.isEmpty())
			textedit_replacesel(g.wBuffer, pcf, prefix);
		for (const auto &it : line->items)
			textedit_replacesel(g.wBuffer, it.format, it.text);
	}
}

static void
buffer_print_separator()
{
	buffer_reset_selection();

	QTextFrameFormat ff;
	ff.setBackground(QColor(0xff, 0x5f, 0x00));
	ff.setHeight(1);
	// FIXME: When the current frame was empty, this seems to add a newline.
	g.wBuffer->textCursor().insertFrame(ff);
}

static void
refresh_buffer(const Buffer &b)
{
	g.wBuffer->clear();

	size_t i = 0, mark_before = b.lines.size() -
		b.new_messages - b.new_unimportant_messages;
	for (auto line = b.lines.begin(); line != b.lines.end(); ++line) {
		if (i == mark_before)
			buffer_print_separator();
		if (!line->is_unimportant || !b.hide_unimportant)
			buffer_print_line(b.lines.begin(), line);

		i++;
	}

	buffer_print_and_watch_trailing_date_changes();
	buffer_scroll_to_bottom();
	// TODO(p): recheck_highlighted() here, or do we handle enough signals?
}

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

static void
relay_process_buffer_line(Buffer &b, Relay::EventData_BufferLine &m)
{
	// Initial sync: skip all other processing, let highlights be.
	auto bc = buffer_by_name(g.buffer_current);
	if (!bc) {
		b.lines.push_back(convert_buffer_line(m));
		return;
	}

	// Retained mode is complicated.
	bool display = (!m.is_unimportant || !bc->hide_unimportant) &&
		(b.buffer_name == g.buffer_current || m.leak_to_active);
	bool to_bottom = display && buffer_at_bottom();
	bool visible = display &&
		to_bottom &&
		!g.wMain->isMinimized() &&
		!g.wLog->isVisible();
	bool separate = display &&
		!visible && !bc->new_messages && !bc->new_unimportant_messages;

	auto line = b.lines.insert(b.lines.end(), convert_buffer_line(m));
	if (!(visible || m.leak_to_active) ||
		b.new_messages || b.new_unimportant_messages) {
		if (line->is_unimportant || m.leak_to_active)
			b.new_unimportant_messages++;
		else
			b.new_messages++;
	}

	if (m.leak_to_active) {
		auto line = bc->lines.insert(bc->lines.end(), convert_buffer_line(m));
		line->leaked = true;
		if (!visible || bc->new_messages || bc->new_unimportant_messages) {
			if (line->is_unimportant)
				bc->new_unimportant_messages++;
			else
				bc->new_messages++;
		}
	}
	if (separate)
		buffer_print_separator();
	if (display)
		buffer_print_line(bc->lines.begin(), bc->lines.end() - 1);
	if (to_bottom)
		buffer_scroll_to_bottom();

	if (line->is_highlight || (!visible && !line->is_unimportant &&
		b.kind == Relay::BufferKind::PRIVATE_MESSAGE)) {
		beep();

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

	refresh_buffer_list();
}

static void
relay_process_callbacks(uint32_t command_seq,
	const std::wstring& error, const Relay::ResponseData *response)
{
	auto &callbacks = g.command_callbacks;
	auto handler = callbacks.find(command_seq);
	if (handler == callbacks.end()) {
		// TODO(p): Warn about an unawaited response.
	} else {
		if (handler->second)
			handler->second(error, response);
		callbacks.erase(handler);
	}

	// We don't particularly care about wraparound issues.
	while (!callbacks.empty() && callbacks.begin()->first <= command_seq) {
		auto front = callbacks.begin();
		if (front->second)
			front->second(L"No response", nullptr);
		callbacks.erase(front);
	}
}

static void
relay_process_message(const Relay::EventMessage &m)
{
	switch (m.data->event) {
	case Relay::Event::ERROR:
	{
		auto data = dynamic_cast<Relay::EventData_Error *>(m.data.get());
		relay_process_callbacks(data->command_seq, data->error, nullptr);
		break;
	}
	case Relay::Event::RESPONSE:
	{
		auto data = dynamic_cast<Relay::EventData_Response *>(m.data.get());
		relay_process_callbacks(data->command_seq, {}, data->data.get());
		break;
	}

	case Relay::Event::PING:
	{
		auto pong = new Relay::CommandData_PingResponse();
		pong->event_seq = m.event_seq;
		relay_send(pong);
		break;
	}

	case Relay::Event::BUFFER_LINE:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferLine &>(*m.data);
		auto b = buffer_by_name(data.buffer_name);
		if (!b)
			break;

		relay_process_buffer_line(*b, data);
		break;
	}
	case Relay::Event::BUFFER_UPDATE:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferUpdate &>(*m.data);
		auto b = buffer_by_name(data.buffer_name);
		if (!b) {
			b = &*g.buffers.insert(g.buffers.end(), Buffer());
			b->buffer_name = QString::fromStdWString(data.buffer_name);

			auto item = new QListWidgetItem;
			refresh_buffer_list_item(item, *b);
			g.wBufferList->addItem(item);
		}

		bool hiding_toggled = b->hide_unimportant != data.hide_unimportant;
		b->hide_unimportant = data.hide_unimportant;
		b->kind = data.context->kind;
		b->server_name.clear();
		if (auto context = dynamic_cast<Relay::BufferContext_Server *>(
				data.context.get()))
			b->server_name = QString::fromStdWString(context->server_name);
		if (auto context = dynamic_cast<Relay::BufferContext_Channel *>(
				data.context.get())) {
			b->server_name = QString::fromStdWString(context->server_name);
			b->modes = QString::fromStdWString(context->modes);
			b->topic = convert_items(context->topic);
		}
		if (auto context = dynamic_cast<Relay::BufferContext_PrivateMessage *>(
				data.context.get()))
			b->server_name = QString::fromStdWString(context->server_name);

		if (b->buffer_name == g.buffer_current) {
			refresh_topic(b->topic);
			refresh_status();

			if (hiding_toggled)
				refresh_buffer(*b);
		}
		break;
	}
	case Relay::Event::BUFFER_STATS:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferStats &>(*m.data);
		auto b = buffer_by_name(data.buffer_name);
		if (!b)
			break;

		b->new_messages = data.new_messages;
		b->new_unimportant_messages = data.new_unimportant_messages;
		b->highlighted = data.highlighted;

		refresh_icon();
		refresh_buffer_list();
		break;
	}
	case Relay::Event::BUFFER_RENAME:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferRename &>(*m.data);
		auto b = buffer_by_name(data.buffer_name);
		if (!b)
			break;

		auto original = b->buffer_name;
		b->buffer_name = QString::fromStdWString(data.new_);

		if (original == g.buffer_current) {
			g.buffer_current = b->buffer_name;
			refresh_status();
		}
		refresh_buffer_list();
		if (original == g.buffer_last)
			g.buffer_last = b->buffer_name;
		break;
	}
	case Relay::Event::BUFFER_REMOVE:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferRemove &>(*m.data);
		auto b = buffer_by_name(data.buffer_name);
		if (!b)
			break;

		int index = b - g.buffers.data();
		delete g.wBufferList->takeItem(index);
		g.buffers.erase(g.buffers.begin() + index);

		refresh_icon();
		break;
	}
	case Relay::Event::BUFFER_ACTIVATE:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferActivate &>(*m.data);
		Buffer *old = buffer_by_name(g.buffer_current);
		g.buffer_last = g.buffer_current;
		g.buffer_current = QString::fromStdWString(data.buffer_name);
		auto b = buffer_by_name(data.buffer_name);
		if (!b)
			break;

		if (old) {
			old->new_messages = 0;
			old->new_unimportant_messages = 0;
			old->highlighted = false;

			old->input = g.wInput->toHtml();
			old->input_start = g.wInput->textCursor().selectionStart();
			old->input_end = g.wInput->textCursor().selectionEnd();

			// Note that we effectively overwrite the newest line
			// with the current textarea contents, and jump there.
			old->history_at = old->history.size();
		}

		if (g.wLog->isVisible())
			buffer_toggle_log();
		if (!g.wMain->isMinimized())
			b->highlighted = false;
		auto item = g.wBufferList->item(b - g.buffers.data());
		refresh_buffer_list_item(item, *b);
		g.wBufferList->setCurrentItem(item);

		refresh_icon();
		refresh_topic(b->topic);
		refresh_buffer(*b);
		refresh_prompt();
		refresh_status();

		g.wInput->setHtml(b->input);
		g.wInput->textCursor().setPosition(b->input_start);
		g.wInput->textCursor().setPosition(
			b->input_end, QTextCursor::KeepAnchor);
		g.wInput->setFocus();
		break;
	}
	case Relay::Event::BUFFER_INPUT:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferInput &>(*m.data);
		auto b = buffer_by_name(data.buffer_name);
		if (!b)
			break;

		if (b->history_at == b->history.size())
			b->history_at++;
		b->history.push_back(
			irc_to_rich_text(QString::fromStdWString(data.text)));
		break;
	}
	case Relay::Event::BUFFER_CLEAR:
	{
		auto &data = dynamic_cast<Relay::EventData_BufferClear &>(*m.data);
		auto b = buffer_by_name(data.buffer_name);
		if (!b)
			break;

		b->lines.clear();
		if (b->buffer_name == g.buffer_current)
			refresh_buffer(*b);
		break;
	}

	case Relay::Event::SERVER_UPDATE:
	{
		auto &data = dynamic_cast<Relay::EventData_ServerUpdate &>(*m.data);
		auto name = QString::fromStdWString(data.server_name);
		if (!g.servers.count(name))
			g.servers.emplace(name, Server());

		auto &server = g.servers.at(name);
		server.state = data.data->state;

		server.user.clear();
		server.user_modes.clear();
		if (auto registered = dynamic_cast<Relay::ServerData_Registered *>(
				data.data.get())) {
			server.user = QString::fromStdWString(registered->user);
			server.user_modes = QString::fromStdWString(registered->user_modes);
		}

		refresh_prompt();
		break;
	}
	case Relay::Event::SERVER_RENAME:
	{
		auto &data = dynamic_cast<Relay::EventData_ServerRename &>(*m.data);
		auto original = QString::fromStdWString(data.server_name);
		g.servers.insert_or_assign(
			QString::fromStdWString(data.new_), g.servers.at(original));
		g.servers.erase(original);
		break;
	}
	case Relay::Event::SERVER_REMOVE:
	{
		auto &data = dynamic_cast<Relay::EventData_ServerRemove &>(*m.data);
		auto name = QString::fromStdWString(data.server_name);
		g.servers.erase(name);
		break;
	}
	}
}

// --- Networking --------------------------------------------------------------

static void
relay_show_dialog()
{
	g.wConnectHost->setText(g.host);
	g.wConnectPort->setText(g.port);
	g.wConnectDialog->move(
		g.wMain->frameGeometry().center() - g.wConnectDialog->rect().center());
	switch (g.wConnectDialog->exec()) {
	case QDialog::Accepted:
		g.host = g.wConnectHost->text();
		g.port = g.wConnectPort->text();
		g.socket->connectToHost(g.host, g.port.toUShort());
		break;
	case QDialog::Rejected:
		QCoreApplication::exit();
	}
}

static void
relay_process_error([[maybe_unused]] QAbstractSocket::SocketError err)
{
	show_error_message(g.socket->errorString());
	g.socket->abort();
	QTimer::singleShot(0, relay_show_dialog);
}

static void
relay_process_connected()
{
	g.command_seq = 0;
	g.command_callbacks.clear();

	g.buffers.clear();
	g.buffer_current.clear();
	g.buffer_last.clear();
	g.servers.clear();

	refresh_icon();
	refresh_topic({});
	g.wBufferList->clear();
	g.wBuffer->clear();
	refresh_prompt();
	refresh_status();

	auto hello = new Relay::CommandData_Hello();
	hello->version = Relay::VERSION;
	relay_send(hello);
}

static bool
relay_process_buffer(QString &error)
{
	// How I wish I could access the internal read buffer directly.
	auto s = g.socket;
	union {
		uint32_t frame_len = 0;
		char buf[sizeof frame_len];
	};
	while (s->peek(buf, sizeof buf) == sizeof buf) {
		frame_len = qFromBigEndian(frame_len);
		if (s->bytesAvailable() < qint64(sizeof frame_len + frame_len))
			break;

		s->skip(sizeof frame_len);
		auto b = s->read(frame_len);
		LibertyXDR::Reader r;
		r.data = reinterpret_cast<const uint8_t *>(b.data());
		r.length = b.size();

		Relay::EventMessage m = {};
		if (!m.deserialize(r) || r.length) {
			error = "Deserialization failed.";
			return false;
		}

		relay_process_message(m);
	}
	return true;
}

static void
relay_process_ready()
{
	QString err;
	if (!relay_process_buffer(err)) {
		show_error_message(err);
		g.socket->abort();
		QTimer::singleShot(0, relay_show_dialog);
	}
}

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

static void
input_set_contents(const QString &input)
{
	g.wInput->setHtml(input);

	auto cursor = g.wInput->textCursor();
	cursor.movePosition(QTextCursor::End);
	g.wInput->setTextCursor(cursor);
	g.wInput->ensureCursorVisible();
}

static bool
input_submit()
{
	auto b = buffer_by_name(g.buffer_current);
	if (!b)
		return false;

	auto input = new Relay::CommandData_BufferInput();
	input->buffer_name = b->buffer_name.toStdWString();
	input->text = rich_text_to_irc(g.wInput).toStdWString();

	// Buffer::history[Buffer::history.size()] 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.push_back(g.wInput->toHtml());
	b->history_at = b->history.size();
	input_set_contents("");

	relay_send(input);
	return true;
}

struct InputStamp {
	int start = {};
	int end = {};
	QString input;
};

static InputStamp
input_stamp()
{
	// Hopefully, the selection markers match the plain text characters.
	auto start = g.wInput->textCursor().selectionStart();
	auto end = g.wInput->textCursor().selectionEnd();
	return {start, end, g.wInput->toPlainText()};
}

static void
input_complete(const InputStamp &state, const std::wstring &error,
	const Relay::ResponseData_BufferComplete *response)
{
	if (!response) {
		show_error_message(QString::fromStdWString(error));
		return;
	}

	auto utf8 = state.input.sliced(0, state.start).toUtf8();
	auto preceding = QString(utf8.sliced(0, response->start));
	if (response->completions.size() > 0) {
		auto insert = response->completions.at(0);
		if (response->completions.size() == 1)
			insert += L" ";

		auto cursor = g.wInput->textCursor();
		cursor.setPosition(preceding.length());
		cursor.setPosition(state.end, QTextCursor::KeepAnchor);
		cursor.insertHtml(irc_to_rich_text(QString::fromStdWString(insert)));
	}

	if (response->completions.size() != 1)
		beep();

	// TODO(p): Show all completion options.
}

static bool
input_complete()
{
	// TODO(p): Also add an increasing counter to the stamp.
	auto state = input_stamp();
	if (state.start != state.end)
		return false;

	auto utf8 = state.input.sliced(0, state.start).toUtf8();
	auto complete = new Relay::CommandData_BufferComplete();
	complete->buffer_name = g.buffer_current.toStdWString();
	complete->text = state.input.toStdWString();
	complete->position = utf8.size();
	relay_send(complete, [state](auto error, auto response) {
		auto stamp = input_stamp();
		if (std::make_tuple(stamp.start, stamp.end, stamp.input) !=
			std::make_tuple(state.start, state.end, state.input))
			return;
		input_complete(stamp, error,
			dynamic_cast<const Relay::ResponseData_BufferComplete *>(response));
	});
	return true;
}

static bool
input_up()
{
	auto b = buffer_by_name(g.buffer_current);
	if (!b || b->history_at < 1)
		return false;

	if (b->history_at == b->history.size())
		b->input = g.wInput->toHtml();
	input_set_contents(b->history.at(--b->history_at));
	return true;
}

static bool
input_down()
{
	auto b = buffer_by_name(g.buffer_current);
	if (!b || b->history_at >= b->history.size())
		return false;

	input_set_contents(++b->history_at == b->history.size()
		? b->input
		: b->history.at(b->history_at));
	return true;
}

class InputEdit : public QTextEdit {
	Q_OBJECT

public:
	explicit InputEdit(QWidget *parent = nullptr) : QTextEdit(parent) {}

	void keyPressEvent(QKeyEvent *event) override
	{
		auto scrollable = g.wLog->isVisible()
			? g.wLog->verticalScrollBar()
			: g.wBuffer->verticalScrollBar();

		QKeyCombination combo(
			event->modifiers() & ~Qt::KeypadModifier, Qt::Key(event->key()));
		switch (combo.toCombined()) {
		case Qt::Key_Return:
		case Qt::Key_Enter:
			input_submit();
			break;
		case QKeyCombination(Qt::ShiftModifier, Qt::Key_Return).toCombined():
		case QKeyCombination(Qt::ShiftModifier, Qt::Key_Enter).toCombined():
			// Qt amazingly inserts U+2028 LINE SEPARATOR instead.
			this->textCursor().insertText("\n");
			break;
		case Qt::Key_Tab:
			input_complete();
			break;
		case QKeyCombination(Qt::AltModifier, Qt::Key_P).toCombined():
		case Qt::Key_Up:
			input_up();
			break;
		case QKeyCombination(Qt::AltModifier, Qt::Key_N).toCombined():
		case Qt::Key_Down:
			input_down();
			break;
		case Qt::Key_PageUp:
			scrollable->setValue(scrollable->value() - scrollable->pageStep());
			break;
		case Qt::Key_PageDown:
			scrollable->setValue(scrollable->value() + scrollable->pageStep());
			break;

		default:
			QTextEdit::keyPressEvent(event);
			return;
		}
		event->accept();
	}
};

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

class BufferEdit : public QTextBrowser {
	Q_OBJECT

public:
	explicit BufferEdit(QWidget *parent = nullptr) : QTextBrowser(parent) {}

	void resizeEvent(QResizeEvent *event) override
	{
		bool to_bottom = buffer_at_bottom();
		QTextBrowser::resizeEvent(event);
		if (to_bottom) {
			buffer_scroll_to_bottom();
		} else {
			recheck_highlighted();
			refresh_status();
		}
	}
};

static void
build_main_window()
{
	g.wMain = new QMainWindow;

	auto central = new QWidget(g.wMain);
	auto vbox = new QVBoxLayout(central);
	vbox->setContentsMargins(4, 4, 4, 4);

	g.wTopic = new QLabel(central);
	g.wTopic->setTextFormat(Qt::RichText);
	vbox->addWidget(g.wTopic);

	auto splitter = new QSplitter(Qt::Horizontal, central);
	splitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

	g.wBufferList = new QListWidget(splitter);
	g.wBufferList->setSizePolicy(
		QSizePolicy::Preferred, QSizePolicy::Expanding);
	QObject::connect(g.wBufferList, &QListWidget::currentRowChanged,
		[](int row) {
			if (row >= 0 && (size_t) row < g.buffers.size())
				buffer_activate(g.buffers.at(row).buffer_name);
		});

	g.wStack = new QStackedWidget(splitter);

	g.wBuffer = new BufferEdit(g.wStack);
	g.wBuffer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	g.wBuffer->setReadOnly(true);
	g.wBuffer->setTextInteractionFlags(
		Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard |
		Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);
	g.wBuffer->setOpenExternalLinks(true);
	QObject::connect(g.wBuffer->verticalScrollBar(), &QScrollBar::valueChanged,
		[]([[maybe_unused]] int value) {
			recheck_highlighted();
			refresh_status();
		});
	QObject::connect(g.wBuffer->verticalScrollBar(), &QScrollBar::rangeChanged,
		[]([[maybe_unused]] int min, [[maybe_unused]] int max) {
			recheck_highlighted();
			refresh_status();
		});

	g.wLog = new QTextBrowser(g.wStack);
	g.wLog->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	g.wLog->setReadOnly(true);
	g.wLog->setTextInteractionFlags(
		Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard |
		Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);
	g.wLog->setOpenExternalLinks(true);

	g.wStack->addWidget(g.wBuffer);
	g.wStack->addWidget(g.wLog);

	splitter->addWidget(g.wBufferList);
	splitter->setStretchFactor(0, 1);
	splitter->addWidget(g.wStack);
	splitter->setStretchFactor(1, 2);
	vbox->addWidget(splitter);

	auto hbox = new QHBoxLayout();
	g.wPrompt = new QLabel(central);
	hbox->addWidget(g.wPrompt);

	g.wButtonB = new QToolButton(central);
	g.wButtonB->setText("&B");
	g.wButtonB->setCheckable(true);
	hbox->addWidget(g.wButtonB);
	g.wButtonI = new QToolButton(central);
	g.wButtonI->setText("&I");
	g.wButtonI->setCheckable(true);
	hbox->addWidget(g.wButtonI);
	g.wButtonU = new QToolButton(central);
	g.wButtonU->setText("&U");
	g.wButtonU->setCheckable(true);
	hbox->addWidget(g.wButtonU);

	g.wStatus = new QLabel(central);
	g.wStatus->setAlignment(
		Qt::AlignRight | Qt::AlignTrailing | Qt::AlignVCenter);
	hbox->addWidget(g.wStatus);

	g.wButtonLog = new QToolButton(central);
	g.wButtonLog->setText("&Log");
	g.wButtonLog->setCheckable(true);
	QObject::connect(g.wButtonLog, &QToolButton::clicked,
		[]([[maybe_unused]] bool checked) { buffer_toggle_log(); });
	hbox->addWidget(g.wButtonLog);

	g.wButtonDown = new QToolButton(central);
	g.wButtonDown->setIcon(
		QApplication::style()->standardIcon(QStyle::SP_ArrowDown));
	g.wButtonDown->setToolButtonStyle(Qt::ToolButtonIconOnly);
	QObject::connect(g.wButtonDown, &QToolButton::clicked,
		[]([[maybe_unused]] bool checked) { buffer_scroll_to_bottom(); });
	hbox->addWidget(g.wButtonDown);
	vbox->addLayout(hbox);

	g.wInput = new InputEdit(central);
	g.wInput->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
	g.wInput->setMaximumHeight(50);
	vbox->addWidget(g.wInput);

	// TODO(p): Figure out why this is not reliable.
	QObject::connect(g.wInput, &QTextEdit::currentCharFormatChanged,
		[](const QTextCharFormat &format) {
			g.wButtonB->setChecked(format.fontWeight() >= QFont::Bold);
			g.wButtonI->setChecked(format.fontItalic());
			g.wButtonU->setChecked(format.fontUnderline());
		});

	QObject::connect(g.wButtonB, &QToolButton::clicked,
		[](bool checked) {
			auto cursor = g.wInput->textCursor();
			auto format = cursor.charFormat();
			format.setFontWeight(checked ? QFont::Bold : QFont::Normal);
			cursor.mergeCharFormat(format);
			g.wInput->setTextCursor(cursor);
		});
	QObject::connect(g.wButtonI, &QToolButton::clicked,
		[](bool checked) {
			auto cursor = g.wInput->textCursor();
			auto format = cursor.charFormat();
			format.setFontItalic(checked);
			cursor.mergeCharFormat(format);
			g.wInput->setTextCursor(cursor);
		});
	QObject::connect(g.wButtonU, &QToolButton::clicked,
		[](bool checked) {
			auto cursor = g.wInput->textCursor();
			auto format = cursor.charFormat();
			format.setFontUnderline(checked);
			cursor.mergeCharFormat(format);
			g.wInput->setTextCursor(cursor);
		});

	central->setLayout(vbox);
	g.wMain->setCentralWidget(central);
	g.wMain->show();
}

static void
build_connect_dialog()
{
	auto dialog = g.wConnectDialog = new QDialog(g.wMain);
	dialog->setModal(true);
	dialog->setWindowTitle("Connect to relay");

	auto layout = new QFormLayout();
	g.wConnectHost = new QLineEdit(dialog);
	layout->addRow("&Host:", g.wConnectHost);
	g.wConnectPort = new QLineEdit(dialog);
	auto validator = new QIntValidator(0, 0xffff, g.wConnectDialog);
	g.wConnectPort->setValidator(validator);
	layout->addRow("&Port:", g.wConnectPort);

	auto buttons = new QDialogButtonBox(dialog);
	buttons->addButton(new QPushButton("&Connect", buttons),
		QDialogButtonBox::AcceptRole);
	buttons->addButton(new QPushButton("&Exit", buttons),
		QDialogButtonBox::RejectRole);
	QObject::connect(buttons, &QDialogButtonBox::accepted,
		dialog, &QDialog::accept);
	QObject::connect(buttons, &QDialogButtonBox::rejected,
		dialog, &QDialog::reject);

	auto vbox = new QVBoxLayout();
	vbox->addLayout(layout);
	vbox->addWidget(buttons);
	dialog->setLayout(vbox);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static std::vector<size_t>
rotated_buffers()
{
	std::vector<size_t> rotated(g.buffers.size());
	size_t start = 0;
	for (auto it = g.buffers.begin(); it != g.buffers.end(); ++it)
		if (it->buffer_name == g.buffer_current) {
			start = it - g.buffers.begin();
			break;
		}
	for (auto &index : rotated)
		index = ++start % g.buffers.size();
	return rotated;
}

static void
bind_shortcuts()
{
	auto previous_buffer = [] {
		auto rotated = rotated_buffers();
		if (rotated.size() > 0) {
			size_t i = (rotated.back() ? rotated.back() : g.buffers.size()) - 1;
			buffer_activate(g.buffers[i].buffer_name);
		}
	};
	auto next_buffer = [] {
		auto rotated = rotated_buffers();
		if (rotated.size() > 0)
			buffer_activate(g.buffers[rotated.front()].buffer_name);
	};
	auto switch_buffer = [] {
		if (auto b = buffer_by_name(g.buffer_last))
			buffer_activate(b->buffer_name);
	};
	auto goto_highlight = [] {
		for (auto i : rotated_buffers())
			if (g.buffers[i].highlighted) {
				buffer_activate(g.buffers[i].buffer_name);
				break;
			}
	};
	auto goto_activity = [] {
		for (auto i : rotated_buffers())
			if (g.buffers[i].new_messages) {
				buffer_activate(g.buffers[i].buffer_name);
				break;
			}
	};
	auto toggle_unimportant = [] {
		if (auto b = buffer_by_name(g.buffer_current))
			buffer_toggle_unimportant(b->buffer_name);
	};

	new QShortcut(QKeyCombination(Qt::ControlModifier, Qt::Key_Tab),
		g.wMain, switch_buffer);
	new QShortcut(QKeyCombination(Qt::AltModifier, Qt::Key_Tab),
		g.wMain, switch_buffer);

	new QShortcut(QKeyCombination(Qt::NoModifier, Qt::Key_F5),
		g.wMain, previous_buffer);
	new QShortcut(QKeyCombination(Qt::AltModifier, Qt::Key_PageUp),
		g.wMain, previous_buffer);
	new QShortcut(QKeyCombination(Qt::ControlModifier, Qt::Key_PageUp),
		g.wMain, previous_buffer);
	new QShortcut(QKeyCombination(Qt::NoModifier, Qt::Key_F6),
		g.wMain, next_buffer);
	new QShortcut(QKeyCombination(Qt::AltModifier, Qt::Key_PageDown),
		g.wMain, next_buffer);
	new QShortcut(QKeyCombination(Qt::ControlModifier, Qt::Key_PageDown),
		g.wMain, next_buffer);

	new QShortcut(QKeyCombination(Qt::AltModifier, Qt::Key_A),
		g.wMain, goto_activity);
	new QShortcut(QKeyCombination(Qt::AltModifier, Qt::Key_Exclam),
		g.wMain, goto_highlight);
	new QShortcut(QKeyCombination(Qt::AltModifier, Qt::Key_H),
		g.wMain, toggle_unimportant);
}

int
main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	auto args = app.arguments();
	if (args.size() != 1 && args.size() != 3) {
		QMessageBox::critical(nullptr, "Error", "Usage: xT [HOST PORT]",
			QMessageBox::Close);
		return 1;
	}

	build_main_window();
	build_connect_dialog();
	bind_shortcuts();

	g.date_change_timer = new QTimer(g.wMain);
	g.date_change_timer->setSingleShot(true);
	QObject::connect(g.date_change_timer, &QTimer::timeout, [] {
		bool to_bottom = buffer_at_bottom();
		buffer_print_and_watch_trailing_date_changes();
		if (to_bottom)
			buffer_scroll_to_bottom();
	});

	g.socket = new QTcpSocket(g.wMain);
	QObject::connect(g.socket, &QTcpSocket::errorOccurred,
		relay_process_error);
	QObject::connect(g.socket, &QTcpSocket::connected,
		relay_process_connected);
	QObject::connect(g.socket, &QTcpSocket::readyRead,
		relay_process_ready);
	if (args.size() == 3) {
		g.host = args[1];
		g.port = args[2];
		g.socket->connectToHost(g.host, g.port.toUShort());
	} else {
		// Allow it to center on its parent, which must be realized.
		while (!g.wMain->windowHandle()->isExposed())
			app.processEvents();
		QTimer::singleShot(0, relay_show_dialog);
	}

	int result = app.exec();
	delete g.wMain;
	return result;
}

// Normally, QObjects should be placed in header files, which we don't do.
#include "xT.moc"