// @ts-check

const assert = require("assert").strict
const {scheduler} = require("timers/promises")
const passthrough = require("../passthrough")
const {sync} = passthrough

/** @type {import("../matrix/homeserver-status")} */
const homeserverStatus = sync.require("../matrix/homeserver-status")

const guildReadyStatus = new class {
	/** @type {Set<string> | null} */
	unavailableGuilds = null
	_allReady = Promise.withResolvers()

	/**
	 * @param {string} guildID
	 * @returns {boolean} true if it was the last one
	 */
	makeReady(guildID) {
		assert(this.unavailableGuilds)
		if (this.unavailableGuilds.delete(guildID) && this.unavailableGuilds.size === 0) {
			this._allReady.resolve(null)
			return true
		}
		return false
	}

	allReady() {
		return this.unavailableGuilds && this.unavailableGuilds.size === 0
	}

	waitForAllReady() {
		return this._allReady.promise
	}
}

/**
 * @param {import("./discord-client")} client
 * @param {import("cloudstorm").IGatewayMessage} message
 * @param {string} listen "full", "half", "no" - whether to set up the event listeners for OOYE to operate
 */
async function onPacket(client, message, listen) {
	// requiring this later so that the client is already constructed by the time event-dispatcher is loaded
	/** @type {typeof import("./event-dispatcher")} */
	const eventDispatcher = sync.require("./event-dispatcher")
	/** @type {import("../discord/register-interactions")} */
	const interactions = sync.require("../discord/register-interactions")

	// Client internals, keep track of the state we need
	if (message.t === "READY") {
		if (client.ready) return
		client.ready = true
		client.user = message.d.user
		client.application = message.d.application
		guildReadyStatus.unavailableGuilds = new Set(message.d.guilds.filter(g => g.unavailable).map(g => g.id))
		console.log(`Discord logged in as ${client.user.username}#${client.user.discriminator} (${client.user.id})`)
		process.stdout.write("Waiting for guilds to warm up... ")
		interactions.registerInteractions()

	} else if (message.t === "GUILD_CREATE") {
		message.d.members = message.d.members.filter(m => m.user.id === client.user.id) // only keep the bot account's member - it's needed for roles to determine private channels on web
		client.guilds.set(message.d.id, message.d)

		/*
			Info about guilds is populated one guild at a time.
			For m->d bridging to work, the guild needs to be populated, so we need to have GUILD_CREATE for the guild.
			If we ping the homeserver, it will send us any pending events, so we need to wait for all GUILD_CREATES before we ping.
			We must attempt a ping because we don't want to try sending missed d->m messages to an offline homeserver.
			The "all guilds ready" delay can be removed if ONE of the following is done:
				1. m->d can queue incoming events until their guild exists in memory
				2. d->m missed messages can have their errors handled and added to queue, rather than pinging first
		*/
		const firstReady = guildReadyStatus.allReady()
		const lastGuildReady = guildReadyStatus.makeReady(message.d.id)

		const arr = []
		client.guildChannelMap.set(message.d.id, arr)
		for (const channel of message.d.channels || []) {
			// @ts-ignore
			channel.guild_id = message.d.id
			arr.push(channel.id)
			client.channels.set(channel.id, channel)
		}
		for (const thread of message.d.threads || []) {
			// @ts-ignore
			thread.guild_id = message.d.id
			arr.push(thread.id)
			client.channels.set(thread.id, thread)
		}

		if (listen === "full") {
			try {
				// Wait for guilds to be connected and homeserver to be online. If this is the last guild, a different code path is used to trigger the homeserver check.
				if (lastGuildReady) {
					process.stdout.write(`ok, ${client.guilds.size} available.\nConnecting to homeserver... `)
					// await guildReadyStatus.waitForAllReady() - no need, we already checked this is the last guild
					await homeserverStatus.homeserverStatus.waitForOnline(true)
					console.log("ok.\nReplaying past events. Welcome to Out Of Your Element.")
				} else {
					await guildReadyStatus.waitForAllReady()
					await homeserverStatus.homeserverStatus.waitForOnline(false)
				}

				await eventDispatcher.checkMissedExpressions(message.d)
				await eventDispatcher.checkMissedMessages(client, message.d)
				await eventDispatcher.checkMissedPins(client, message.d)
				await eventDispatcher.checkMissedLeaves(client, message.d)
			} catch (e) {
				if (firstReady) {
					console.error("Failed to sync missed events. To retry, please fix this error and restart OOYE:")
				}
				console.error(e)
			}
		}

	} else if (message.t === "GUILD_UPDATE") {
		const guild = client.guilds.get(message.d.id)
		if (guild) {
			for (const prop of Object.keys(message.d)) {
				if (!["channels", "threads"].includes(prop)) {
					guild[prop] = message.d[prop]
				}
			}
		}

	} else if (message.t === "GUILD_EMOJIS_UPDATE") {
		const guild = client.guilds.get(message.d.guild_id)
		if (guild) {
			guild.emojis = message.d.emojis
		}

	} else if (message.t === "GUILD_STICKERS_UPDATE") {
		const guild = client.guilds.get(message.d.guild_id)
		if (guild) {
			guild.stickers = message.d.stickers
		}

	} else if (message.t === "GUILD_ROLE_CREATE" || message.t === "GUILD_ROLE_UPDATE" || message.t === "GUILD_ROLE_DELETE") {
		const guild = client.guilds.get(message.d.guild_id)
		/** Delete this in case of UPDATE or DELETE */
		const targetID = "role_id" in message.d ? message.d.role_id : message.d.role.id
		/** Add this in case of CREATE or UPDATE */
		const newRoles = []
		if ("role" in message.d) newRoles.push(message.d.role)
		if (guild) {
			const targetIndex = guild.roles.findIndex(r => r.id === targetID)
			if (targetIndex !== -1) {
				// Role already exists. Delete it and maybe replace it.
				guild.roles.splice(targetIndex, 1, ...newRoles)
			} else {
				// Role doesn't already exist.
				guild.roles.push(...newRoles)
			}
		}

	} else if (message.t === "GUILD_MEMBER_UPDATE") {
		const guild = client.guilds.get(message.d.guild_id)
		const member = guild?.members.find(m => m.user.id === message.d.user.id)
		if (member) { // only update existing members (i.e. the bot's own member) - don't want to inflate the cache with new irrelevant ones
			Object.assign(member, message.d)
		}

	} else if (message.t === "THREAD_CREATE") {
		client.channels.set(message.d.id, message.d)
		if (message.d["guild_id"]) {
			const channels = client.guildChannelMap.get(message.d["guild_id"])
			if (channels && !channels.includes(message.d.id)) channels.push(message.d.id)
		}

	} else if (message.t === "CHANNEL_UPDATE" || message.t === "THREAD_UPDATE") {
		client.channels.set(message.d.id, message.d)


	} else if (message.t === "CHANNEL_PINS_UPDATE") {
		const channel = client.channels.get(message.d.channel_id)
		if (channel) {
			channel["last_pin_timestamp"] = message.d.last_pin_timestamp
		}


	} else if (message.t === "GUILD_DELETE") {
		client.guilds.delete(message.d.id)
		const channels = client.guildChannelMap.get(message.d.id)
		if (channels) {
			for (const id of channels) client.channels.delete(id)
		}
		client.guildChannelMap.delete(message.d.id)


	} else if (message.t === "CHANNEL_CREATE") {
		client.channels.set(message.d.id, message.d)
		if (message.d["guild_id"]) { // obj[prop] notation can be used to access a property without typescript complaining that it doesn't exist on all values something can have
			const channels = client.guildChannelMap.get(message.d["guild_id"])
			if (channels && !channels.includes(message.d.id)) channels.push(message.d.id)
		}

	} else if (message.t === "CHANNEL_DELETE") {
		client.channels.delete(message.d.id)
		if (message.d["guild_id"]) {
			const channels = client.guildChannelMap.get(message.d["guild_id"])
			if (channels) {
				const previous = channels.indexOf(message.d.id)
				if (previous !== -1) channels.splice(previous, 1)
			}
		}
	}

	// Event dispatcher for OOYE bridge operations
	if (listen === "full" && message.t) {
		const alwaysRealTimeEvents = ["PRESENCE_UPDATE"]
		const optionalEvents = ["TYPING_START"]
		if (alwaysRealTimeEvents.includes(message.t) || homeserverStatus.homeserverStatus.isRealTime()) {
			// real time
			dispatchPacketToBridge(client, message)
		} else if (optionalEvents.includes(message.t)) {
			// when not real time, skip optional events
		} else {
			// queue required events
			homeserverStatus.homeserverStatus.queuePacket(message)
		}
	}
}

