// mautrix-telegram - A Matrix-Telegram puppeting bridge
// Copyright (C) 2017 Tulir Asokan
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
const { Bridge } = require("matrix-appservice-bridge")
const escapeHTML = require("escape-html")
const sanitizeHTML = require("sanitize-html")
const marked = require("marked")
const commands = require("./commands")
const MatrixUser = require("./matrix-user")
const TelegramUser = require("./telegram-user")
const TelegramPeer = require("./telegram-peer")
const Portal = require("./portal")

/**
 * The base class for the bridge.
 */
class MautrixTelegram {
	/**
	 * Create a MautrixTelegram instance with the given config data.
	 *
	 * @param config The data from the config file.
	 */
	constructor(config) {
		/**
		 * The app config.
		 * @type {Object}
		 */
		this.config = config
		/**
		 * A special-cased {@link TelegramUser} that is used to send broadcasts to a channel.
		 * @type {TelegramUser}
		 */
		this.channelTelegramSender = new TelegramUser(this, -1)

		/**
		 * MXID -> {@link MatrixUser} cache.
		 * @private
		 * @type {Map<string, MatrixUser>}
		 */
		this.matrixUsersByID = new Map()
		/**
		 * Telegram ID -> {@link MatrixUser} cache.
		 * @priavte
		 * @type {Map<number, MatrixUser>}
		 */
		this.matrixUsersByTelegramID = new Map()
		/**
		 * Telegram ID -> {@link TelegramUser} cache.
		 * @private
		 * @type {Map<number, TelegramUser>}
		 */
		this.telegramUsersByID = new Map()
		/**
		 * Telegram peer ID -> {@link Portal} cache.
		 * @private
		 * @type {Map<number, Portal>}
		 */
		this.portalsByPeerID = new Map()
		/**
		 * Matrix room ID -> {@link Portal} cache.
		 * @private
		 * @type {Map<string, Portal>}
		 */
		this.portalsByRoomID = new Map()
		/**
		 * List of management rooms.
		 * @type {string[]}
		 */
		this.managementRooms = []

		/**
		 * A regular expression that matches MXIDs of Telegram user bridged by this bridge.
		 * @type {RegExp}
		 */
		this.usernameRegex = new RegExp(
				`^@${
					this.config.bridge.username_template.replace("${ID}", "([0-9]+)")
				}:${
					this.config.homeserver.domain
				}$`)

		const self = this
		/**
		 * The matrix-appservice-bridge Bridge instance.
		 * @private
		 * @type {Bridge}
		 */
		this.bridge = new Bridge({
			homeserverUrl: config.homeserver.address,
			domain: config.homeserver.domain,
			registration: config.appservice.registration,
			controller: {
				onUserQuery(/*user*/) {
					return {}
				},
				async onEvent(request/*, context*/) {
					try {
						await self.handleMatrixEvent(request.getData())
					} catch (err) {
						console.error("Matrix event handling failed:", err)
						console.error(err.stack)
					}
				},
			},
		})
	}

	/**
	 * Start the bridge.
	 */
	async run() {
		console.log("Appservice listening on port %s", this.config.appservice.port)
		await this.bridge.run(this.config.appservice.port, {})

		// Load all Matrix users to cache
		const userEntries = await this.bridge.getUserStore()
			.select({ type: "matrix" })

		for (const entry of userEntries) {
			const user = MatrixUser.fromEntry(this, entry)
			this.matrixUsersByID.set(entry.id, user)
			if (user.telegramUserID) {
				this.matrixUsersByTelegramID.set(user.telegramUserID, user)
			}
		}
	}

	/**
	 * The {@link MatrixClient} object for the appservice bot.
	 */
	get bot() {
		return this.bridge.getBot()
	}

	/**
	 * The {@link Intent} object for the appservice bot.
	 */
	get botIntent() {
		return this.bridge.getIntent()
	}

