// matrix-puppeteer-line - A very hacky Matrix-LINE bridge based on running LINE's Chrome extension in Puppeteer
// Copyright (C) 2020-2021 Tulir Asokan, Andrew Ferrazzutti
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

// Definitions and docs for methods that the Puppeteer script exposes for the content script
/**
 * @param {string} text - The date string to parse
 * @param {Date} [ref] - Reference date to parse relative times
 * @param {{[forwardDate]: boolean}} [option] - Extra options for parser
 * @return {Promise<Date>}
 */
window.__chronoParseDate = function (text, ref, option) {}
/**
 * @param {string[]} changes - The hrefs of the chats that changed.
 * @return {Promise<void>}
 */
window.__mautrixReceiveChanges = function (changes) {}
/**
 * @param {string} messages - The ID of the chat receiving messages.
 * @param {MessageData[]} messages - The messages added to a chat.
 * @return {Promise<void>}
 */
window.__mautrixReceiveMessages = function (chatID, messages) {}
/**
 * @param {string} chatID - The ID of the chat whose receipts are being processed.
 * @param {string} receipt_id - The ID of the most recently-read message for the current chat.
 * @return {Promise<void>}
 */
window.__mautrixReceiveReceiptDirectLatest = function (chatID, receipt_id) {}
/**
 * @param {string} chatID - The ID of the chat whose receipts are being processed.
 * @param {[Receipt]} receipts - All newly-seen receipts for the current chat.
 * @return {Promise<void>}
 */
window.__mautrixReceiveReceiptMulti = function (chat_id, receipts) {}
/**
 * @param {string} url - The URL for the QR code.
 * @return {Promise<void>}
 */
window.__mautrixReceiveQR = function (url) {}
/**
 * @return {Promise<void>}
 */
window.__mautrixSendEmailCredentials = function () {}
/**
 * @param {string} pin - The login PIN.
 * @return {Promise<void>}
 */
window.__mautrixReceivePIN = function (pin) {}
/**
 * @param {Element} button - The button to click when a QR code or PIN expires.
 * @return {Promise<void>}
 */
window.__mautrixExpiry = function (button) {}
/**
 * @param {number} id - The ID of the message that was sent
 * @return {Promise<void>}
 */
window.__mautrixReceiveMessageID = function(id) {}
/**
 * @return {void}
 */
window.__mautrixLoggedOut = function() {}

/**
 * typedef ChatTypeEnum
 */
const ChatTypeEnum = Object.freeze({
	DIRECT: 1,
	GROUP: 2,
	ROOM: 3,
})

const MSG_DECRYPTING = "ⓘ Decrypting..."
// TODO consts for common selectors

class MautrixController {
	constructor() {
		this.chatListObserver = null
		this.msgListObserver = null
		this.receiptObserver = null

		this.qrChangeObserver = null
		this.qrAppearObserver = null
		this.emailAppearObserver = null
		this.pinAppearObserver = null
		this.ownID = null

		this._promiseOwnMsgReset()
	}

	setOwnID(ownID) {
		// Remove characters that will conflict with mxid grammar
		const suffix = ownID.slice(1).replace(":", "_ON_")
		this.ownID = `_OWN_${suffix}`
	}

	// TODO Commonize with Node context
	getChatType(id) {
		switch (id.charAt(0)) {
		case "u":
			return ChatTypeEnum.DIRECT
		case "c":
			return ChatTypeEnum.GROUP
		case "r":
			return ChatTypeEnum.ROOM
		default:
			throw `Invalid chat ID: ${id}`
		}
	}

	getCurrentChatID() {
		const chatListElement = document.querySelector("#_chat_list_body > .ExSelected > .chatList")
		return chatListElement ? this.getChatListItemID(chatListElement) : null
	}

	/**
	 * Parse a date string.
	 *
	 * @param {string} text - The string to parse
	 * @param {Date} [ref] - Reference date to parse relative times
	 * @param {{[forwardDate]: boolean}} [option] - Extra options for parser
	 * @return {Promise<?Date>} - The date, or null if parsing failed.
	 * @private
	 */
	async _tryParseDate(text, ref, option) {
		const parsed = await window.__chronoParseDate(text, ref, option)
		return parsed ? new Date(parsed) : null
	}

	/**
	 * Parse a date separator.
	 *
	 * @param {string} text - The text in the date saparator.
	 * @return {Promise<?Date>} - The value of the date separator.
	 * @private
	 */
	async _tryParseDateSeparator(text) {
		if (!text) {
			return null
		}
		// Must prefix with midnight to prevent getting noon
		text = "00:00 " + text.replace(/\. /, "/")
		const now = new Date()
		let newDate = await this._tryParseDate(text)
		if (!newDate || newDate > now) {
			const lastWeek = new Date()
			lastWeek.setDate(lastWeek.getDate() - 7)
			newDate = await this._tryParseDate(text, lastWeek, { forwardDate: true })
		}
		return newDate && newDate <= now ? newDate : null
	}

	/**
	 * Try to match a user against an entry in the friends list to get their ID.
	 *
	 * @param {string} senderName - The display name of the user to find the ID for.
	 * @return {?string}          - The user's ID if found.
	 */
	getUserIdFromFriendsList(senderName) {
		return document.querySelector(`#contact_wrap_friends > ul > li[title='${senderName}']`)?.getAttribute("data-mid")
	}

