const TelegramBot = require('node-telegram-bot-api');
const env = require('./.env');
const fs = require('fs');
const bot = new TelegramBot(env.token, { polling: true });
const jsonFilePathUsers = 'db/usernameIdMap.json';
const jsonFilePathWarnings = 'db/warningsIdMap.json';
const jsonFilePathMenu = 'db/menuIdMap.json';
const MAX_WARNINGS = env.MAX_WARNINGS;

let customCommands = {};
let usernameToUserIdMap = [];
let warnings = {};

const welcomeMessages = [
    'Esperamos que você se divirta por aqui!',
    'Estamos felizes em tê-lo(a) no grupo.',
    'Sinta-se à vontade para participar das conversas.'
];
const allowedGroupIds = [
    '-1001576734558',
    '-1002005067008', //DTunnel Mod (ConfigMods)
    '-1002016594807', //Grupo de testes
    '-1001591216081'  //Grupo do shaka
];

if (fs.existsSync(jsonFilePathUsers)) {
    const jsonDataUsers = fs.readFileSync(jsonFilePathUsers);
    usernameToUserIdMap = JSON.parse(jsonDataUsers);
}
if (fs.existsSync(jsonFilePathWarnings)) {
    const jsonDataWarnings = fs.readFileSync(jsonFilePathWarnings);
    warnings = JSON.parse(jsonDataWarnings);
}
if (fs.existsSync(jsonFilePathMenu)) {
    const jsonDataMenu = fs.readFileSync(jsonFilePathMenu);
    customCommands = JSON.parse(jsonDataMenu);
}

bot.on('message', (msg) => {
    const chatId = msg.chat.id;
    const { username, id } = msg.from;
    if (username) {
        const userIndex = usernameToUserIdMap.findIndex(user => user.id === id);
        if (userIndex !== -1) {
            const firstName = msg.from.first_name || '';
            const lastName = msg.from.last_name || '';
            const usernameOld = usernameToUserIdMap[userIndex].username;

            if (usernameOld != username) {
                const message = `🧐 Mudança Detectada\n\n👤 Usuário: ${firstName + ' ' + lastName} [ID: ${id}]\n\n✏️ Mudou @${usernameOld} Para @${username}`;
                bot.sendMessage(chatId, message);
            }
            usernameToUserIdMap[userIndex].username = username;
        } else {
            usernameToUserIdMap.push({ id, username });
        }
        fs.writeFileSync(jsonFilePathUsers, JSON.stringify(usernameToUserIdMap, null, 4));
    }
});

