const { EmbedBuilder } = require('discord.js');
const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database('myDatabase.db');
module.exports = {
    name: 'alias',
    description: 'Gérer les alias des commandes',
    aliases: ['alias'],
    category: 'botcontrol',
    emote: '📝',
    utilisation: 'alias <add|remove|list>',

    async execute(message, args, client) {
        const botId = message.client.user.id;
        const subCommand = args[0];
        if (!subCommand) {
            return message.reply('Veuillez spécifier une sous-commande: add, remove, list.');
        }

        switch (subCommand) {
            case 'add':
                const commandName = args[1];
                const newAlias = args[2];
                if (!commandName || !newAlias) {
                    return message.reply('Veuillez spécifier la commande et le nouvel alias.');
                }
            
                const command = client.commands.get(commandName);
                if (!command) {
                    return message.reply(`La commande ${commandName} n'existe pas.`);
                }
                const aliasCheck = isAliasUnique(client, newAlias);
                if (!aliasCheck.isUnique) {
                    return message.reply(`Cet alias est déjà utilisé par la commande \`${aliasCheck.conflictCommand}\`.`);
                }
            
            
                let data = await new Promise((resolve, reject) => {
                    db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                        if (err) {
                            console.error(err.message);
                            reject(err);
                        }
                        resolve(row ? JSON.parse(row.value) : {});
                    });
                });
            
                if (!data.alias) {
                    data.alias = {};
                }
            
                for (const cmd in data.alias) {
                    if (data.alias[cmd][newAlias]) {
                        return message.reply(`Cet alias est déjà utilisé par la commande \`${cmd}\`.`);
                    }
                }
            
                if (!data.alias[commandName]) {
                    data.alias[commandName] = {};
                }
            
                data.alias[commandName][newAlias] = true;
            
                db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], (err) => {
                    if (err) {
                        console.error(err.message);
                        return message.reply('Une erreur est survenue lors de l\'ajout de l\'alias.');
                    }
                    message.reply(`Alias ajouté pour la commande ${commandName}: ${newAlias}`);
                });
                break;
                case 'remove':
                    const commandName2 = args[1];
                    const aliasToRemove = args[2];
                    if (!commandName2 || !aliasToRemove) {
                        return message.reply('Veuillez spécifier la commande et l\'alias à supprimer.');
                    }
                    let data2 = await new Promise((resolve, reject) => {
                        db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                            if (err) {
                                console.error(err.message);
                                reject(err);
                            }
                            resolve(row ? JSON.parse(row.value) : {});
                        });
                    });
                
                    if (!data2.alias || !data2.alias[commandName2] || !data2.alias[commandName2][aliasToRemove]) {
                        return message.reply('Alias non trouvé pour cette commande.');
                    }

                    delete data2.alias[commandName2][aliasToRemove];
                
                    db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data2)], (err) => {
                        if (err) {
                            console.error(err.message);
                            return message.reply('Une erreur est survenue lors de la suppression de l\'alias.');
                        }
                        message.reply(`Alias ${aliasToRemove} supprimé de la commande ${commandName2}.`);
                    });
                    break;
                    case 'list':
                        let data3 = await new Promise((resolve, reject) => {
                            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                                if (err) {
                                    console.error(err.message);
                                    reject(err);
                                }
                                resolve(row ? JSON.parse(row.value) : {});
                            });
                        });
                    
                        let aliasesList = '';
                        for (const command in data3.alias) {
                            aliasesList += `**${command}**: ${Object.keys(data3.alias[command]).join(', ')}\n`;
                        }
                        const embed = new EmbedBuilder()
                            .setTitle('Liste des alias')
                            .setDescription(aliasesList || 'Aucun alias défini.')
                            .setFooter({ text: 'Gestion des alias', iconURL: client.user.displayAvatarURL({dynamic: true})});
                        message.channel.send({ embeds: [embed] });
                        break;
            default:
                return message.reply('Sous-commande invalide. Veuillez utiliser add, remove, ou list.');
        }
    },
};
function isAliasUnique(client, newAlias) {
    for (const command of client.commands.values()) {
        if (command.name === newAlias) {
            return { isUnique: false, conflictCommand: command.name };
        }
        if (command.aliases && command.aliases.includes(newAlias)) {
            return { isUnique: false, conflictCommand: command.name };
        }
    }
    return { isUnique: true };
}