"use strict";
const Discord = require("@xhayper/discord-rpc");
const { dev } = require("electron-is");
const { dialog, app } = require("electron");

const registerCallback = require("../../providers/song-info");

// Application ID registered by @Zo-Bro-23
const clientId = "1043858434585526382";

/**
 * @typedef {Object} Info
 * @property {import('@xhayper/discord-rpc').Client} rpc
 * @property {boolean} ready
 * @property {boolean} autoReconnect
 * @property {import('../../providers/song-info').SongInfo} lastSongInfo
 */
/**
 * @type {Info}
 */
const info = {
	rpc: new Discord.Client({
		clientId
	}),
	ready: false,
	autoReconnect: true,
	lastSongInfo: null,
};

/**
 * @type {(() => void)[]}
 */
const refreshCallbacks = [];

const resetInfo = () => {
	info.ready = false;
	clearTimeout(clearActivity);
	if (dev()) console.log("discord disconnected");
	refreshCallbacks.forEach(cb => cb());
};

info.rpc.on("connected", () => {
	if (dev()) console.log("discord connected");
	refreshCallbacks.forEach(cb => cb());
});

info.rpc.on("ready", () => {
	info.ready = true;
	if (info.lastSongInfo) updateActivity(info.lastSongInfo)
});

info.rpc.on("disconnected", () => {
	resetInfo();

	if (info.autoReconnect) {
		connectTimeout();
	}
});

const connectTimeout = () => new Promise((resolve, reject) => setTimeout(() => {
	if (!info.autoReconnect || info.rpc.isConnected) return;
	info.rpc.login().then(resolve).catch(reject);
}, 5000));

const connectRecursive = () => {
	if (!info.autoReconnect || info.rpc.isConnected) return;
	connectTimeout().catch(connectRecursive);
}

let window;
const connect = (showErr = false) => {
	if (info.rpc.isConnected) {
		if (dev())
			console.log('Attempted to connect with active connection');
		return;
	}

	info.ready = false;

	// Startup the rpc client
	info.rpc.login({ clientId }).catch(err => {
		resetInfo();
		if (dev()) console.error(err);
		if (info.autoReconnect) {
			connectRecursive();
		}
		else if (showErr) dialog.showMessageBox(window, { title: 'Connection failed', message: err.message || String(err), type: 'error' });
	});
};

let clearActivity;
/**
 * @type {import('../../providers/song-info').songInfoCallback}
 */
let updateActivity;

module.exports = (win, { autoReconnect, activityTimoutEnabled, activityTimoutTime, listenAlong, hideDurationLeft }) => {
	info.autoReconnect = autoReconnect;

	window = win;
	// We get multiple events
	// Next song: PAUSE(n), PAUSE(n+1), PLAY(n+1)
	// Skip time: PAUSE(N), PLAY(N)
	updateActivity = songInfo => {
		if (songInfo.title.length === 0 && songInfo.artist.length === 0) {
			return;
		}
		info.lastSongInfo = songInfo;

		// stop the clear activity timout
		clearTimeout(clearActivity);

		// stop early if discord connection is not ready
		// do this after clearTimeout to avoid unexpected clears
		if (!info.rpc || !info.ready) {
			return;
		}

		// clear directly if timeout is 0
		if (songInfo.isPaused && activityTimoutEnabled && activityTimoutTime === 0) {
			info.rpc.user?.clearActivity().catch(console.error);
			return;
		}

		// Song information changed, so lets update the rich presence
		// @see https://discord.com/developers/docs/topics/gateway#activity-object
		// not all options are transfered through https://github.com/discordjs/RPC/blob/6f83d8d812c87cb7ae22064acd132600407d7d05/src/client.js#L518-530
		const activityInfo = {
			details: songInfo.title,
			state: songInfo.artist,
			largeImageKey: songInfo.imageSrc,
			largeImageText: songInfo.album,
				buttons: listenAlong ? [
				{ label: "Listen Along", url: songInfo.url },
			] : undefined,
		};

		if (songInfo.isPaused) {
			// Add a paused icon to show that the song is paused
			activityInfo.smallImageKey = "paused";
			activityInfo.smallImageText = "Paused";
			// Set start the timer so the activity gets cleared after a while if enabled
			if (activityTimoutEnabled)
				clearActivity = setTimeout(() => info.rpc.user?.clearActivity().catch(console.error), activityTimoutTime ?? 10000);
		} else if (!hideDurationLeft) {
			// Add the start and end time of the song
			const songStartTime = Date.now() - songInfo.elapsedSeconds * 1000;
			activityInfo.startTimestamp = songStartTime;
			activityInfo.endTimestamp =
				songStartTime + songInfo.songDuration * 1000;
		}

		info.rpc.user?.setActivity(activityInfo).catch(console.error);
	};

	// If the page is ready, register the callback
	win.once("ready-to-show", () => {
		registerCallback(updateActivity);
		connect();
	});
	app.on('window-all-closed', module.exports.clear)
};

module.exports.clear = () => {
	if (info.rpc) info.rpc.user?.clearActivity();
	clearTimeout(clearActivity);
};

module.exports.connect = connect;
module.exports.registerRefresh = (cb) => refreshCallbacks.push(cb);
module.exports.isConnected = () => info.rpc !== null;