	/**
	 * Get the {@link Intent} for the Telegram user with the given ID.
	 *
	 * This does not care if a {@link TelegramUser} object for the user ID exists.
	 * It simply returns an intent for a Matrix puppet user with the correct MXID.
	 *
	 * @param   {number} id The ID of the Telegram user.
	 * @returns {Intent}    The Matrix puppet intent for the given Telegram user.
	 */
	getIntentForTelegramUser(id) {
		if (id === -1) {
			return this.botIntent
		}
		return this.bridge.getIntentFromLocalpart(this.getUsernameForTelegramUser(id))
	}

	/**
	 * Get the Matrix username localpart for the Telegram user with the given ID.
	 *
	 * @param   {number} id The ID of the Telegram user.
	 * @returns {string}    The Matrix username localpart for the given Telegram user.
	 */
	getUsernameForTelegramUser(id) {
		return this.config.bridge.username_template.replace("${ID}", id)
	}

	/**
	 * Get the full Matrix ID ({@code @localpart:homeserver.tld}) for the Telegram user with the given ID.
	 *
	 * @param   {number} id The ID of the Telegram user.
	 * @returns {string}    The full Matrix ID for the given Telegram user.
	 */
	getMXIDForTelegramUser(id) {
		return `@${this.getUsernameForTelegramUser(id)}:${this.config.homeserver.domain}`
	}

	/**
	 * Get the matrix.to link for the Matrix puppet of the Telegram user with the given ID.
	 *
	 * @param   {number} id The ID of the Telegram user.
	 * @returns {string}    A matrix.to link that points to the Matrix puppet of the given user.
	 */
	getMatrixToLinkForTelegramUser(id) {
		return `https://matrix.to/#/${this.getMXIDForTelegramUser(id)}`
	}

	/**
	 * Get a {@link Portal} by Telegram peer or peer ID.
	 *
	 * This will either get the room from the room cache or the bridge room database.
	 * If the room is not found, a new {@link Portal} object is created.
	 *
	 * You may set the {@code opts.createIfNotFound} parameter to change whether or not to create the Portal
	 * automatically. However, if the peer is just the ID, a new room will not be created in any case.
	 *
	 * @param   {TelegramPeer|number} peer      The TelegramPeer object OR the ID of the peer whose portal to get.
	 *                                          If only a peer ID is given, it is assumed that the peer is a chat or a
	 *                                          channel. Searching for user peers requires the receiver ID, thus here it
	 *                                          requires the full TelegramPeer object.
	 * @param   {object}              [opts]    Additional options.
	 * @param   {boolean} opts.createIfNotFound Whether or not to create the room if it is not found
	 * @returns {Portal}                        The Portal object.
	 */
	async getPortalByPeer(peer, { createIfNotFound = true } = {}) {
		if (typeof peer === "number") {
			peer = {
				id: peer,
			}
			createIfNotFound = false
		} else if (!(peer instanceof TelegramPeer)) {
			throw new Error("Invalid argument: peer is not a number or a TelegramPeer.")
		}
		let portal = this.portalsByPeerID.get(peer.id)
		if (portal) {
			return portal
		}

		const query = {
			type: "portal",
			id: peer.id,
		}
		if (peer.type === "user") {
			query.receiverID = peer.receiverID
		}
		const entries = await this.bridge.getRoomStore().select(query)

		// Handle possible db query race conditions
		portal = this.portalsByPeerID.get(peer.id)
		if (portal) {
			return portal
		}

		if (entries.length) {
			portal = Portal.fromEntry(this, entries[0])
		} else if (createIfNotFound) {
			portal = new Portal(this, undefined, peer)
		} else {
			return undefined
		}
		this.portalsByPeerID.set(peer.id, portal)
		if (portal.roomID) {
			this.portalsByRoomID.set(portal.roomID, portal)
		}
		return portal
	}

