const { SlashCommandBuilder, EmbedBuilder, inlineCode } = require('discord.js')
let dotenv = require('dotenv')
dotenv.config()

const appDir = require('path').dirname(require.main.filename)
const API = require('require-all')(appDir + '/utilsAMP')

function failMsg(data) { return `La commande a échouée !\n${inlineCode(`${data.Title}: ${data.Message}`)}` }
function errorMsg(data) { return `Y'a eu une erreur !\n${inlineCode(`${data.error_code}`)}` }

module.exports = {
	data: new SlashCommandBuilder().setName('amp').setDescription('Accède à mon panel de jeu AMP !')
	.addSubcommand(subcommand => subcommand.setName('login').setDescription("Connectez-vous avant d'effectuer une autre commande !")
		.addStringOption(option => option.setName('username').setDescription("Nom d'Utilisateur").setRequired(true))
		.addStringOption(option => option.setName('password').setDescription('Mot de Passe').setRequired(true))
		.addBooleanOption(option => option.setName('remember').setDescription('Mémoriser les identifiants').setRequired(true))
		.addStringOption(option => option.setName('otp').setDescription('Code de double authentification')))

	.addSubcommandGroup(subcommandgroup => subcommandgroup.setName('instances').setDescription('Intéragir avec les instances AMP.')
		.addSubcommand(subcommand => subcommand.setName('list').setDescription('Liste toutes les instances disponibles.'))

		.addSubcommand(subcommand => subcommand.setName('manage').setDescription('Gérer une instance.')
			.addStringOption(option => option.setName('name').setDescription("Nom de l'instance").setRequired(true)))

		.addSubcommand(subcommand => subcommand.setName('restart').setDescription('Redémarre une instance.')
			.addStringOption(option => option.setName('name').setDescription("Nom de l'instance").setRequired(true)))),

	async execute(interaction) {
		// Let the user login
		if (interaction.options.getSubcommand() == 'login') {
			// Get a SessionID and a RememberMeToken if wanted
			await interaction.deferReply({ ephemeral: true })

			let details = {
				username: interaction.options.getString('username'),
				password: interaction.options.getString('password'),
				token: interaction.options.getString('otp') || '',
				rememberMe: interaction.options.getBoolean('remember')
			}

			let result = await API.Core.Login(details)
			if (result.status === 'success') return await interaction.followUp(`Tu es connecté au panel sous **${result.data.userInfo.Username}** !`)
			else if (result.status === 'fail') return await interaction.followUp(failMsg(result.data))
			else if (result.status === 'error') return await interaction.followUp(errorMsg(result.data))
		}
		await interaction.deferReply()
		
		// Check if the SessionID is still valid
		let sessionID = dotenv.config().parsed.AMP_SESSIONID

		let session = await API.CheckSession(sessionID)
		if (session.status === 'fail') {
			console.log(session)
			if (process.env.AMP_REMEMBER_TOKEN) {
				// Refresh the SessionID if the RememberMeToken is available
				let details = {
					username: process.env.AMP_USERNAME,
					password: '',
					token: process.env.AMP_REMEMBER_TOKEN,
					rememberMe: true
				}
				let result = await API.Core.Login(details)
				console.log(result)
				if (result.status === 'success') sessionID = result.data.sessionID
				else if (result.status === 'fail') return await interaction.followUp(failMsg(result.data))
				else if (result.status === 'error') return await interaction.followUp(errorMsg(result.data))
			}
			else {
				// If no RememberMeToken is available, ask to login
				return await interaction.followUp(`Tu dois te connecter avant d'effectuer une autre commande !`)
			}
		}
		else if (session.status === 'error') return await interaction.followUp(errorMsg(session.data))

		if (interaction.options.getSubcommandGroup() == 'instances') {
			if (interaction.options.getSubcommand() == 'list') {
				let result = await API.ADSModule.GetInstances(sessionID)

				if (result.status === 'success') {
					await interaction.followUp({ content: `${result.data.result.length} hôtes trouvés !` })
					result.data.result.forEach(async host => {
						let fields = []
						host.AvailableInstances.forEach(instance => {
							fields.push({
								name: instance.FriendlyName,
								value: `**ID:** ${instance.InstanceID}
									**Running:** ${instance.Running}
									**IP:** ${instance.IP}
									**Port:** ${instance.Port}
									**Module:** ${instance.Module}`,
								inline: true
							})
						})
						let embed = new EmbedBuilder()
							.setTitle('Instances')
							.setDescription(`Liste des instances de l'hôte **${host.FriendlyName}** :`)
							.setColor(interaction.guild.members.me.displayColor)
							.setTimestamp()
							.setFields(fields)
						return await interaction.channel.send({ embeds: [embed] })
					})
				}
				else if (result.status === 'fail') return await interaction.followUp(failMsg(result.data))
				else if (result.status === 'error') return await interaction.followUp(errorMsg(result.data))
			}
			else if (interaction.options.getSubcommand() == 'manage') {
				let query = interaction.options.getString('name')
				let result = await API.ADSModule.ManageInstance(sessionID, query)

				if (result.status === 'success') return await interaction.followUp(`Ok !`)
				else if (result.status === 'fail') return await interaction.followUp(failMsg(result.data))
				else if (result.status === 'error') return await interaction.followUp(errorMsg(result.data))
			}
			else if (interaction.options.getSubcommand() == 'restart') {
				let query = interaction.options.getString('name')
				let result = await API.ADSModule.RestartInstance(sessionID, query)

				if (result.status === 'success') return await interaction.followUp(`Ok !`)
				else if (result.status === 'fail') return await interaction.followUp(failMsg(result.data))
				else if (result.status === 'error') return await interaction.followUp(errorMsg(result.data))
			}
		}
	}
}