bot.on('message', async (msg) => {
    const chatId = msg.chat.id;
    const msgUserId = msg.message_id;
    if (msg.entities && msg.entities[0].type === 'bot_command') {
        const command = msg.text.split(' ')[0];

        if (msg.chat.type === 'private') {
            switch (command) {
                case '/start':
                    bot.sendMessage(chatId, 'Olá! Eu sou Amy gerenciadora de grupos.');
                    break;
            }
        } else {
            if (command == '/id') {
                bot.sendMessage(chatId, `ID do Grupo: ${chatId}`);
                return;
            }
            if (!isChatAllowed(chatId)) {
                bot.sendMessage(chatId, `O bot não está autorizado a ser usado neste grupo.`);
                return;
            }
            switch (command) {
                case '/start':
                    bot.sendMessage(chatId, 'Olá! Eu sou Amy gerenciadora de grupos.');
                    break;
                case '/ban':
                    checkAdminPermission(msg, () => {
                        let userId;
                        let userName;
                        const commandParams = msg.text.split(' ');

                        if (msg.reply_to_message) {
                            userId = msg.reply_to_message.from.id;
                            userName = msg.reply_to_message.from.first_name + (msg.reply_to_message.from.last_name ? ' ' + msg.reply_to_message.from.last_name : '');
                        } else if (commandParams.length > 1 && /^\d+$/.test(commandParams[1])) {
                            userId = commandParams[1];
                            userName = userId;
                        } else if (commandParams.length > 1 && commandParams[1].startsWith('@')) {
                            const username = commandParams[1].substring(1);
                            const user = usernameToUserIdMap.find(user => user.username === username);

                            if (user) {
                                const user_Id = user.id;
                                bot.banChatMember(chatId, user_Id);
                                sendMessageWithUndoButton(chatId, `Usuário banido: @${username} (${user_Id})`, JSON.stringify({ command: 'undo_ban', userId: user_Id }));
                            } else {
                                bot.sendMessage(chatId, 'O usuário não foi encontrado.');
                            }
                            return;
                        } else {
                            bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário ou o username para banir.');
                            return;
                        }

                        bot.banChatMember(chatId, userId);
                        sendMessageWithUndoButton(chatId, `Usuário banido: ${userName} (${userId})`, JSON.stringify({ command: 'undo_ban', userId: userId }));
                    });
                    break;
                case '/warn':
                    checkAdminPermission(msg, () => {
                        const reasonWarn = msg.text.split(' ').slice(1).join(' ');
                        if (!reasonWarn) {
                            const warnedUserId = msg.reply_to_message.from.id;
                            const groupId = msg.chat.id;

                            if (!warnings[groupId]) {
                                warnings[groupId] = {};
                            }

                            const username = msg.reply_to_message.from.username;
                            warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
                            const warnMessage = `Usuário @${username} advertido: ${warnings[groupId][warnedUserId]}/3`;
                            sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
                            if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
                                bot.banChatMember(chatId, warnedUserId);
                                bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
                                delete warnings[groupId][warnedUserId];
                            }
                            saveWarnings();
                        } else {
                            const warnedUserId = msg.reply_to_message.from.id;
                            const groupId = msg.chat.id;

                            if (!warnings[groupId]) {
                                warnings[groupId] = {};
                            }

                            const username = msg.reply_to_message.from.username;
                            warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
                            const warnMessage = `Usuário @${username} advertido: ${warnings[groupId][warnedUserId]}/3\nMotivo: ${reasonDWarn}.`;
                            sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
                            if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
                                bot.banChatMember(chatId, warnedUserId);
                                bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
                                delete warnings[groupId][warnedUserId];
                            }
                            saveWarnings();
                        }
                    });
                    break;
                case '/mute':
                    checkAdminPermission(msg, () => {

                        let userId;
                        let userName;

                        if (msg.reply_to_message) {
                            userId = msg.reply_to_message.from.id;
                            userName = msg.reply_to_message.from.username;
                        } else {
                            const commandParams = msg.text.split(' ').slice(1).join(' ');

                            if (!commandParams) {
                                bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
                                return;
                            }
                            if (/^\d+$/.test(commandParams)) {
                                userId = commandParams;
                                userName = userId;
                                bot.getChatMember(chatId, userId).then((user) => {
                                    userName = user.user.username || 'não disponível';
                                    const options = {
                                        until_date: Math.floor(Date.now() / 1000) + 3600,
                                        can_send_messages: false
                                    };

                                    bot.restrictChatMember(chatId, userId, options);
                                    sendMessageWithUndoButton(chatId, `@${userName} (${userId}) mutado por 1h.`, JSON.stringify({ command: 'undo_mute', userId: userId }));
                                }).catch((error) => {
                                    console.error('Erro ao obter informações do usuário:', error.message);
                                    bot.sendMessage(chatId, 'Erro ao obter informações do usuário.');
                                });
                                return;
                            } else if (commandParams.startsWith('@')) {
                                const usernameParam = commandParams.substring(1);
                                const user = usernameToUserIdMap.find(user => user.username === usernameParam);

                                if (user) {
                                    userId = user.id;
                                    userName = usernameParam;

                                    const options = {
                                        until_date: Math.floor(Date.now() / 1000) + 3600,
                                        can_send_messages: false
                                    };

                                    bot.restrictChatMember(chatId, userId, options);
                                    sendMessageWithUndoButton(chatId, `@${userName} (${userId}) mutado por 1h.`, JSON.stringify({ command: 'undo_mute', userId: userId }));
                                    return;
                                } else {
                                    bot.sendMessage(chatId, 'Usuário não encontrado.');
                                    return;
                                }
                            } else {
                                bot.sendMessage(chatId, 'Formato de entrada inválido. Use /mute @username ou /mute user_id.');
                                return;
                            }
                        }

                        const options = {
                            until_date: Math.floor(Date.now() / 1000) + 3600,
                            can_send_messages: false
                        };

                        bot.restrictChatMember(chatId, userId, options);
                        sendMessageWithUndoButton(chatId, `@${userName} (${userId}) mutado por 1h.`, JSON.stringify({ command: 'undo_mute', userId: userId }));

                    });
                    break;
                case '/unmute':
                    checkAdminPermission(msg, () => {

                        let userId;
                        let userName;

                        if (msg.reply_to_message) {
                            userId = msg.reply_to_message.from.id;
                            userName = msg.reply_to_message.from.username;
                        } else {
                            const commandParams = msg.text.split(' ').slice(1).join(' ');

                            if (!commandParams) {
                                bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
                                return;
                            }
                            if (/^\d+$/.test(commandParams)) {
                                userId = commandParams;
                                userName = userId;
                                bot.getChatMember(chatId, userId).then((user) => {
                                    userName = user.user.username || 'não disponível';
                                    const options = { can_send_messages: true };

                                    bot.restrictChatMember(chatId, userId, options);
                                    bot.sendMessage(chatId, `@${userName} foi desmutado.`);
                                }).catch((error) => {
                                    console.error('Erro ao obter informações do usuário:', error.message);
                                    bot.sendMessage(chatId, 'Erro ao obter informações do usuário.');
                                });
                                return;
                            } else if (commandParams.startsWith('@')) {
                                const usernameParam = commandParams.substring(1);
                                const user = usernameToUserIdMap.find(user => user.username === usernameParam);

                                if (user) {
                                    userId = user.id;
                                    userName = usernameParam;

                                    const options = { can_send_messages: true };

                                    bot.restrictChatMember(chatId, userId, options);
                                    bot.sendMessage(chatId, `@${userName} foi desmutado.`);
                                    return;
                                } else {
                                    bot.sendMessage(chatId, 'Usuário não encontrado.');
                                    return;
                                }
                            } else {
                                bot.sendMessage(chatId, 'Formato de entrada inválido. Use /unmute @username ou /unmute user_id.');
                                return;
                            }
                        }

                        const options = { can_send_messages: true };

                        bot.restrictChatMember(chatId, userId, options);
                        bot.sendMessage(chatId, `@${userName} foi desmutado.`);
                    });
                    break;
                case '/info':
                    checkAdminPermission(msg, () => {
                        let userId;
                        let username;
                        let user_id;

                        const commandParams = msg.text.split(' ');

                        if (msg.reply_to_message) {
                            userId = msg.reply_to_message.from.id;
                            username = msg.reply_to_message.from.username || 'não disponível';
                            user_id = userId;
                        } else {
                            const firstParam = commandParams[1];
                            if (commandParams[1] != null) {
                                if (/^\d+$/.test(firstParam)) {
                                    userId = firstParam;
                                    bot.getChatMember(chatId, userId).then((user) => {
                                        user_id = user.user.id;
                                        username = user.user.username || 'não disponível';
                                        const userWarnings = warnings[userId] || 0;
                                        bot.sendMessage(chatId, `Informações sobre o usuário:\nUser: @${username}\nID: ${user_id}\nNúmero de advertências: ${userWarnings}`);
                                    }).catch((error) => {
                                        console.error('Erro ao obter informações do usuário:', error.message);
                                        bot.sendMessage(chatId, 'Erro ao obter informações do usuário.');
                                    });
                                    return;
                                } else if (firstParam.startsWith('@')) {
                                    const usernameParam = firstParam.substring(1);

                                    const user = usernameToUserIdMap.find(user => user.username === usernameParam);

                                    if (user) {
                                        user_id = user.id;
                                        username = usernameParam;
                                    } else {
                                        bot.sendMessage(chatId, 'O usuário não foi encontrado.');
                                        return;
                                    }
                                }
                            } else {
                                bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
                                return;
                            }
                        }

                        const userWarnings = warnings[userId] || 0;
                        bot.sendMessage(chatId, `Informações sobre o usuário:\nUser: @${username}\nID: ${user_id}\nNúmero de advertências: ${userWarnings}`);
                    });
                    break;
                case '/dwarn':
                    checkAdminPermission(msg, () => {
                        const reasonDWarn = msg.text.split(' ').slice(1).join(' ');
                        if (!reasonDWarn) {
                            const warnedUserId = msg.reply_to_message.from.id;
                            const groupId = msg.chat.id;

                            if (!warnings[groupId]) {
                                warnings[groupId] = {};
                            }

                            const username = msg.reply_to_message.from.username;
                            warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
                            bot.deleteMessage(chatId, msg.reply_to_message.message_id);
                            const warnMessage = `Usuário @${username} advertido: ${warnings[groupId][warnedUserId]}/3`;
                            sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
                            if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
                                bot.banChatMember(chatId, warnedUserId);
                                bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
                                delete warnings[groupId][warnedUserId];
                            }
                            saveWarnings();
                        } else {
                            const warnedUserId = msg.reply_to_message.from.id;
                            const groupId = msg.chat.id;

                            if (!warnings[groupId]) {
                                warnings[groupId] = {};
                            }

                            const username = msg.reply_to_message.from.username;
                            warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
                            bot.deleteMessage(chatId, msg.reply_to_message.message_id);
                            const warnMessage = `Usuário @${username} adivertido: ${warnings[groupId][warnedUserId]}/3\nMotivo: ${reasonDWarn}.`;
                            sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
                            if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
                                bot.banChatMember(chatId, warnedUserId);
                                bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
                                delete warnings[groupId][warnedUserId];
                            }
                            saveWarnings();
                        }
                    });
                    break;
                case '/dmute':
                    checkAdminPermission(msg, () => {
                        const messageId = msg.reply_to_message.message_id;
                        bot.deleteMessage(chatId, messageId).then(() => {
                            const userId = msg.reply_to_message.from.id;
                            const options = {
                                until_date: Math.floor(Date.now() / 1000) + 3600,
                                can_send_messages: false
                            };
                            bot.restrictChatMember(chatId, userId, options).then(() => {
                                sendMessageWithUndoButton(chatId, 'Mensagem apagada e usuário mutado por 1 hora.', JSON.stringify({ command: 'undo_mute', userId: userId }));
                            }).catch((error) => {
                                console.error('Erro ao mutar usuário:', error.message);
                                bot.sendMessage(chatId, 'Erro ao mutar usuário.');
                            });
                        }).catch((error) => {
                            console.error('Erro ao apagar mensagem:', error.message);
                            bot.sendMessage(chatId, 'Erro ao apagar mensagem.');
                        });
                    });
                    break;
                case '/dban':
                    checkAdminPermission(msg, () => {
                        const messageId = msg.reply_to_message.message_id;
                        bot.deleteMessage(chatId, messageId).then(() => {
                            const userId = msg.reply_to_message.from.id;
                            bot.banChatMember(chatId, userId).then(() => {
                                sendMessageWithUndoButton(chatId, 'Mensagem apagada e usuário banido.', JSON.stringify({ command: 'undo_ban', userId: userId }));
                            }).catch((error) => {
                                console.error('Erro ao banir usuário:', error.message);
                                bot.sendMessage(chatId, 'Erro ao banir usuário.');
                            });
                        }).catch((error) => {
                            console.error('Erro ao apagar mensagem:', error.message);
                            bot.sendMessage(chatId, 'Erro ao apagar mensagem.');
                        });
                    });
                    break;
                case '/promote':
                    checkCreatorPermission(msg, async () => {
                        const commandParams = msg.text.split(' ');
                        let userId;
                        let userName;
                        let user_name;

                        if (msg.reply_to_message) {
                            userId = msg.reply_to_message.from.id;
                            userName = msg.reply_to_message.from.first_name + (msg.reply_to_message.from.last_name ? ' ' + msg.reply_to_message.from.last_name : '');
                            user_name = msg.reply_to_message.from.username;
                        }

                        if (!userId && commandParams.length > 1 && /^\d+$/.test(commandParams[1])) {
                            userId = commandParams[1];
                            userName = userId;
                            user_name = msg.reply_to_message.from.username;
                        }

                        if (!userId && commandParams.length > 1 && commandParams[1].startsWith('@')) {
                            const username = commandParams[1].substring(1);

                            // Procurar o usuário no usernameToUserIdMap
                            const user = usernameToUserIdMap.find(user => user.username === username);

                            if (user) {
                                const user_Id = user.id;
                                await bot.promoteChatMember(chatId, user_Id, { can_change_info: false, can_delete_messages: true, can_invite_users: true, can_restrict_members: true, can_pin_messages: true, can_promote_members: false });
                                bot.sendMessage(chatId, `Usuário @${username} promovido a administrador.`);
                                return;
                            } else {
                                bot.sendMessage(chatId, 'O usuário não foi encontrado.');
                                return;
                            }
                        }

                        if (!userId) {
                            bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
                            return;
                        }

                        try {
                            await bot.promoteChatMember(chatId, userId, { can_change_info: false, can_delete_messages: true, can_invite_users: true, can_restrict_members: true, can_pin_messages: true, can_promote_members: false });
                            bot.sendMessage(chatId, `Usuário @${user_name} promovido a administrador.`);
                        } catch (error) {
                            console.error('Erro ao promover usuário a administrador:', error.message);
                            bot.sendMessage(chatId, 'Erro ao promover usuário a administrador.');
                        }
                    });
                    break;
                case '/send':
                    const commandParams = msg.text.split(' ').slice(1).join(' ');
                    console.log(commandParams)
                    bot.deleteMessage(chatId, msg.message_id);
                    bot.sendMessage(chatId, commandParams);
                    break;
                case '/comandos':
                    const message = await fs.readFileSync('db/comandos.txt', 'utf-8');
                    bot.sendMessage(chatId, message, { parse_mode: 'HTML' });
                    break;
                case '/create':
                    checkAdminPermission(msg, async () => {
                        const commandData = msg.text.split(' ').slice(1).join(' ').split(':') || [];
                        const commandName = commandData[0] ? commandData[0].trim() : false;
                        const commandOrder = commandData[1] ? parseInt(commandData[1].trim()) : false;
                        const groupId = msg.chat.id;

                        if (!customCommands[groupId]) {
                            customCommands[groupId] = {};
                        }

                        if (!commandData || commandData.length !== 2) {
                            bot.sendMessage(chatId, 'Formato inválido. Use /create nome:ordem');
                            return;
                        }

                        if (!commandName) {
                            bot.sendMessage(chatId, 'Necessário adicionar um nome para o comando.');
                            return;
                        }

                        if (!commandOrder || isNaN(commandOrder) || commandOrder <= 0) {
                            bot.sendMessage(chatId, 'Necessário adicionar uma ordem válida para o comando.');
                            return;
                        }

                        if (customCommands[groupId][commandName]) {
                            bot.sendMessage(chatId, `O comando '${commandName}' já existe.`);
                            return;
                        }

                        if (!msg.reply_to_message || !msg.reply_to_message.text) {
                            bot.sendMessage(chatId, 'Você precisa responder a uma mensagem para criar um comando personalizado.');
                            return;
                        }

                        const messageText = msg.reply_to_message.text;

                        customCommands[groupId][commandName] = { text: messageText, order: commandOrder };

                        bot.sendMessage(chatId, `Comando personalizado '${commandName}' criado com número de ordem '${commandOrder}'.`);

                        // Ordena os comandos personalizados por número de ordem
                        const sortedCommands = Object.entries(customCommands[groupId]).sort((a, b) => a[1].order - b[1].order);
                        customCommands[groupId] = Object.fromEntries(sortedCommands);

                        fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));

                        menuOptions = createMenuButtons(groupId);
                    });
                    break;
                case '/menu':
                    menuOptions = createMenuButtons(chatId);
                    const commands = customCommands[chatId];

                    bot.getChatMember(chatId, msg.from.id)
                        .then(chatMember => {
                            let username = '';
                            if (chatMember.user.username) {
                                username = '@' + chatMember.user.username;
                            } else if (chatMember.user.first_name) {
                                username = `${chatMember.user.first_name} (ID: ${chatMember.user.id.toString()})`;
                            }
                            setTimeout(() => {
                                bot.deleteMessage(chatId, msgUserId)
                                    .catch(error => {
                                        console.error('Erro ao excluir mensagem:', error);
                                    });
                            }, 2 * 1000);
                            if (commands && Object.keys(commands).length > 0) {
                                bot.sendPhoto(chatId, 'bot.png', {
                                    caption: `Solicitado por: ${username}\n\nSelecione uma ação:`,
                                    reply_markup: menuOptions.reply_markup,
                                }).then(sentMessage => {
                                    const messageId = sentMessage.message_id;
                                    const delaySeconds = 90;
                                    setTimeout(() => {
                                        bot.deleteMessage(chatId, messageId)
                                            .catch(error => {
                                                console.error('Erro ao excluir mensagem:', error);
                                            });
                                    }, delaySeconds * 1000);
                                }).catch(error => {
                                    console.error('Erro ao enviar mensagem:', error);
                                });
                            } else {
                                bot.sendMessage(chatId, 'Nenhum comando personalizado foi criado ainda');
                            }
                        })
                        .catch(error => {
                            console.error('Erro ao obter informações do membro do chat:', error);
                        });
                    break;
                case '/delete':
                    checkAdminPermission(msg, async () => {
                        const commandToDelete = msg.text.split(' ').slice(1).join(' ');
                        const groupIdToDelete = msg.chat.id;
                        if (customCommands.hasOwnProperty(groupIdToDelete) && customCommands[groupIdToDelete].hasOwnProperty(commandToDelete)) {
                            delete customCommands[groupIdToDelete][commandToDelete];
                            bot.sendMessage(msg.chat.id, `Comando "${commandToDelete}" deletado com sucesso.`)
                                .then(sentMessage => {
                                    menuOptions = createMenuButtons(groupIdToDelete);
                                    fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));
                                    // bot.editMessageReplyMarkup(menuOptions.reply_markup, {
                                    //     chat_id: sentMessage.chat.id,
                                    //     message_id: sentMessage.message_id
                                    // });
                                })
                                .catch(error => {
                                    console.error('Erro ao enviar mensagem:', error);
                                });
                        } else {
                            bot.sendMessage(msg.chat.id, `O comando "${commandToDelete}" não existe.`);
                        }
                    });
                    break;
                case '/unban':
                    checkAdminPermission(msg, async () => {
                        let userId;
                        let user_name

                        const commandParams = msg.text.split(' ');

                        if (msg.reply_to_message) {
                            userId = msg.reply_to_message.from.id;
                        }

                        if (!userId && commandParams.length > 1 && /^\d+$/.test(commandParams[1])) {
                            userId = commandParams[1];
                        }

                        if (!userId && commandParams.length > 1 && commandParams[1].startsWith('@')) {
                            const usernameParam = commandParams[1].substring(1);
                            const user = usernameToUserIdMap.find(user => user.username === usernameParam);

                            if (user) {
                                userId = user.id;
                                user_name = usernameParam;
                            } else {
                                bot.sendMessage(chatId, 'O usuário não foi encontrado.');
                                return;
                            }
                        }

                        if (!userId) {
                            bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
                            return;
                        }

                        bot.getChatMember(msg.chat.id, userId)
                            .then(chatMember => {
                                user_name = chatMember.user.username;
                            })
                            .catch(error => {
                                console.error('Erro ao obter informações do membro do chat:', error);
                            });

                        try {
                            await bot.unbanChatMember(chatId, userId);
                            bot.sendMessage(chatId, `Usuário @${user_name} (ID: ${userId}) foi desbanido.`);
                        } catch (error) {
                            console.error('Erro ao desbanir usuário:', error.message);
                            bot.sendMessage(chatId, 'Erro ao desbanir usuário.');
                        }
                    });
                    break;
                case '/pin':
                    checkAdminPermission(msg, async () => {
                        const messageId = msg.reply_to_message.message_id;

                        if (!messageId) {
                            bot.sendMessage(chatId, 'Por favor, responda à mensagem que deseja fixar com o comando /pin.')
                                .then(sentMessage => {
                                    const messageId = sentMessage.message_id;
                                    const delaySeconds = 30;
                                    setTimeout(() => {
                                        bot.deleteMessage(chatId, messageId)
                                            .catch(error => {
                                                console.error('Erro ao excluir mensagem:', error);
                                            });
                                    }, delaySeconds * 1000);
                                }).catch(error => {
                                    console.error('Erro ao enviar mensagem:', error);
                                });
                            return;
                        }

                        bot.pinChatMessage(chatId, messageId)
                            .then(() => {
                                bot.sendMessage(chatId, 'A mensagem foi fixada com sucesso.')
                                    .then(sentMessage => {
                                        const messageId = sentMessage.message_id;
                                        const delaySeconds = 30;
                                        setTimeout(() => {
                                            bot.deleteMessage(chatId, messageId)
                                                .catch(error => {
                                                    console.error('Erro ao excluir mensagem:', error);
                                                });
                                        }, delaySeconds * 1000);
                                    }).catch(error => {
                                        console.error('Erro ao enviar mensagem:', error);
                                    });
                            })
                            .catch((error) => {
                                console.error('Erro ao fixar mensagem:', error);
                                bot.sendMessage(chatId, 'Ocorreu um erro ao fixar a mensagem. Por favor, tente novamente mais tarde.')
                                    .then(sentMessage => {
                                        const messageId = sentMessage.message_id;
                                        const delaySeconds = 30;
                                        setTimeout(() => {
                                            bot.deleteMessage(chatId, messageId)
                                                .catch(error => {
                                                    console.error('Erro ao excluir mensagem:', error);
                                                });
                                        }, delaySeconds * 1000);
                                    }).catch(error => {
                                        console.error('Erro ao enviar mensagem:', error);
                                    });
                            });
                    });
                    break;
                case '/editar_ordem':
                    checkAdminPermission(msg, async () => {
                        const commandData = msg.text.split(' ').slice(1).join(' ').split(':');
                        const commandName = commandData[0].trim();
                        const newPosition = parseInt(commandData[1].trim());
                        const groupId = msg.chat.id;

                        if (!customCommands[groupId]) {
                            customCommands[groupId] = {};
                        }

                        if (isNaN(newPosition) || newPosition <= 0) {
                            bot.sendMessage(chatId, 'A nova posição do comando deve ser um valor numérico maior que zero.');
                            return;
                        }

                        if (!customCommands[groupId][commandName]) {
                            bot.sendMessage(chatId, `O comando '${commandName}' não existe.`);
                            return;
                        }

                        customCommands[groupId][commandName].order = newPosition;

                        const sortedCommands = Object.entries(customCommands[groupId]).sort((a, b) => a[1].order - b[1].order);
                        customCommands[groupId] = Object.fromEntries(sortedCommands);

                        fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));

                        bot.sendMessage(chatId, `Posição do comando '${commandName}' atualizada para '${newPosition}'.`);

                        menuOptions = createMenuButtons(groupId);
                    });
                    break;
                case '/editar_texto':
                    checkAdminPermission(msg, async () => {
                        const commandName = msg.text.split(' ').slice(1).join(' ');
                        const groupId = msg.chat.id;

                        if (!customCommands[groupId]) {
                            customCommands[groupId] = {};
                        }

                        if (!customCommands[groupId][commandName]) {
                            bot.sendMessage(chatId, `O comando '${commandName}' não existe.`);
                            return;
                        }

                        if (!msg.reply_to_message || !msg.reply_to_message.text) {
                            bot.sendMessage(chatId, 'Você precisa responder a uma mensagem para editar o texto do comando.');
                            return;
                        }

                        const newMessageText = msg.reply_to_message.text;

                        customCommands[groupId][commandName].text = newMessageText;

                        fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));

                        bot.sendMessage(chatId, `Texto do comando '${commandName}' atualizado.`);

                        menuOptions = createMenuButtons(groupId);
                    });
                    break;
                case '/editar_comando':
                    checkAdminPermission(msg, async () => {
                        const commandData = msg.text.split(' ').slice(1).join(' ').split(':');
                        const currentCommandName = commandData[0].trim();
                        const newCommandName = commandData[1].trim();
                        const groupId = msg.chat.id;

                        if (!customCommands[groupId]) {
                            customCommands[groupId] = {};
                        }

                        if (!customCommands[groupId][currentCommandName]) {
                            bot.sendMessage(chatId, `O comando '${currentCommandName}' não existe.`);
                            return;
                        }

                        if (customCommands[groupId][newCommandName]) {
                            bot.sendMessage(chatId, `O novo nome '${newCommandName}' já está em uso.`);
                            return;
                        }

                        customCommands[groupId][newCommandName] = customCommands[groupId][currentCommandName];
                        delete customCommands[groupId][currentCommandName];

                        fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));

                        bot.sendMessage(chatId, `Nome do comando '${currentCommandName}' atualizado para '${newCommandName}'.`);

                        menuOptions = createMenuButtons(groupId);
                    });
                    break;
            }
        }
    }
});
bot.on('callback_query', (callbackQuery) => {
    const msg = callbackQuery.message;
    const data = JSON.parse(callbackQuery.data);
    const user_callbackId = callbackQuery.from.id;
    const userId = data.userId;
    const groupId = msg.chat.id;

    if (!isChatAllowed(groupId)) {
        bot.sendMessage(groupId, `O bot não está autorizado a ser usado neste grupo.`);
        return;
    }

    switch (data.command) {
        case 'undo_warn':
            bot.getChatMember(groupId, user_callbackId)
                .then(chatMember => {
                    const memberStatus = chatMember.status;
                    if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
                        const status = chatMember.status;
                        if (status === 'administrator' || status === 'creator') {
                            if (warnings[groupId][userId] && warnings[groupId][userId] > 0) {
                                warnings[groupId][userId]--;
                                bot.editMessageText('Aviso removido.', {
                                    chat_id: groupId,
                                    message_id: msg.message_id
                                });
                                saveWarnings();
                            } else {
                                bot.sendMessage(groupId, 'Este usuário não possui advertências.');
                            }
                        } else {
                            bot.answerCallbackQuery(callbackQuery.id, 'Você não tem permissão para executar este comando.');
                        }
                    }
                })
                .catch(error => {
                    console.error('Erro ao obter informações do membro do chat:', error.message);
                });
            break;
        case 'undo_ban':
            bot.getChatMember(groupId, user_callbackId)
                .then(chatMember => {
                    const memberStatus = chatMember.status;
                    if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
                        const status = chatMember.status;
                        if (status === 'administrator' || status === 'creator') {
                            bot.unbanChatMember(groupId, userId);
                            bot.editMessageText('Banimento removido.', {
                                chat_id: groupId,
                                message_id: msg.message_id
                            });
                        } else {
                            bot.answerCallbackQuery(callbackQuery.id, 'Você não tem permissão para executar este comando.');
                        }
                    }
                })
                .catch(error => {
                    console.error('Erro ao obter informações do membro do chat:', error.message);
                });
            break;
        case 'undo_mute':
            bot.getChatMember(groupId, user_callbackId)
                .then(chatMember => {
                    const memberStatus = chatMember.status;
                    if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
                        const status = chatMember.status;
                        if (status === 'administrator' || status === 'creator') {
                            const options = { can_send_messages: true };
                            bot.restrictChatMember(groupId, userId, options);
                            bot.editMessageText('Ação de mutar desfeita com sucesso.', {
                                chat_id: groupId,
                                message_id: msg.message_id
                            });
                        } else {
                            bot.answerCallbackQuery(callbackQuery.id, 'Você não tem permissão para executar este comando.');
                        }
                    }
                })
                .catch(error => {
                    console.error('Erro ao obter informações do membro do chat:', error.message);
                });
            break;
        case 'callback_menu':
            menuOptions = createMenuButtons(groupId);
            const commands = customCommands[groupId];
            if (commands && Object.keys(commands).length > 0) {
                bot.getChatMember(groupId, user_callbackId)
                    .then(chatMember => {
                        const memberStatus = chatMember.status;
                        if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
                            let username = '';
                            if (chatMember.user.username) {
                                username = '@' + chatMember.user.username;
                            } else if (chatMember.user.first_name) {
                                username = `${chatMember.user.first_name} (ID: ${chatMember.user.id.toString()})`;
                            }
                            bot.sendPhoto(groupId, 'bot.png', {
                                caption: `Solicitado por: ${username}\n\nSelecione uma ação:`,
                                reply_markup: menuOptions.reply_markup,
                            }).then(sentMessage => {
                                const messageId = sentMessage.message_id;
                                const delaySeconds = 90;
                                setTimeout(() => {
                                    bot.deleteMessage(groupId, messageId)
                                        .catch(error => {
                                            console.error('Erro ao excluir mensagem:', error.message);
                                        });
                                }, delaySeconds * 1000);
                            }).catch(error => {
                                console.error('Erro ao enviar mensagem:', error.message);
                            });
                        }
                    })
                    .catch(error => {
                        console.error('Erro ao obter informações do membro do chat:', error.message);
                    });
            } else {
                bot.sendMessage(groupId, 'Nenhum comando personalizado foi criado ainda');
            }
            break;
        default:
            const command = data.command.replace('action_', '');
            if (customCommands[groupId] && customCommands[groupId][command]) {
                bot.getChatMember(groupId, user_callbackId)
                    .then(chatMember => {
                        const memberStatus = chatMember.status;
                        if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
                            let username = '';
                            if (chatMember.user.username) {
                                username = '@' + chatMember.user.username;
                            } else if (chatMember.user.first_name) {
                                username = `${chatMember.user.first_name} (ID: ${chatMember.user.id.toString()})`;
                            }
                            bot.sendMessage(groupId, `${customCommands[groupId][command].text}\n\nSolicitado por: ${username}`, { parse_mode: 'HTML' }).then(sentMessage => {
                                const messageId = sentMessage.message_id;
                                const delaySeconds = 90;
                                setTimeout(() => {
                                    bot.deleteMessage(groupId, messageId)
                                        .catch(error => {
                                            console.error('Erro ao excluir mensagem:', error.message);
                                        });
                                }, delaySeconds * 1000);
                            }).catch(error => {
                                if (error.message.includes(`can't parse entities: Can't find end tag corresponding to start tag code`)) {
                                    bot.sendMessage(groupId, `Erro: Alguma tag foi utilizada de forma incorreta neste comando.`);
                                } else {
                                    bot.sendMessage(groupId, `Erro: ${error.message}`);
                                }
                            });
                        }
                    })
                    .catch(error => {
                        console.error('Erro ao obter informações do membro do chat:', error.message);
                    });
            } else {
                bot.sendMessage(groupId, 'Este comando personalizado não está disponível.');
            }
            break;
    }
});
bot.on('new_chat_members', (msg) => {
    const chatId = msg.chat.id;
    const newMembers = msg.new_chat_members;

    if (!isChatAllowed(chatId)) {
        bot.sendMessage(chatId, `O bot não está autorizado a ser usado neste grupo.`);
        return;
    }

    newMembers.forEach((member) => {
        const welcomeMessage = welcomeMessages[Math.floor(Math.random() * welcomeMessages.length)];

        let username = '';
        if (member.username) {
            username = '@' + member.username;
        } else if (member.first_name) {
            username = `${member.first_name} (ID: ${member.id.toString()})`;
        }

        const text = `Bem-vindo(a) ${username}\n${welcomeMessage}\n\nAperte no botão a baixo para ver as opções do grupo.`;
        const keyboard = {
            inline_keyboard: [
                [
                    {
                        text: 'menu',
                        callback_data: JSON.stringify({ command: 'callback_menu', userId: member.id.toString() })
                    }
                ]
            ]
        };

        bot.sendMessage(chatId, text, { reply_markup: JSON.stringify(keyboard) })
            .then(sentMessage => {
                const messageId = sentMessage.message_id;
                const delaySeconds = 90;
                setTimeout(() => {
                    bot.deleteMessage(chatId, messageId)
                        .catch(error => {
                            console.error('Erro ao excluir mensagem:', error.message);
                        });
                }, delaySeconds * 1000);
            }).catch(error => {
                console.error('Erro ao enviar mensagem:', error.message);
            });
    });
});
bot.on('left_chat_member', (msg) => {
    const chatId = msg.chat.id;
    const userName = msg.left_chat_member.username;
    const firstName = msg.left_chat_member.first_name;
    const lastName = msg.left_chat_member.last_name || '';
    const message = `O usuário ${firstName} ${lastName} (@${userName}) saiu do grupo.`;

    if (!isChatAllowed(chatId)) {
        bot.sendMessage(chatId, `O bot não está autorizado a ser usado neste grupo.`);
        return;
    }

    bot.sendMessage(chatId, message)
        .then(sentMessage => {
            const messageId = sentMessage.message_id;
            const delaySeconds = 60;
            setTimeout(() => {
                bot.deleteMessage(chatId, messageId)
                    .catch(error => {
                        console.error('Erro ao excluir mensagem:', error.message);
                    });
            }, delaySeconds * 1000);
        }).catch(error => {
            console.error('Erro ao enviar mensagem:', error.message);
        });
});
bot.on('polling_error', (error) => {
    console.error(error.message);
});