	/**
	 * Get a {@link Portal} by Matrix room ID.
	 *
	 * This will either get the room from the room cache or the bridge room database.
	 * If the room is not found, this function WILL NOT create a new room,
	 * but rather just return {@code undefined}.
	 *
	 * @param   {string} id The Matrix room ID of the portal to get.
	 * @returns {Portal}    The Portal object.
	 */
	async getPortalByRoomID(id) {
		let portal = this.portalsByRoomID.get(id)
		if (portal) {
			return portal
		}

		// Check if we have it stored in the by-peer map
		// FIXME this is probably useless
		for (const [_, portalByPeer] of this.portalsByPeerID) {
			if (portalByPeer.roomID === id) {
				this.portalsByRoomID.set(id, portalByPeer)
				return portalByPeer
			}
		}

		const entries = await this.bridge.getRoomStore().select({
			type: "portal",
			roomID: id,
		})

		// Handle possible db query race conditions
		portal = this.portalsByRoomID.get(id)
		if (portal) {
			return portal
		}

		if (entries.length) {
			portal = Portal.fromEntry(this, entries[0])
		} else {
			// Don't create portals based on room ID
			return undefined
		}
		this.portalsByPeerID.set(portal.id, portal)
		this.portalsByRoomID.set(id, portal)
		return portal
	}

	/**
	 * Get a {@link TelegramUser} by ID.
	 *
	 * This will either get the user from the user cache or the bridge user database.
	 * If the user is not found, a new {@link TelegramUser} instance is created.
	 *
	 * @param   {number} id    The internal Telegram ID of the user to get.
	 * @returns {TelegramUser} The TelegramUser object.
	 */
	async getTelegramUser(id, { createIfNotFound = true } = {}) {
		if (id === -1) {
			return this.channelTelegramSender
		}
		// TODO remove this after bugs are fixed
		if (isNaN(parseInt(id, 10))) {
			const err = new Error("Fatal: non-int Telegram user ID")
			console.error(err.stack)
			throw err
		}
		let user = this.telegramUsersByID.get(id)
		if (user) {
			return user
		}

		const entries = await this.bridge.getUserStore().select({
			type: "remote",
			id,
		})

		// Handle possible db query race conditions
		if (this.telegramUsersByID.has(id)) {
			return this.telegramUsersByID.get(id)
		}

		if (entries.length) {
			user = TelegramUser.fromEntry(this, entries[0])
		} else if (createIfNotFound) {
			user = new TelegramUser(this, id)
		} else {
			return undefined
		}
		this.telegramUsersByID.set(id, user)
		return user
	}

	/**
	 * Get a {@link MatrixUser} by Telegram user ID.
	 *
	 * This will either get the user from the user cache or the bridge user database.
	 *
	 * @param   {number} id  The Telegram user ID of the Matrix user to get.
	 * @returns {MatrixUser} The MatrixUser object.
	 */
	async getMatrixUserByTelegramID(id) {
		console.log("Searching for Matrix user by Telegram ID", id)
		let user = this.matrixUsersByTelegramID.get(id)
		if (user) {
			console.log("Found in cache", user.userID)
			return user
		}

		// Check if we have the user stored in the by- map
		// FIXME this should be made useless by making sure we always add to the second map when appropriate
		for (const [_, userByMXID] of this.matrixUsersByID) {
			if (userByMXID.telegramUserID === id) {
				console.log("Found in MXID cache", userByMXID.userID)
				this.matrixUsersByTelegramID.set(id, userByMXID)
				return userByMXID
			}
		}

		const entries = this.bridge.getUserStore().select({
			type: "matrix",
			telegramID: id,
		})

		// Handle possible db query race conditions
		if (this.matrixUsersByTelegramID.has(id)) {
			console.log("Found in cache after race", user.userID)
			return this.matrixUsersByTelegramID.get(id)
		}

		if (entries.length) {
			console.log("Found in db", user.userID)
			user = MatrixUser.fromEntry(this, entries[0])
		} else {
			console.log("Not found :(")
			return undefined
		}
		this.matrixUsersByID.set(user.userID, user)
		this.matrixUsersByTelegramID.set(id, user)
		return user
	}