	/**
	 * @typedef MessageData
	 * @type {object}
	 * @property {number}  id          - The ID of the message. Seems to be sequential.
	 * @property {number}  timestamp   - The unix timestamp of the message. Accurate to the minute.
	 * @property {boolean} is_outgoing - Whether or not this user sent the message.
	 * @property {?Participant} sender - Full data of the participant who sent the message, if needed and available.
	 * @property {?string} html        - The HTML format of the message, if necessary.
	 * @property {?ImageInfo} image    - Information of the image in the message, if it's an image-only message.
	 * @property {?int} receipt_count  - The number of users who have read the message.
	 */

	/**
	 * @typedef ImageInfo
	 * @type {object}
	 * @property {string} url - The URL of the image's location.
	 * @property {boolean} is_sticker - Whether the sent image is a sticker.
	 * @property {boolean} animated   - Whether the sent image is animated. Only used for stickers (for now...?).
	 */

	/**
	 * Return whether a URL points to a loaded image or not.
	 *
	 * @param {string} src
	 * @return boolean
	 * @private
	 */
	_isLoadedImageURL(src) {
		return src && (
			src.startsWith(`blob:`) ||
			src.startsWith(`${document.location.origin}/res/`) && !src.startsWith(`${document.location.origin}/res/img/noimg/`))
	}

	/**
	 * Parse a message element.
	 *
	 * @param {Element} element - The message element.
	 * @param {Number} chatType - What kind of chat this message is part of.
	 * @param {Date} refDate    - The most recent date indicator. If undefined, do not retrieve the timestamp of this message.
	 * @return {Promise<MessageData>}
	 * @private
	 */
	async _parseMessage(element, chatType, refDate) {
		const is_outgoing = element.classList.contains("mdRGT07Own")
		let sender = {}

		const receipt = element.querySelector(".mdRGT07Own .mdRGT07Read:not(.MdNonDisp)")
		let receipt_count

		// TODO Clean up participantsList access...
		const participantsListSelector = "#_chat_detail_area > .mdRGT02Info ul.mdRGT13Ul"

		// Don't need sender ID for direct chats, since the portal will have it already.
		if (chatType == ChatTypeEnum.DIRECT) {
			sender = null
			receipt_count = is_outgoing ? (receipt ? 1 : 0) : null
		} else if (!is_outgoing) {
			let imgElement
			sender.name = element.querySelector(".mdRGT07Body > .mdRGT07Ttl").innerText
			// Room members are always friends (right?),
			// so search the friend list for the sender's name
			// and get their ID from there.
			sender.id = this.getUserIdFromFriendsList(sender.name)
			// Group members aren't necessarily friends,
			// but the participant list includes their ID.
			// ROOMS DO NOT!! Ugh.
			if (!sender.id) {
				const participantsList = document.querySelector(participantsListSelector)
				// Groups use a participant's name as the alt text of their avatar image,
				// but rooms do not...ARGH! But they both use a dedicated element for it.
				const participantNameElement =
					Array.from(participantsList.querySelectorAll(`.mdRGT13Ttl`))
					.find(e => e.innerText == sender.name)
				if (participantNameElement) {
					imgElement = participantNameElement.previousElementSibling.firstElementChild
					sender.id = imgElement.parentElement.parentElement.getAttribute("data-mid")
				}
			} else {
				imgElement = element.querySelector(".mdRGT07Img > img")
			}
			sender.avatar = this._getPathImage(imgElement)
			receipt_count = null
		} else {
			// TODO Get own ID and store it somewhere appropriate.
			//      Unable to get own ID from a room chat...
			// if (chatType == ChatTypeEnum.GROUP) {
			// 	const participantsList = document.querySelector("#_chat_detail_area > .mdRGT02Info ul.mdRGT13Ul")
			// 	// TODO The first member is always yourself, right?
			// 	// TODO Cache this so own ID can be used later
			// 	sender = participantsList.children[0].getAttribute("data-mid")
			// }
			const participantsList = document.querySelector(participantsListSelector)
			sender.name = this.getParticipantListItemName(participantsList.children[0])
			sender.avatar = this.getParticipantListItemAvatar(participantsList.children[0])
			sender.id = this.ownID

			receipt_count = receipt ? this._getReceiptCount(receipt) : null
		}

		const messageData = {
			id: +element.getAttribute("data-local-id"),
			timestamp:
				refDate !== undefined
				? (await this._tryParseDate(element.querySelector("time")?.innerText, refDate))?.getTime()
				: null,
			is_outgoing: is_outgoing,
			sender: sender,
			receipt_count: receipt_count,
		}

		const messageElement = element.querySelector(".mdRGT07Body > .mdRGT07Msg")
		const is_sticker = messageElement.classList.contains("mdRGT07Sticker")
		if (messageElement.classList.contains("mdRGT07Text")) {
			let msgSpan = messageElement.querySelector(".mdRGT07MsgTextInner")
			try {
				if (msgSpan.innerHTML == MSG_DECRYPTING) {
					msgSpan = await this._waitForDecryptedMessage(element, msgSpan, 5000)
				}
				messageData.html = await this._parseMessageHTML(msgSpan)
			} catch {
				// Throw to reject, but return what was parsed so far
				throw messageData
			}
		} else if (is_sticker || messageElement.classList.contains("mdRGT07Image")) {
			// TODO Animated non-sticker images require clicking its img element, which is just a thumbnail
			// Real image: "#wrap_single_image img"
			// Close button: "#wrap_single_image button"
			// Viewer is open/closed based on "#wrap_single_image.MdNonDisp" / "#wrap_single_image:not(.MdNonDisp)"
			let img = messageElement.querySelector(".mdRGT07MsgImg > img")
			if (!this._isLoadedImageURL(img.src)) {
				try {
					img = await this._waitForLoadedImage(img, 10000)
				} catch {
					// Throw to reject, but return what was parsed so far
					throw messageData
				}
			}
			messageData.image = {
				url: img.src,
				is_sticker: is_sticker,
				is_animated: is_sticker && img.parentElement.classList.contains("animationSticker"),
			}
		}
		return messageData
	}