function checkAdminPermission(msg, callback) {
    const chatId = msg.chat.id;
    bot.getChatMember(chatId, msg.from.id).then((chatMember) => {
        if (chatMember.status === 'administrator' || chatMember.status === 'creator') {
            callback();
        } else {
            bot.answerCallbackQuery(chatId, 'Você não tem permissão para usar este comando.');
        }
    });
}
function checkCreatorPermission(msg, callback) {
    const chatId = msg.chat.id;
    bot.getChatMember(chatId, msg.from.id).then((chatMember) => {
        if (chatMember.status === 'creator') {
            callback();
        } else {
            bot.answerCallbackQuery(chatId, 'Você não tem permissão para usar este comando.');
        }
    });
}
function sendMessageWithUndoButton(chatId, text, undoCallbackData) {
    const keyboard = {
        inline_keyboard: [
            [
                {
                    text: 'Desfazer',
                    callback_data: undoCallbackData
                }
            ]
        ]
    };

    bot.sendMessage(chatId, text, { reply_markup: JSON.stringify(keyboard) });
}
function createMenuButtons(groupId) {
    let commands = customCommands[groupId] ? Object.entries(customCommands[groupId]) : [];

    commands.sort((a, b) => a[1].order - b[1].order);

    const buttons = commands.map(command => ({ text: command[0], callback_data: JSON.stringify({ command: `action_${command[0]}` }) }));
    const buttonsInRows = [];
    for (let i = 0; i < buttons.length; i += 2) {
        buttonsInRows.push(buttons.slice(i, i + 2));
    }
    return {
        reply_markup: {
            inline_keyboard: buttonsInRows
        }
    };
}
function isChatAllowed(chatId) {
    return allowedGroupIds.includes(chatId.toString());
}
function saveWarnings() {
    try {
        fs.writeFileSync(jsonFilePathWarnings, JSON.stringify(warnings, null, 4));
        console.log('Warnings salvos com sucesso.');
    } catch (error) {
        console.error('Erro ao salvar os warnings no arquivo JSON:', error);
    }
}