	/**
	 * Get a {@link MatrixUser} by ID.
	 *
	 * This will either get the user from the user cache or the bridge user database.
	 * If the user is not found, a new {@link MatrixUser} instance is created.
	 *
	 * @param   {string} id  The MXID of the Matrix user to get.
	 * @returns {MatrixUser} The MatrixUser object.
	 */
	async getMatrixUser(id, { createIfNotFound = true } = {}) {
		let user = this.matrixUsersByID.get(id)
		if (user) {
			return user
		}

		const entries = this.bridge.getUserStore().select({
			type: "matrix",
			id,
		})

		// Handle possible db query race conditions
		if (this.matrixUsersByID.has(id)) {
			return this.matrixUsersByID.get(id)
		}

		if (entries.length) {
			user = MatrixUser.fromEntry(this, entries[0])
		} else if (createIfNotFound) {
			user = new MatrixUser(this, id)
		} else {
			return undefined
		}
		this.matrixUsersByID.set(id, user)
		if (user.telegramUserID) {
			this.matrixUsersByID.set(user.telegramUserID, user)
		}
		return user
	}

	/**
	 * Save a user to the bridge user database.
	 *
	 * @param {MatrixUser|TelegramUser} user The user object to save.
	 */
	putUser(user) {
		const entry = user.toEntry()
		return this.bridge.getUserStore()
			.upsert({
				type: entry.type,
				id: entry.id,
			}, entry)
	}

	/**
	 * Save a room to the bridge room database.
	 *
	 * @param {Room} room The Room object to save.
	 */
	putRoom(room) {
		const entry = room.toEntry()
		return this.bridge.getRoomStore()
			.upsert({
				type: entry.type,
				id: entry.id,
			}, entry)
	}

	/**
	 * Get the members in the given room.
	 *
	 * @param   {string} roomID   The ID of the room to search.
	 * @param   {Intent} [intent] The Intent object to use when reading the room state.
	 *                            Uses {@link #botIntent} by default.
	 * @returns {string[]}        The list of MXIDs who are in the room.
	 */
	async getRoomMembers(roomID, intent = this.botIntent) {
		const roomState = await intent.roomState(roomID)
		const members = []
		for (const event of roomState) {
			if (event.type === "m.room.member" && event.membership === "join") {
				members.push(event.user_id)
			}
		}
		return members
	}

	/**
	 * Handle an invite to a Matrix room.
	 *
	 * @param {MatrixUser}  sender The user who sent this invite.
	 * @param {MatrixEvent} evt    The invite event.
	 */
	async handleInvite(sender, evt) {
		const asBotID = this.bridge.getBot().getUserId()
		if (evt.state_key === asBotID) {
			// Accept all AS bot invites.
			try {
				await this.botIntent.join(evt.room_id)
			} catch (err) {
				console.error(`Failed to join room ${evt.room_id}:`, err)
				if (err instanceof Error) {
					console.error(err.stack)
				}
			}
			return
		}
		if (evt.sender === asBotID || evt.sender === evt.state_key) {
			return
		}

		// Check if the invited user is a Telegram user.
		const capture = this.usernameRegex.exec(evt.state_key)
		if (!capture) {
			return
		}

		const telegramID = +capture[1]
		if (!telegramID || isNaN(telegramID)) {
			return
		}

		const intent = this.getIntentForTelegramUser(telegramID)
		try {
			await intent.join(evt.room_id)
			const members = await this.getRoomMembers(evt.room_id, intent)
			if (members.length < 2) {
				console.warn(`No members in room ${evt.room_id}`)
				await intent.leave(evt.room_id)
			} else if (members.length === 2) {
				const user = await this.getTelegramUser(telegramID)
				const peer = user.toPeer(sender.telegramPuppet)
				const portal = await this.getPortalByPeer(peer)
				if (portal.roomID) {
					await intent.sendMessage(evt.room_id, {
						msgtype: "m.notice",
						body: "You already have a private chat room with me!\nI'll re-invite you to that room.",
					})
					try {
						await intent.invite(portal.roomID, sender.userID)
					} catch (_) {}
					await intent.leave(evt.room_id)
				} else {
					portal.roomID = evt.room_id
					await portal.save()
					await intent.sendMessage(portal.roomID, {
						msgtype: "m.notice",
						body: "Portal to Telegram private chat created.",
					})
				}
			} else {
				if (!members.includes(asBotID)) {
					await intent.sendMessage(evt.room_id, {
						msgtype: "m.notice",
						body: "Inviting additional Telegram users to private chats or non-portal rooms is not supported.",
					})
				} else {
					// TODO Allow inviting Telegram users to group/channel portal rooms.
					await intent.sendMessage(evt.room_id, {
						msgtype: "m.notice",
						body: "Inviting Telegram users to portal rooms is not (yet) supported.",
					})
				}
				await intent.leave(evt.room_id)
			}
		} catch (err) {
			console.error(`Failed to process invite to room ${evt.room_id} for Telegram user ${telegramID}: ${err}`)
			if (err instanceof Error) {
				console.error(err.stack)
			}
		}
	}