	/**
	 * @param {Element} msgSpan
	 * @return Promise<DOMString>
	 * @private
	 */
	async _parseMessageHTML(msgSpan) {
		const msgSpanImgs = msgSpan.getElementsByTagName("img")
		if (msgSpanImgs.length == 0) {
			return msgSpan.innerHTML
		} else {
			const unloadedImgs = Array.from(msgSpanImgs).filter(img => !this._isLoadedImageURL(img.src))
			if (unloadedImgs.length > 0) {
				// NOTE Use allSettled to not throw if any images time out
				await Promise.allSettled(
					unloadedImgs.map(img => this._waitForLoadedImage(img, 2000))
				)
			}

			// Hack to put sticon dimensions in HTML (which are excluded by default)
			// in such a way that doesn't alter the elements that are in the DOM
			const msgSpanCopy = msgSpan.cloneNode(true)
			const msgSpanCopyImgs = msgSpanCopy.getElementsByTagName("img")
			for (let i = 0, n = msgSpanImgs.length; i < n; i++) {
				msgSpanCopyImgs[i].height = msgSpanImgs[i].height
				msgSpanCopyImgs[i].width  = msgSpanImgs[i].width
			}
			return msgSpanCopy.innerHTML
		}
	}

	/**
	 * @param {Element} element
	 * @param {Element} msgSpan
	 * @param {Number} timeoutLimitMillis
	 * @return {Promise<Element>}
	 * @private
	 */
	_waitForDecryptedMessage(element, msgSpan, timeoutLimitMillis) {
		console.debug("Wait for message element to finish decrypting")
		console.debug(element)
		return new Promise((resolve, reject) => {
			let observer = new MutationObserver(changes => {
				for (const change of changes) {
					const isTextUpdate = change.type == "characterData"
					const target = isTextUpdate ? msgSpan : element.querySelector(".mdRGT07MsgTextInner")
					if (target && target.innerHTML != MSG_DECRYPTING) {
						if (isTextUpdate) {
							console.debug("UNLIKELY(?) EVENT -- Found decrypted message from text update")
						} else {
							// TODO Looks like it's div.mdRGT07Body that gets always replaced. If so, watch only for that
							console.debug("Found decrypted message from element replacement")
							console.debug(target)
							console.debug("Added:")
							for (const change of changes) {
								console.debug(change.removedNodes)
							}
							console.debug("Removed:")
							for (const change of changes) {
								console.debug(change.addedNodes)
							}
						}
						observer.disconnect()
						observer = null
						resolve(target)
						return
					}
					if (target && target != msgSpan) {
						console.debug("UNLIKELY EVENT -- Somehow added a new \"decrypting\" span, it's the one to watch now")
						console.debug(target)
						msgSpan = target
						observer.observe(msgSpan, { characterData: true })
					}
				}
			})
			// Either the span element or one of its ancestors is replaced,
			// or the span element's content is updated.
			// Not exactly sure which of these happens, or if the same kind
			// of mutation always happens, so just look for them all...
			observer.observe(element, { childList: true, subtree: true })
			observer.observe(msgSpan, { characterData: true })
			setTimeout(() => {
				if (observer) {
					observer.disconnect()
					// Don't print log message, as this may be a safe timeout
					reject()
				}
			}, timeoutLimitMillis)
		})
	}

	/**
	 * @param {Element} img
	 * @param {Number} timeoutLimitMillis
	 * @return {Promise<Element>}
	 * @private
	 */
	_waitForLoadedImage(img, timeoutLimitMillis) {
		console.debug("Wait for image element to finish loading")
		console.debug(img)
		// TODO Should reject on "#_chat_message_image_failure"
		return new Promise((resolve, reject) => {
			let observer = new MutationObserver(changes => {
				for (const change of changes) {
					if (this._isLoadedImageURL(change.target.src)) {
						console.debug("Image element finished loading")
						console.debug(change.target)
						observer.disconnect()
						observer = null
						resolve(change.target)
						return
					}
				}
			})
			observer.observe(img, { attributes: true, attributeFilter: ["src"] })
			setTimeout(() => {
				if (observer) {
					observer.disconnect()
					// Don't print log message, as this may be a safe timeout
					reject()
				}
			}, timeoutLimitMillis)
		})
	}

	/**
	 * Find the number in the "Read #" receipt message.
	 * Don't look for "Read" specifically, to support multiple languages.
	 *
	 * @param {Element} receipt - The element containing the receipt message.
	 * @private
	 */
	_getReceiptCount(receipt) {
		const match = receipt.innerText.match(/\d+/)
		return Number.parseInt(match ? match[0] : 0) || null
	}