/**
 * @param {import("./discord-client")} client
 * @param {import("cloudstorm").IGatewayMessage} message
 */
async function dispatchPacketToBridge(client, message) {
	// requiring this later so that the client is already constructed by the time event-dispatcher is loaded
	/** @type {typeof import("./event-dispatcher")} */
	const eventDispatcher = sync.require("./event-dispatcher")
	/** @type {import("../discord/register-interactions")} */
	const interactions = sync.require("../discord/register-interactions")

	assert(message.t) // checked above

	try {
		if (message.t === "MESSAGE_REACTION_REMOVE" || message.t === "MESSAGE_REACTION_REMOVE_EMOJI" || message.t === "MESSAGE_REACTION_REMOVE_ALL") {
			await eventDispatcher.onSomeReactionsRemoved(client, message.d)

		} else if (message.t === "INTERACTION_CREATE") {
			await interactions.dispatchInteraction(message.d)

		} else if (message.t in eventDispatcher) {
			await eventDispatcher[message.t](client, message.d)
		}
	} catch (e) {
		// Let OOYE try to handle errors too
		await eventDispatcher.onError(client, e, message)
	}
}

module.exports.onPacket = onPacket
module.exports.dispatchPacketToBridge = dispatchPacketToBridge
module.exports.guildReadyStatus = guildReadyStatus