melhore esse código

const { EmbedBuilder, ButtonBuilder, ActionRowBuilder, ButtonStyle } = require("discord.js");
const PaymentProcessor = require('../structures/PaymentProcessor');
const { Application, Payment } = require('../database/models/Models');
const moment = require('moment');
const { handleSharedApplication } = require("../utils/expiredApplicationManager");
const c = require('chalk');
const sendLogs = require("../utils/sendLogs");


async function renewApp(interaction, appId, waitReturn = true, multiplier = 1) {
    return new Promise(async (resolve) => {
        const app = await Application.findOne({ id: appId });
        if (!app) {
            await interaction.editReply({ content: `Não foi possível localizar a aplicação \`${appId}\``, ephemeral: true });
            return resolve(false);
        }

        const email = 'caualara257@gmail.com'; // Supondo que você tenha o email do usuário
        const name = `${interaction.user.username} - ${interaction.user.id}`; // Supondo que você tenha o email do usuário
        const transaction_amount = app.monthlyFee * multiplier; // Valor do pagamento, ajuste conforme necessário
        const days = 30 * multiplier; // Duração da renovação, ajuste conforme necessário
        const description = `Renovação da Aplicação: ${appId} (${days} dias)`;

        let payment = await Payment.findOne({
            customerId: interaction.user.id,
            transaction_amount,
            description,
            status: 'pending'
        });

        const paymentProcessor = new PaymentProcessor();

        if (!payment) {
            let result;
            try {
                result = await paymentProcessor.processPayment(transaction_amount, description, name, email);
                payment = new Payment({
                    payment_id: result.id,
                    transaction_amount,
                    description,
                    customerId: interaction.user.id,
                    email
                });

                await payment.save();
            } catch (error) {
                await interaction.editReply({ content: 'Falha ao processar o pagamento. Por favor, tente novamente.', ephemeral: true });
                console.error('Erro ao processar pagamento:', error);
                return resolve(false);
            }
        }

        if (payment && payment.status === 'pending') {
            const result = await paymentProcessor.getPayment(payment.payment_id);

            if (result && result.attachment) {
                const paymentEmbed = new EmbedBuilder()
                    .setTitle('Renovação da Aplicação')
                    .setDescription('Escaneie o QR Code para realizar o pagamento.')
                    .addFields(
                        { name: "<:n_id:1260915324648423466> Renovando:", value: `${days} dias`, inline: true },
                        { name: "<:n_money:1260915655943655464> Valor:", value: `R$${transaction_amount},00`, inline: true },
                    )
                    .setImage('attachment://qrcode.png')
                    .setColor('#2B2D31');

                const cancelBtn = new ButtonBuilder()
                    .setCustomId('cancelPayment')
                    .setLabel('Cancelar Pagamento')
                    .setStyle(ButtonStyle.Danger)
                    .setEmoji('<:n_negative:1261856702496636958>');

                const copyPasteBtn = new ButtonBuilder()
                    .setCustomId('copyPasteCode')
                    .setLabel('Mostrar Pix Copia e Cola')
                    .setStyle(ButtonStyle.Secondary);

                const paymentMsg = await interaction.editReply({
                    content: '',
                    embeds: [paymentEmbed],
                    files: [result.attachment],
                    components: [new ActionRowBuilder().addComponents(cancelBtn, copyPasteBtn)],
                    fetchReply: true,
                    ephemeral: true,
                });

                let paymentStatus = payment.status;
                const checkInterval = setInterval(async () => {
                    try {
                        paymentStatus = await paymentProcessor.checkPaymentStatus(payment.payment_id);
                        if (paymentStatus == 'approved') {
                            clearInterval(checkInterval);
                            await interaction.editReply({ content: `Pagamento aprovado! Sua aplicação foi renovada por mais ${days} dias`, embeds: [], components: [], files: [] });

                            const payment2 = await Payment.findOne({
                                payment_id: payment.payment_id,
                                status: 'approved'
                            });

                            if (payment2) {
                                return resolve(true, 'renewed application');
                            }

                            payment.status = 'approved';
                            await payment.save();

                            // Atualiza a data de renovação no banco de dados
                            const newNextRenewalTimestamp = moment(app.nextRenewalTimestamp).add(days, 'days').valueOf();
                            await Application.updateOne({ id: appId }, { $set: { nextRenewalTimestamp: newNextRenewalTimestamp, status: 'active', notifiedAfterExpiry: false, lastNotificationTimestamp: 0 } });
                            if (app.avaliableServers?.length >= 1) await handleSharedApplication(app, true)
                            console.log(c.green(`[App-Payments] O usuário '${interaction.user.username}' (${interaction.user.id}) renovou a aplicação '${appId}' por R$${payment.transaction_amount} (${days} dias)`))
                            sendLogs(`<:n_money:1260915655943655464> [App-Payments] O usuário ${interaction.user.toString()} (${interaction.user.id}) renovou a aplicação \`${appId}\` por **R$${payment.transaction_amount}** \`(${days} dias)\``)

                            return resolve(true, 'renewed application');
                        }
                    } catch (error) {
                        console.error('Erro ao verificar status do pagamento:', error);
                    }
                }, 10000); // Verifica o status do pagamento a cada 10 segundos

                setTimeout(async () => {
                    clearInterval(checkInterval);
                    if (paymentStatus !== 'approved') {
                        await paymentProcessor.cancelPayment(payment.payment_id);
                        await interaction.editReply({ content: 'Tempo de pagamento expirado. Por favor, tente novamente.', embeds: [], components: [], files: [] });
                        payment.status = 'expired';
                        await payment.save();
                        return resolve(false, 'expired payment time');
                    }
                }, 1000 * 60 * 25); // Tempo limite de 25 minutos para realizar o pagamento

                const renewCollector = paymentMsg.createMessageComponentCollector({ filter: (m) => m.user.id === interaction.user.id, time: 1000 * 60 * 2 });

                renewCollector.on('collect', async (renewInteraction) => {
                    if (renewInteraction.customId == 'cancelPayment') {
                        try {
                            await paymentProcessor.cancelPayment(payment.payment_id);
                            clearInterval(checkInterval);
                            await renewInteraction.update({ content: 'Pagamento cancelado com sucesso.', embeds: [], components: [], files: [] });
                            payment.status = 'canceled';
                            await payment.save();
                        } catch (error) {
                            await renewInteraction.update({ content: 'Erro ao cancelar pagamento. Por favor, tente novamente.', embeds: [], components: [], files: [] });
                            console.error('Erro ao cancelar pagamento:', error);
                        }
                    } else if (renewInteraction.customId == 'copyPasteCode') {
                        try {
                            await renewInteraction.reply({ content: `${result.pixCopyPasteCode}`, ephemeral: true });
                        } catch (error) {
                            await renewInteraction.reply({ content: 'Erro ao exibir código copia e cola. Por favor, tente novamente.', ephemeral: true });
                            console.error('Erro ao exibir código copia e cola:', error);
                        }
                    }
                });

                if (!waitReturn) return resolve(true, 'payment created');
            } else {
                await interaction.editReply({ content: 'Falha ao gerar o QR Code de pagamento. Por favor, tente novamente.', embeds: [], components: [], ephemeral: true });
                return resolve(false, 'error on create payment');
            }
        } else {
            await interaction.editReply({ content: 'Falha ao encontrar ou criar pagamento. Por favor, tente novamente.', embeds: [], components: [], ephemeral: true });
            return resolve(false, 'error on find or create payment');
        }
    });
}

module.exports = renewApp;