	/**
	 * Create and store a promise that resolves when a message written
	 * by the user finishes getting sent.
	 * Accepts selectors for elements that become visible once the message
	 * has succeeded or failed to be sent.
	 *
	 * @param {int} timeoutLimitMillis - The maximum amount of time to wait for the message to be sent.
	 * @param {string} successSelector - The selector for the element that indicates the message was sent.
	 * @param {?string} failureSelector - The selector for the element that indicates the message failed to be sent.
	 */
	promiseOwnMessage(timeoutLimitMillis, successSelector, failureSelector=null) {
		this.promiseOwnMsgSuccessSelector = successSelector
		this.promiseOwnMsgFailureSelector = failureSelector

		this.ownMsgPromise = new Promise((resolve, reject) => {
			this.promiseOwnMsgResolve = resolve
			this.promiseOwnMsgReject = reject
		})
		this.promiseOwnMsgTimeoutID = setTimeout(() => {
			if (this.promiseOwnMsgReject) {
				console.error("Timed out waiting for own message to be sent")
				this._rejectOwnMessage()
			}
		}, timeoutLimitMillis)
	}

	/**
	 * Wait for a user-sent message to finish getting sent.
	 *
	 * @return {Promise<int>} - The ID of the sent message.
	 */
	async waitForOwnMessage() {
		return this.ownMsgPromise ? await this.ownMsgPromise : -1
	}

	/**
	 * Parse the message list of whatever the currently-viewed chat is.
	 *
	 * @param {int} minID - The minimum message ID to consider.
	 * @return {Promise<[MessageData]>} - A list of messages.
	 */
	async parseMessageList(minID = 0) {
		console.debug(`minID for full refresh: ${minID}`)
		const msgList =
			Array.from(document.querySelectorAll("#_chat_room_msg_list > div[data-local-id]"))
			.filter(msg =>
				msg.hasAttribute("data-local-id") &&
				(!msg.classList.contains("MdRGT07Cont") || msg.getAttribute("data-local-id") > minID))
		if (msgList.length == 0) {
			return []
		}
		const messagePromises = []
		const chatType = this.getChatType(this.getCurrentChatID())
		let refDate = null
		for (const child of msgList) {
			if (child.classList.contains("mdRGT10Date")) {
				refDate = await this._tryParseDateSeparator(child.firstElementChild.innerText)
			} else if (child.classList.contains("MdRGT07Cont")) {
				messagePromises.push(this._parseMessage(child, chatType, refDate))
			}
		}
		// NOTE No message should ever time out, but use allSettled to not throw if any do
		return (await Promise.allSettled(messagePromises))
		.filter(value => value.status == "fulfilled")
		.map(value => value.value)
	}

	/**
	 * @typedef PathImage
	 * @type object
	 * @property {?string} path - The virtual path of the image (behaves like an ID). Optional.
	 * @property {string} src   - The URL of the image. Mandatory.
	 */

	/**
	 * @param {Element} img - The image element to get the URL and path of.
	 * @return {?PathImage} - The image URL and its path, if found.
	 */
	_getPathImage(img) {
		if (img && img.src.startsWith("blob:")) {
			// NOTE Having a blob but no path means the image exists,
			// 		but in a form that cannot be uniquely identified.
			// 		If instead there is no blob, the image is blank.
			return {
				path: img.getAttribute("data-picture-path"),
				url: img.src,
			}
		} else {
			return null
		}
	}

	/**
	 * @typedef Participant
	 * @type object
	 * @property {string} id         - The member ID for the participant
	 * @property {?PathImage} avatar - The path and blob URL of the participant's avatar
	 * @property {string} name       - The contact list name of the participant
	 */

	getParticipantListItemName(element) {
		return element.querySelector(".mdRGT13Ttl").innerText
	}

	getParticipantListItemAvatar(element) {
		return this._getPathImage(element.querySelector(".mdRGT13Img img[src]"))
	}

	getParticipantListItemID(element) {
		// TODO Cache own ID
		return element.getAttribute("data-mid")
	}

	/**
	 * Parse a group participants list.
	 * TODO Find what works for a *room* participants list...!
	 *
	 * @param {Element} element - The participant list element.
	 * @return {[Participant]} - The list of participants.
	 */
	parseParticipantList(element) {
		// TODO Might need to explicitly exclude own user if double-puppeting is enabled.
		// TODO The first member is always yourself, right?
		const ownParticipant = {
			// TODO Find way to make this work with multiple mxids using the bridge.
			//      One idea is to add real ID as suffix if we're in a group, and
			//      put in the puppet DB table somehow.
			id: this.ownID,
			avatar: this.getParticipantListItemAvatar(element.children[0]),
			name: this.getParticipantListItemName(element.children[0]),
		}

		return [ownParticipant].concat(Array.from(element.children).slice(1).map(child => {
			const name = this.getParticipantListItemName(child)
			const id = this.getParticipantListItemID(child) || this.getUserIdFromFriendsList(name)
			return {
				id: id,
				avatar: this.getParticipantListItemAvatar(child),
				name: name,
			}
		}))
	}

	/**
	 * @typedef ChatListInfo
	 * @type object
	 * @property {number} id      - The ID of the chat.
	 * @property {string} name    - The name of the chat.
	 * @property {PathImage} icon - The path and blob URL of the chat icon.
	 * @property {string} lastMsg - The most recent message in the chat.
	 *                              May be prefixed by sender name.
	 * @property {string} lastMsgDate - An imprecise date for the most recent message
	 *                                  (e.g. "7:16 PM", "Thu" or "Aug 4")
	 */

	getChatListItemID(element) {
		return element.getAttribute("data-chatid")
	}

	getChatListItemName(element) {
		return element.querySelector(".mdCMN04Ttl").innerText
	}