	/**
	 * Handle a single received Matrix event.
	 *
	 * @param {MatrixEvent} evt The Matrix event that occurred.
	 */
	async handleMatrixEvent(evt) {
		const user = await this.getMatrixUser(evt.sender)
		if (!user.whitelisted) {
			return
		}

		const asBotID = this.bridge.getBot().getUserId()
		if (evt.type === "m.room.member" && evt.content.membership === "invite") {
			await this.handleInvite(user, evt)
			return
		}

		if (evt.sender === asBotID || evt.type !== "m.room.message" || !evt.content) {
			// Ignore own messages and non-message events.
			return
		}

		const portal = await this.getPortalByRoomID(evt.room_id)
		if (portal) {
			portal.handleMatrixEvent(user, evt)
			return
		}

		let isManagement = this.managementRooms.includes(evt.room_id)
		if (!isManagement) {
			const roomMembers = await this.getRoomMembers(evt.room_id)
			if (roomMembers.length === 2 && roomMembers.includes(asBotID)) {
				this.managementRooms.push(evt.room_id)
				isManagement = true
			}
		}
		const cmdprefix = this.config.bridge.commands.prefix
		if (isManagement || (cmdprefix && evt.content.body.startsWith(`${cmdprefix} `))) {
			const prefixLength = cmdprefix.length + 1
			if (cmdprefix && evt.content.body.startsWith(`${cmdprefix} `)) {
				evt.content.body = evt.content.body.substr(prefixLength)
			}
			const args = evt.content.body.split(" ")
			const command = args.shift()
			const replyFunc = (reply, { allowHTML = false, markdown = true } = {}) => {
				reply = reply.replace("$cmdprefix", cmdprefix || "")
				if (!markdown && !allowHTML) {
					reply = escapeHTML(reply)
				}
				if (markdown) {
					reply = marked(reply, {
						sanitize: !allowHTML,
					})
				}
				this.botIntent.sendMessage(
						evt.room_id, {
							body: sanitizeHTML(reply),
							formatted_body: reply,
							msgtype: "m.notice",
							format: "org.matrix.custom.html",
						})
			}
			commands.run(user, command, args, replyFunc, this, evt)
		}
	}

	/**
	 * Check whether the given user ID is allowed to use this bridge.
	 *
	 * @param   {string} userID The full Matrix ID to check (@user:homeserver.tld)
	 * @returns {boolean}       Whether or not the user should be allowed to use the bridge.
	 */
	checkWhitelist(userID) {
		if (!this.config.bridge.whitelist || this.config.bridge.whitelist.length === 0) {
			return true
		}

		userID = userID.toLowerCase()
		const userIDCapture = /@.+:(.+)/.exec(userID)
		const homeserver = userIDCapture && userIDCapture.length > 1 ? userIDCapture[1] : undefined
		for (let whitelisted of this.config.bridge.whitelist) {
			whitelisted = whitelisted.toLowerCase()
			if (whitelisted === userID || (homeserver && whitelisted === homeserver)) {
				return true
			}
		}
		return false
	}
}

module.exports = MautrixTelegram