	getChatListItemIcon(element) {
		return this._getPathImage(element.querySelector(".mdCMN04Img > :not(.mdCMN04ImgInner) > img[src]"))
	}

	getChatListItemLastMsg(element) {
		return element.querySelector(".mdCMN04Desc").innerText
	}

	getChatListItemLastMsgDate(element) {
		return element.querySelector("time").innerText
	}

	/**
	 * Parse a conversation list item element.
	 *
	 * @param {Element} element - The element to parse.
	 * @param {?string} knownID - The ID of this element, if it is known.
	 * @return {ChatListInfo}   - The info in the element.
	 */
	parseChatListItem(element, knownID) {
		return !element.classList.contains("chatList") ? null : {
			id: knownID || this.getChatListItemID(element),
			name: this.getChatListItemName(element),
			icon: this.getChatListItemIcon(element),
			lastMsg: this.getChatListItemLastMsg(element),
			lastMsgDate: this.getChatListItemLastMsgDate(element),
		}
	}

	/**
	 * Parse the list of recent/saved chats.
	 *
	 * @return {[ChatListInfo]} - The list of chats.
	 */
	parseChatList() {
		const chatList = document.querySelector("#_chat_list_body")
		return Array.from(chatList.children).map(
			child => this.parseChatListItem(child.firstElementChild))
	}

	/**
	 * Download an image at a given URL and return it as a data URL.
	 *
	 * @param {string} url - The URL of the image to download.
	 * @return {Promise<string>} - The data URL (containing the mime type and base64 data)
	 */
	async readImage(url) {
		const resp = await fetch(url)
		const reader = new FileReader()
		const promise = new Promise((resolve, reject) => {
			reader.onload = () => resolve(reader.result)
			reader.onerror = reject
		})
		reader.readAsDataURL(await resp.blob())
		return promise
	}

	/**
	 * @param {[MutationRecord]} mutations - The mutation records that occurred
	 * @private
	 */
	_observeChatListMutations(mutations) {
		// TODO Observe *added/removed* chats, not just new messages
		const changedChatIDs = new Set()
		for (const change of mutations) {
			if (change.target.id == "_chat_list_body") {
				// TODO
				// These could be new chats, or they're
				// existing ones that just moved around.
				/*
				for (const node of change.addedNodes) {
				}
				*/
			} else if (change.target.tagName == "LI") {
				if (change.target.classList.contains("ExSelected")) {
					console.debug("Not using chat list mutation response for currently-active chat")
					continue
				}
				for (const node of change.addedNodes) {
					const chat = this.parseChatListItem(node)
					if (chat) {
						console.log("Added chat list item:", chat)
						changedChatIDs.add(chat.id)
					} else {
						console.debug("Could not parse added node as a chat list item:", node)
					}
				}
			}
			// change.removedNodes tells you which chats that had notifications are now read.
		}
		if (changedChatIDs.size > 0) {
			console.debug("Dispatching chat list mutations:", changedChatIDs)
			window.__mautrixReceiveChanges(Array.from(changedChatIDs)).then(
				() => console.debug("Chat list mutations dispatched"),
				err => console.error("Error dispatching chat list mutations:", err))
		}
	}

	/**
	 * Add a mutation observer to the chat list.
	 */
	addChatListObserver() {
		this.removeChatListObserver()
		this.chatListObserver = new MutationObserver(async (mutations) => {
			if (this.ownMsgPromise) {
				// Wait for pending sent messages to be resolved before responding to mutations
				try {
					await this.ownMsgPromise
				} catch (e) {}
			}

			try {
				this._observeChatListMutations(mutations)
			} catch (err) {
				console.error("Error observing chat list mutations:", err)
			}
		})
		this.chatListObserver.observe(
			document.querySelector("#_chat_list_body"),
			{ childList: true, subtree: true })
		console.log("Started chat list observer")
	}

	/**
	 * Disconnect the most recently added mutation observer.
	 */
	removeChatListObserver() {
		if (this.chatListObserver !== null) {
			this.chatListObserver.disconnect()
			this.chatListObserver = null
			console.log("Disconnected chat list observer")
		}
	}

	/**
	 * @param {[MutationRecord]} mutations - The mutation records that occurred
	 * @param {string} chatID - The ID of the chat being observed.
	 * @private
	 */
	_observeReceiptsDirect(mutations, chatID) {
		let receipt_id
		for (const change of mutations) {
			if ( change.target.classList.contains("mdRGT07Read") &&
				!change.target.classList.contains("MdNonDisp")) {
				const msgElement = change.target.closest(".mdRGT07Own")
				if (msgElement) {
					let id = +msgElement.getAttribute("data-local-id")
					if (!receipt_id || receipt_id < id) {
						receipt_id = id
					}
				}
			}
		}

		if (receipt_id) {
			window.__mautrixReceiveReceiptDirectLatest(chatID, receipt_id).then(
				() => console.debug(`Receipt sent for message ${receipt_id}`),
				err => console.error(`Error sending receipt for message ${receipt_id}:`, err))
		}
	}

	/**
	 * @param {[MutationRecord]} mutations - The mutation records that occurred
	 * @param {string} chatID - The ID of the chat being observed.
	 * @private
	 */
	_observeReceiptsMulti(mutations, chatID) {
		const ids = new Set()
		const receipts = []
		for (const change of mutations) {
			const target = change.type == "characterData" ? change.target.parentElement : change.target
			if ( target.classList.contains("mdRGT07Read") &&
				!target.classList.contains("MdNonDisp"))
			{
				const msgElement = target.closest(".mdRGT07Own")
				if (msgElement) {
					const id = +msgElement.getAttribute("data-local-id")
					if (!ids.has(id)) {
						ids.add(id)
						receipts.push({
							id: id,
							count: this._getReceiptCount(target),
						})
					}
				}
			}
		}

		if (receipts.length > 0) {
			window.__mautrixReceiveReceiptMulti(chatID, receipts).then(
				() => console.debug(`Receipts sent for ${receipts.length} messages`),
				err => console.error(`Error sending receipts for ${receipts.length} messages`, err))
		}
	}

	/**
	 * @typedef PendingMessage
	 * @type object
	 *
	 * @property {Promise<MessageData>} promise
	 * @property {Number} id
	 */

	/**
	 * @typedef SameIDMsgs
	 * @type object
	 *
	 * @property {Number} id
	 * @property {PendingMessage[]} msgs
	 * @property {Function} resolve
	 * @property {Number} numRejected
	 */

	/**
	 * Binary search for the array of messages with the provided ID.
	 *
	 * @param {SameIDMsgs[]} sortedSameIDMsgs
	 * @param {Number} id
	 * @param {boolean} returnClosest - If true, return the index of the nearest result on miss instead of -1.
	 * @return {Number} The index of the matched element, or -1 if not found.
	 */
	_findMsgsForID(
		sortedSameIDMsgs, id, returnClosest = false,
		lowerBound = 0, upperBound = sortedSameIDMsgs.length - 1)
	{
		if (lowerBound > upperBound) {
			return -1
		}
		if (returnClosest && lowerBound == upperBound) {
			// Caller must check if the result has a matching ID or not
			return sortedSameIDMsgs[lowerBound].id <= id ? lowerBound : lowerBound-1
		}
		const i = lowerBound + Math.floor((upperBound - lowerBound)/2)
		const val = sortedSameIDMsgs[i]
		if (val.id == id) {
			return i
		} else if (val.id < id) {
			return this._findMsgsForID(
				sortedSameIDMsgs, id, returnClosest,
				i+1, upperBound)
		} else {
			return this._findMsgsForID(
				sortedSameIDMsgs, id, returnClosest,
				lowerBound, i-1)
		}
	}
	
	/**
	 * Insert the given message to the proper inner array.
	 * In no inner array exists, insert a new one, preserving sort order.
	 * Return the wrapper of which inner array was added to or created.
	 *
	 * @param {SameIDMsgs[]} sortedSameIDMsgs
	 * @param {PendingMessage} msg
	 * @return {SameIDMsgs}
	 */
	_insertMsgByID(sortedSameIDMsgs, msg) {
		let i = this._findMsgsForID(sortedSameIDMsgs, msg.id, true)
		if (i != -1 && sortedSameIDMsgs[i].id == msg.id) {
			sortedSameIDMsgs[i].msgs.push(msg)
			console.debug("UNLIKELY(?) EVENT -- Found two new message elements with the same ID, so tracking both of them")
		} else {
			sortedSameIDMsgs.splice(++i, 0, {
				id: msg.id,
				msgs: [msg],
				numRejected: 0,
				resolve: null,
			})
		}
		return sortedSameIDMsgs[i]
	}

	/**
	 * Add a mutation observer to the message list of the current chat.
	 * Used for observing new messages & read receipts.
	 *
	 * @param {int} minID - The minimum message ID to consider.
	 */
	addMsgListObserver(minID = 0) {
		const chat_room_msg_list = document.querySelector("#_chat_room_msg_list")
		if (!chat_room_msg_list) {
			console.debug("Could not start msg list observer: no msg list available!")
			return
		}
		this.removeMsgListObserver()

		const chatID = this.getCurrentChatID()
		const chatType = this.getChatType(chatID)

		// NEED TO HANDLE:
		// * message elements arriving in any order
		// * messages being potentially pending (i.e. decrypting or loading),
		//   and resolving in a potentially different order than they arrived in
		// * pending messages potentially having multiple elements associated with
		//   them, where only one of them resolves
		// * message elements being added/removed any number of times, which may
		//   or may not ever resolve
		// * outgoing messages (i.e. sent by the bridge)
		// And must send resolved messages to the bridge *in order*!
		// BUT: Assuming that incoming messages will never be younger than a resolved one.

		const sortedSameIDMsgs = []
		const pendingMsgElements = new Set()

		this.msgListObserver = new MutationObserver(changes => {
			console.debug(`MESSAGE LIST CHANGES: check since ${minID}`)
			const remoteMsgs = []
			for (const change of changes) {
				console.debug("---new change set---")
				for (const child of change.addedNodes) {
					if (!pendingMsgElements.has(child) &&
						child.tagName == "DIV" &&
						child.hasAttribute("data-local-id") &&
						// Skip timestamps, as these are always current
						child.classList.contains("MdRGT07Cont"))
					{
						const msgID = child.getAttribute("data-local-id")
						if (msgID > minID) {
							pendingMsgElements.add(child)

							// TODO Maybe handle own messages somewhere else...?
							const ownMsg = this._observeOwnMessage(child)
							if (ownMsg) {
								console.log("Found own bridge-sent message, will wait for it to resolve")
								console.debug(child)
								this.ownMsgPromise
								.then(msgID => {
									console.log("Resolved own bridge-sent message")
									console.debug(ownMsg)
									pendingMsgElements.delete(ownMsg)
									if (minID < msgID) {
										minID = msgID
									}
								})
								.catch(() => {
									console.log("Rejected own bridge-sent message")
									console.debug(ownMsg)
									pendingMsgElements.delete(ownMsg)
								})
							} else {
								console.log("Found remote message")
								console.debug(child)
								remoteMsgs.push({
									id: msgID,
									element: child
								})
							}
						}
					}
				}
				// NOTE Ignoring removedNodes because an element can always be added back.
				//      Will simply let permanently-removed nodes time out.
			}
			if (remoteMsgs.length == 0) {
				console.debug("Found no new remote messages")
				return
			}

			// No need to sort remoteMsgs, because sortedSameIDMsgs is enough
			for (const msg of remoteMsgs) {
				const messageElement = msg.element
				const pendingMessage = {
					id: msg.id,
					promise: this._parseMessage(messageElement, chatType)
				}
				const sameIDMsgs = this._insertMsgByID(sortedSameIDMsgs, pendingMessage)

				const handleMessage = async (messageData) => {
					minID = messageData.id
					sortedSameIDMsgs.shift()
					await window.__mautrixReceiveMessages(chatID, [messageData])
					if (sortedSameIDMsgs.length > 0 && sortedSameIDMsgs[0].resolve) {
						console.debug("Allowing queued resolved message to be sent")
						console.debug(sortedSameIDMsgs[0])
						sortedSameIDMsgs[0].resolve()
					}
				}

				pendingMessage.promise.then(
				async (messageData) => {
					const i = this._findMsgsForID(sortedSameIDMsgs, messageData.id)
					if (i == -1) {
						console.debug(`Got resolved message for already-handled ID ${messageData.id}, ignore it`)
						pendingMsgElements.delete(messageElement)
						return
					}
					if (i != 0) {
						console.debug(`Got resolved message for later ID ${messageData.id}, wait for earlier messages`)
						await new Promise(resolve => sameIDMsgs.resolve = resolve)
						console.debug(`Message before ID ${messageData.id} finished, can now send this one`)
					} else {
						console.debug(`Got resolved message for earliest ID ${messageData.id}, send it`)
					}
					console.debug(messageElement)
					pendingMsgElements.delete(messageElement)
					handleMessage(messageData)
				},
				// error case
				async (messageData) => {
					console.debug("Message element rejected")
					console.debug(messageElement)
					pendingMsgElements.delete(messageElement)
					if (++sameIDMsgs.numRejected == sameIDMsgs.msgs.length) {
						// Note that if another message element with this ID somehow comes later, it'll be ignored.
						console.debug(`All messages for ID ${sameIDMsgs.id} rejected, abandoning this ID and sending dummy message`)
						// Choice of which message to send should be arbitrary
						handleMessage(messageData)
					}
				})
			}
		})
		this.msgListObserver.observe(
			chat_room_msg_list,
			{ childList: true })

		console.debug(`Started msg list observer with minID = ${minID}`)


		const observeReadReceipts = (
			chatType == ChatTypeEnum.DIRECT ?
			this._observeReceiptsDirect :
			this._observeReceiptsMulti
			).bind(this)

		this.receiptObserver = new MutationObserver(changes => {
			try {
				observeReadReceipts(changes, chatID)
			} catch (err) {
				console.error("Error observing msg list mutations:", err)
			}
		})
		this.receiptObserver.observe(
			chat_room_msg_list, {
				subtree: true,
				attributes: true,
				attributeFilter: ["class"],
				characterData: chatType != ChatTypeEnum.DIRECT,
			})

		console.debug("Started receipt observer")
	}

	_observeOwnMessage(ownMsg) {
		if (!this.ownMsgPromise) {
			// Not waiting for a pending sent message
			return null
		}

		const successElement =
			ownMsg.querySelector(this.promiseOwnMsgSuccessSelector)
		if (successElement) {
			if (successElement.classList.contains("MdNonDisp")) {
				console.log("Invisible success for own bridge-sent message, will wait for it to resolve")
				console.log(successElement)
			} else {
				console.debug("Already visible success, must not be it")
				console.debug(successElement)
				return null
			}
		} else {
			return null
		}

		const failureElement =
			this.promiseOwnMsgFailureSelector &&
			ownMsg.querySelector(this.promiseOwnMsgFailureSelector)
		if (failureElement) {
			if (failureElement.classList.contains("MdNonDisp")) {
				console.log("Invisible failure for own bridge-sent message, will wait for it (or success) to resolve")
				console.log(failureElement)
			} else {
				console.debug("Already visible failure, must not be it")
				console.log(failureElement)
				return null
			}
		} else if (this.promiseOwnMsgFailureSelector) {
			return null
		}

		const msgID = +ownMsg.getAttribute("data-local-id")
		this.visibleSuccessObserver = new MutationObserver(
			this._getOwnVisibleCallback(msgID))
		this.visibleSuccessObserver.observe(
			successElement,
			{ attributes: true, attributeFilter: ["class"] })

		if (this.promiseOwnMsgFailureSelector) {
			this.visibleFailureObserver = new MutationObserver(
				this._getOwnVisibleCallback())
			this.visibleFailureObserver.observe(
				failureElement,
				{ attributes: true, attributeFilter: ["class"] })
		}

		return ownMsg
	}

	_getOwnVisibleCallback(msgID=null) {
		const isSuccess = !!msgID
		return changes => {
			for (const change of changes) {
				if (!change.target.classList.contains("MdNonDisp")) {
					console.log(`Resolved ${isSuccess ? "success" : "failure"} for own bridge-sent message`)
					console.log(change.target)
					isSuccess ? this._resolveOwnMessage(msgID) : this._rejectOwnMessage(change.target)
					return
				}
			}
		}
	}

	_resolveOwnMessage(msgID) {
		if (!this.promiseOwnMsgResolve) return
		clearTimeout(this.promiseOwnMsgTimeoutID)
		const resolve = this.promiseOwnMsgResolve
		this._promiseOwnMsgReset()

		window.__mautrixReceiveMessageID(msgID).then(
			() => resolve(msgID))
	}

	_rejectOwnMessage(failureElement = null) {
		if (!this.promiseOwnMsgReject) return
		const reject = this.promiseOwnMsgReject
		this._promiseOwnMsgReset()

		reject(failureElement)
	}

	_promiseOwnMsgReset() {
		this.ownMsgPromise = null
		this.promiseOwnMsgSuccessSelector = null
		this.promiseOwnMsgFailureSelector = null
		this.promiseOwnMsgResolve = null
		this.promiseOwnMsgReject = null
		this.promiseOwnMsgTimeoutID = null

		if (this.visibleSuccessObserver) {
			this.visibleSuccessObserver.disconnect()
		}
		this.visibleSuccessObserver = null
		if (this.visibleFailureObserver) {
			this.visibleFailureObserver.disconnect()
		}
		this.visibleFailureObserver = null
	}

	removeMsgListObserver() {
		let result = false
		if (this.msgListObserver !== null) {
			this.msgListObserver.disconnect()
			this.msgListObserver = null
			console.debug("Disconnected msg list observer")
			result = true
		}
		if (this.receiptObserver !== null) {
			this.receiptObserver.disconnect()
			this.receiptObserver = null
			console.debug("Disconnected receipt observer")
			result = true
		}
		return result
	}

	addQRChangeObserver(element) {
		this.removeQRChangeObserver()
		this.qrChangeObserver = new MutationObserver(changes => {
			for (const change of changes) {
				if (change.attributeName === "title" && change.target instanceof Element) {
					window.__mautrixReceiveQR(change.target.getAttribute("title"))
				}
			}
		})
		this.qrChangeObserver.observe(element, {
			attributes: true,
			attributeFilter: ["title"],
		})
	}

	removeQRChangeObserver() {
		if (this.qrChangeObserver !== null) {
			this.qrChangeObserver.disconnect()
			this.qrChangeObserver = null
		}
	}

	addQRAppearObserver(element) {
		this.removeQRAppearObserver()
		this.qrAppearObserver = new MutationObserver(changes => {
			for (const change of changes) {
				for (const node of change.addedNodes) {
					const qrElement = node.querySelector("#login_qrcode_area div[title]")
					if (qrElement) {
						window.__mautrixReceiveQR(qrElement.title)
						window.__mautrixController.addQRChangeObserver(element)
						return
					}
				}
			}
		})
		this.qrAppearObserver.observe(element, {
			childList: true,
		})
	}

	removeQRAppearObserver() {
		if (this.qrAppearObserver !== null) {
			this.qrAppearObserver.disconnect()
			this.qrAppearObserver = null
		}
	}

	addEmailAppearObserver(element) {
		this.removeEmailAppearObserver()
		this.emailAppearObserver = new MutationObserver(changes => {
			for (const change of changes) {
				for (const node of change.addedNodes) {
					const emailArea = node.querySelector("#login_email_area")
					if (emailArea && !emailArea.classList.contains("MdNonDisp")) {
						window.__mautrixSendEmailCredentials()
						return
					}
				}
			}
		})
		this.emailAppearObserver.observe(element, {
			childList: true,
		})
	}

	removeEmailAppearObserver() {
		if (this.emailAppearObserver !== null) {
			this.emailAppearObserver.disconnect()
			this.emailAppearObserver = null
		}
	}

	addPINAppearObserver(element) {
		this.removePINAppearObserver()
		this.pinAppearObserver = new MutationObserver(changes => {
			for (const change of changes) {
				for (const node of change.addedNodes) {
					const pinElement = node.querySelector("div.mdCMN01Code")
					if (pinElement) {
						window.__mautrixReceivePIN(pinElement.innerText)
						return
					}
				}
			}
		})
		this.pinAppearObserver.observe(element, {
			childList: true,
		})
	}

	removePINAppearObserver() {
		if (this.pinAppearObserver !== null) {
			this.pinAppearObserver.disconnect()
			this.pinAppearObserver = null
		}
	}

}

window.__mautrixController = new MautrixController()

/**
 * Watch for an error dialog / PIN expiry dialog to appear, and click its "OK" button.
 * Must watch for both its parent appearing & it being added to its parent in the first place.
 */
const layer = document.querySelector("#layer_contents")
new MutationObserver(() => {
	if (!layer.classList.contains("MdNonDisp")) {
		const button = layer.querySelector("dialog button")
		if (button) {
			console.log("Something expired, clicking OK button to continue")
			button.click()
		}
	}
}).observe(layer, {
	attributes: true,
	attributeFilter: ["class"],
	childList: true,
})

/**
 * Watch for being logged out.
 */
const mainApp = document.querySelector("#mainApp")
new MutationObserver(() => {
	if (mainApp.classList.contains("MdNonDisp")) {
		window.__mautrixLoggedOut()
	}
}).observe(mainApp, {
	attributes: true,
	attributeFilter: ["class"],
})