"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const baileys_1 = __importStar(require("@whiskeysockets/baileys"));
const qrcodeTerminal = __importStar(require("qrcode-terminal"));
const QRCode = __importStar(require("qrcode"));
const express = require("express");
const cors = require("cors");
const helmet_1 = __importDefault(require("helmet"));
const path = require("path");
const fs = require("fs");
const dotenv = require("dotenv");
const multer = require("multer");
dotenv.config();
const PORT = process.env.PORT || 3000;
const TOKEN_SENHA = process.env.TOKEN_SENHA || "@@EQTL2025";
const NODE_ENV = process.env.NODE_ENV || 'development';
let sock = null;
let isConnected = false;
let grupos = [];
let currentQR = null;
let qrExpired = false;
let connectionAttempts = 0;
let isReconnecting = false;
let qrTimestamp = null;
const app = express();
app.use((0, helmet_1.default)());
app.use(cors());
app.use(express.json());
app.use('/public', express.static(path.join(__dirname, '../public')));
const publicDir = path.join(__dirname, '../public');
if (!fs.existsSync(publicDir)) {
    fs.mkdirSync(publicDir, { recursive: true });
}
const uploadsDir = path.join(__dirname, '../uploads');
if (!fs.existsSync(uploadsDir)) {
    fs.mkdirSync(uploadsDir, { recursive: true });
}
const storage = multer.diskStorage({
    destination: (req, file, cb) => {
        cb(null, uploadsDir);
    },
    filename: (req, file, cb) => {
        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
        cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
    }
});
const upload = multer({
    storage: storage,
    limits: {
        fileSize: 10 * 1024 * 1024,
    },
    fileFilter: (req, file, cb) => {
        if (file.mimetype.startsWith('image/')) {
            cb(null, true);
        }
        else {
            cb(new Error('Apenas arquivos de imagem são permitidos!'));
        }
    }
});
function formatarMensagemWhatsApp(texto) {
    if (!texto)
        return '';
    let mensagemFormatada = texto
        .replace(/\\n/g, '\n')
        .replace(/\n/g, '\n');
    return mensagemFormatada;
}
function processarMencoes(texto) {
    if (!texto)
        return { texto: '', mencoes: [] };
    const mencoes = [];
    const regexMencao = /@(\+?55)?(\d{10,11})/g;
    let match;
    while ((match = regexMencao.exec(texto)) !== null) {
        const numeroCompleto = match[0];
        let numeroLimpo = match[2];
        if (!match[1]) {
            if (numeroLimpo.length === 10 && numeroLimpo.startsWith('11')) {
                numeroLimpo = numeroLimpo.substring(0, 2) + '9' + numeroLimpo.substring(2);
            }
        }
        const jidCompleto = `55${numeroLimpo}@s.whatsapp.net`;
        if (!mencoes.includes(jidCompleto)) {
            mencoes.push(jidCompleto);
        }
    }
    return { texto: formatarMensagemWhatsApp(texto), mencoes };
}
const authenticateToken = (req, res, next) => {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];
    if (!token) {
        return res.status(401).json({
            error: 'Token de acesso requerido',
            message: 'Use: Authorization: Bearer [SEU_TOKEN]'
        });
    }
    if (token !== TOKEN_SENHA) {
        return res.status(403).json({
            error: 'Token inválido',
            message: 'Token de acesso não autorizado'
        });
    }
    next();
};
async function limparSessao() {
    try {
        const authDir = './baileys_auth';
        if (fs.existsSync(authDir)) {
            console.log('🧹 Limpando sessão corrompida...');
            const files = fs.readdirSync(authDir);
            for (const file of files) {
                fs.unlinkSync(path.join(authDir, file));
            }
            fs.rmdirSync(authDir);
        }
    }
    catch (error) {
        console.error('❌ Erro ao limpar sessão:', error);
    }
}
async function forcarNovoQR() {
    console.log('🔄 Forçando geração de novo QR Code...');
    if (sock) {
        try {
            sock.end(undefined);
            sock = null;
        }
        catch (error) {
            console.error('Erro ao fechar socket anterior:', error);
        }
    }
    isConnected = false;
    isReconnecting = true;
    currentQR = null;
    qrExpired = false;
    qrTimestamp = null;
    setTimeout(async () => {
        await iniciarWhatsApp();
    }, 2000);
}
async function iniciarWhatsApp() {
    try {
        console.log('🚀 Iniciando conexão WhatsApp...');
        console.log(`📊 Tentativa de conexão: ${++connectionAttempts}`);
        isReconnecting = true;
        const { state, saveCreds } = await (0, baileys_1.useMultiFileAuthState)('./baileys_auth');
        const { version } = await (0, baileys_1.fetchLatestBaileysVersion)();
        sock = (0, baileys_1.default)({
            version,
            auth: state,
            printQRInTerminal: false,
            browser: ['WhatsApp Bot API', 'Chrome', '4.0.0'],
            markOnlineOnConnect: true,
            generateHighQualityLinkPreview: true,
            syncFullHistory: false,
            shouldSyncHistoryMessage: () => false,
            defaultQueryTimeoutMs: 60000,
            connectTimeoutMs: 60000,
        });
        sock.ev.on('creds.update', saveCreds);
        sock.ev.on('messages.upsert', async (m) => {
            if (isReconnecting) {
                console.log('📨 Mensagens recebidas - conexão estável');
                isReconnecting = false;
            }
        });
        sock.ev.on('connection.update', async (update) => {
            const { connection, lastDisconnect, qr } = update;
            if (qr) {
                currentQR = qr;
                qrExpired = false;
                qrTimestamp = new Date();
                isReconnecting = false;
                console.log('📲 Novo QR Code gerado!');
                console.log('🌐 Acesse: http://localhost:' + PORT + '/qr para visualizar');
                qrcodeTerminal.generate(qr, { small: true });
                try {
                    const qrImagePath = path.join(__dirname, '../public/qrcode.png');
                    await QRCode.toFile(qrImagePath, qr, {
                        width: 300,
                        margin: 2,
                        color: {
                            dark: '#000000',
                            light: '#FFFFFF'
                        }
                    });
                    console.log('💾 QR Code salvo como imagem em: /public/qrcode.png');
                }
                catch (qrError) {
                    console.error('❌ Erro ao salvar QR code:', qrError);
                }
                setTimeout(() => {
                    if (currentQR === qr && !isConnected) {
                        qrExpired = true;
                        currentQR = null;
                        console.log('⏰ QR Code expirado. Gerando novo automaticamente...');
                        setTimeout(() => {
                            if (!isConnected) {
                                forcarNovoQR();
                            }
                        }, 2000);
                    }
                }, 45000);
            }
            if (connection === 'close') {
                const statusCode = lastDisconnect?.error?.output?.statusCode;
                const reason = baileys_1.DisconnectReason[statusCode] || statusCode;
                console.log(`❌ Conexão encerrada. Status: ${statusCode} (${reason})`);
                isConnected = false;
                isReconnecting = true;
                const shouldReconnect = statusCode !== baileys_1.DisconnectReason.loggedOut;
                if (statusCode === baileys_1.DisconnectReason.badSession) {
                    console.log('🧹 Sessão corrompida. Limpando e reiniciando...');
                    await limparSessao();
                    setTimeout(() => {
                        iniciarWhatsApp();
                    }, 3000);
                }
                else if (statusCode === baileys_1.DisconnectReason.loggedOut) {
                    console.log('📱 Usuário deslogado. Novo QR será necessário.');
                    currentQR = null;
                    qrExpired = false;
                    await limparSessao();
                    setTimeout(() => {
                        iniciarWhatsApp();
                    }, 3000);
                }
                else if (shouldReconnect) {
                    const delay = Math.min(5000 + (connectionAttempts * 2000), 30000);
                    console.log(`🔄 Reconectando em ${delay / 1000} segundos... (tentativa ${connectionAttempts})`);
                    setTimeout(iniciarWhatsApp, delay);
                }
            }
            if (connection === 'connecting') {
                console.log('🔄 Conectando ao WhatsApp...');
                isConnected = false;
            }
            if (connection === 'open') {
                console.log('✅ WhatsApp conectado com sucesso!');
                isConnected = true;
                isReconnecting = false;
                connectionAttempts = 0;
                currentQR = null;
                qrExpired = false;
                qrTimestamp = null;
                setTimeout(async () => {
                    await buscarGrupos();
                }, 8000);
            }
        });
    }
    catch (error) {
        console.error('❌ Erro ao iniciar WhatsApp:', error);
    }
}
async function buscarGrupos() {
    try {
        if (!sock || !sock.user) {
            console.log('⚠️ Socket não está pronto');
            return;
        }
        console.log('🔍 Buscando grupos...');
        const chats = await sock.groupFetchAllParticipating();
        grupos = Object.values(chats);
        console.log(`📋 ${grupos.length} grupos encontrados:`);
        grupos.forEach((g, i) => {
            console.log(`${i + 1}. ${g.subject} → ${g.id}`);
        });
    }
    catch (error) {
        console.error('❌ Erro ao buscar grupos:', error);
        setTimeout(buscarGrupos, 10000);
    }
}
app.post('/send-message', upload.single('imagem'), authenticateToken, async (req, res) => {
    const MAX_RETRY_TIME = 60000;
    const RETRY_INTERVAL = 2000;
    async function tentarEnviarMensagem(tentativa = 1) {
        const startTime = Date.now();
        while (Date.now() - startTime < MAX_RETRY_TIME) {
            try {
                const { grupo, mensagem, legenda } = req.body;
                const imagemFile = req.file;
                if (!grupo || (!mensagem && !imagemFile)) {
                    return {
                        success: false,
                        error: 'Parâmetros obrigatórios',
                        message: 'Campo "grupo" é obrigatório, e pelo menos "mensagem" ou "imagem" devem ser fornecidos',
                        example: {
                            grupo: "SQL QUERY",
                            mensagem: "Sua mensagem aqui",
                            legenda: "Legenda da imagem (opcional)"
                        }
                    };
                }
                if (!isConnected || !sock) {
                    const tempoDecorrido = Date.now() - startTime;
                    const tentativaAtual = Math.floor(tempoDecorrido / RETRY_INTERVAL) + 1;
                    console.log(`⏳ Tentativa ${tentativaAtual} - WhatsApp não conectado, aguardando... (${Math.floor(tempoDecorrido / 1000)}s)`);
                    if (tempoDecorrido < MAX_RETRY_TIME) {
                        await new Promise(resolve => setTimeout(resolve, RETRY_INTERVAL));
                        continue;
                    }
                    else {
                        return {
                            success: false,
                            error: 'WhatsApp não conectado',
                            message: 'O bot não conseguiu se conectar ao WhatsApp após 1 minuto de tentativas. Tente novamente mais tarde.',
                            tentativas: tentativaAtual,
                            tempoEsgotado: '60 segundos'
                        };
                    }
                }
                console.log(`✅ WhatsApp conectado na tentativa ${Math.floor((Date.now() - startTime) / RETRY_INTERVAL) + 1}`);
                let grupoEncontrado = grupos.find(g => g.subject?.toLowerCase().includes(grupo.toLowerCase()));
                if (!grupoEncontrado) {
                    if (grupos.length === 0) {
                        console.log('🔄 Lista de grupos vazia, tentando buscar novamente...');
                        await buscarGrupos();
                        grupoEncontrado = grupos.find(g => g.subject?.toLowerCase().includes(grupo.toLowerCase()));
                    }
                    if (!grupoEncontrado) {
                        return {
                            success: false,
                            error: 'Grupo não encontrado',
                            message: `Grupo "${grupo}" não foi encontrado`,
                            gruposDisponiveis: grupos.map(g => g.subject),
                            sugestao: grupos.length === 0 ? 'O bot não está em nenhum grupo ou a conexão está instável' : 'Verifique se o nome do grupo está correto'
                        };
                    }
                }
                let resultado = {};
                if (imagemFile) {
                    try {
                        const imagemBuffer = fs.readFileSync(imagemFile.path);
                        let legendaProcessada = '';
                        let mencoesLegenda = [];
                        if (legenda) {
                            const resultadoLegenda = processarMencoes(legenda);
                            legendaProcessada = resultadoLegenda.texto;
                            mencoesLegenda = resultadoLegenda.mencoes;
                        }
                        const imagemMessage = {
                            image: imagemBuffer,
                            fileName: imagemFile.originalname,
                        };
                        if (legendaProcessada) {
                            imagemMessage.caption = legendaProcessada;
                            if (mencoesLegenda.length > 0) {
                                imagemMessage.mentions = mencoesLegenda;
                            }
                        }
                        await sock.sendMessage(grupoEncontrado.id, imagemMessage);
                        resultado.imagemEnviada = {
                            nomeArquivo: imagemFile.originalname,
                            tamanho: imagemFile.size,
                            legenda: legenda || null,
                            mencoes: mencoesLegenda.length > 0 ? mencoesLegenda : null
                        };
                        console.log(`📷 Imagem enviada para: ${grupoEncontrado.subject}`);
                        if (mencoesLegenda.length > 0) {
                            console.log(`👥 Menções na legenda: ${mencoesLegenda.join(', ')}`);
                        }
                        fs.unlinkSync(imagemFile.path);
                    }
                    catch (error) {
                        console.error('❌ Erro ao enviar imagem:', error);
                        if (fs.existsSync(imagemFile.path)) {
                            fs.unlinkSync(imagemFile.path);
                        }
                        throw error;
                    }
                }
                if (mensagem) {
                    const { texto: mensagemFormatada, mencoes } = processarMencoes(mensagem);
                    const messageObj = { text: mensagemFormatada };
                    if (mencoes.length > 0) {
                        messageObj.mentions = mencoes;
                    }
                    await sock.sendMessage(grupoEncontrado.id, messageObj);
                    resultado.mensagemEnviada = mensagemFormatada;
                    resultado.mencoes = mencoes.length > 0 ? mencoes : null;
                    console.log(`✅ Mensagem enviada para: ${grupoEncontrado.subject}`);
                    if (mencoes.length > 0) {
                        console.log(`👥 Menções: ${mencoes.join(', ')}`);
                    }
                }
                return {
                    success: true,
                    message: 'Conteúdo enviado com sucesso',
                    grupo: {
                        nome: grupoEncontrado.subject,
                        id: grupoEncontrado.id
                    },
                    ...resultado,
                    timestamp: new Date().toISOString(),
                    tentativasRealizadas: Math.floor((Date.now() - startTime) / RETRY_INTERVAL) + 1
                };
            }
            catch (error) {
                console.error('❌ Erro ao enviar conteúdo:', error);
                if (req.file && fs.existsSync(req.file.path)) {
                    fs.unlinkSync(req.file.path);
                }
                if (error.message.includes('Connection') || error.message.includes('not connected')) {
                    const tempoDecorrido = Date.now() - startTime;
                    if (tempoDecorrido < MAX_RETRY_TIME) {
                        console.log(`🔄 Erro de conexão, tentando novamente em ${RETRY_INTERVAL / 1000}s...`);
                        await new Promise(resolve => setTimeout(resolve, RETRY_INTERVAL));
                        continue;
                    }
                }
                return {
                    success: false,
                    error: 'Erro interno',
                    message: 'Erro ao enviar conteúdo',
                    details: error.message || error
                };
            }
        }
    }
    try {
        const resultado = await tentarEnviarMensagem();
        if (resultado.success) {
            return res.status(200).json(resultado);
        }
        else {
            const statusCode = resultado.error === 'Grupo não encontrado' ? 404 :
                resultado.error === 'Parâmetros obrigatórios' ? 400 :
                    resultado.error === 'WhatsApp não conectado' ? 503 : 500;
            return res.status(statusCode).json(resultado);
        }
    }
    catch (error) {
        console.error('❌ Erro geral:', error);
        if (req.file && fs.existsSync(req.file.path)) {
            fs.unlinkSync(req.file.path);
        }
        return res.status(500).json({
            success: false,
            error: 'Erro interno',
            message: 'Erro ao processar solicitação',
            details: error.message || error
        });
    }
});
app.get('/groups', authenticateToken, (req, res) => {
    if (!isConnected) {
        return res.status(503).json({
            error: 'WhatsApp não conectado',
            message: 'O bot não está conectado ao WhatsApp'
        });
    }
    return res.status(200).json({
        success: true,
        totalGrupos: grupos.length,
        grupos: grupos.map(g => ({
            nome: g.subject,
            id: g.id,
            participantes: g.participants?.length || 0
        }))
    });
});
app.get('/status', (req, res) => {
    const qrAge = qrTimestamp ? Math.floor((Date.now() - qrTimestamp.getTime()) / 1000) : null;
    return res.status(200).json({
        success: true,
        whatsappConectado: isConnected,
        reconectando: isReconnecting,
        tentativasConexao: connectionAttempts,
        totalGrupos: grupos.length,
        qrCodeDisponivel: !!currentQR && !qrExpired,
        qrCodeExpirado: qrExpired,
        qrIdadeSegundos: qrAge,
        qrGeradoEm: qrTimestamp?.toISOString(),
        timestamp: new Date().toISOString(),
        uptime: process.uptime(),
        versaoNode: process.version,
        memoria: {
            usado: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
            total: Math.round(process.memoryUsage().heapTotal / 1024 / 1024),
            unidade: 'MB'
        }
    });
});
app.get('/qr', (req, res) => {
    if (isConnected) {
        return res.send(`
      <!DOCTYPE html>
      <html>
      <head>
        <title>WhatsApp Bot - Conectado</title>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <style>
          body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; text-align: center; padding: 20px; background: linear-gradient(135deg, #25D366, #128C7E); min-height: 100vh; display: flex; align-items: center; justify-content: center; margin: 0; }
          .container { max-width: 500px; background: white; padding: 40px; border-radius: 20px; box-shadow: 0 10px 30px rgba(0,0,0,0.2); }
          .status { padding: 25px; margin: 20px 0; border-radius: 15px; }
          .connected { background: linear-gradient(135deg, #d4edda, #c8e6c8); color: #155724; border: 2px solid #25D366; }
          .icon { font-size: 4rem; margin-bottom: 10px; }
          button { background: linear-gradient(135deg, #25D366, #128C7E); color: white; border: none; padding: 15px 30px; border-radius: 10px; cursor: pointer; margin: 10px; font-size: 16px; font-weight: 600; transition: transform 0.2s; }
          button:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0,0,0,0.2); }
          .refresh-button { background: linear-gradient(135deg, #007bff, #0056b3); }
          .status-button { background: linear-gradient(135deg, #28a745, #1e7e34); }
          .info { background: #f8f9fa; padding: 15px; border-radius: 10px; margin: 20px 0; border-left: 4px solid #25D366; }
        </style>
        <script>
          setTimeout(() => window.location.reload(), 30000);
        </script>
      </head>
      <body>
        <div class="container">
          <div class="icon">✅</div>
          <h1>WhatsApp Bot Conectado</h1>
          <div class="status connected">
            <h2>Conexão Ativa!</h2>
            <p>O bot está conectado e funcionando normalmente.</p>
            <p><strong>Grupos disponíveis:</strong> ${grupos.length}</p>
          </div>
          <div class="info">
            <p><strong>💡 Dica:</strong> Use a API para enviar mensagens automaticamente!</p>
          </div>
          <button class="refresh-button" onclick="window.location.reload()">🔄 Atualizar</button>
          <button class="status-button" onclick="window.location.href='/status'">📊 Ver Status Completo</button>
          <button onclick="window.location.href='/'">📖 Documentação</button>
          <p style="margin-top: 30px; color: #666; font-size: 14px;">Atualização automática em 30s</p>
        </div>
      </body>
      </html>
    `);
    }
    if (!currentQR || qrExpired) {
        const isReconnectingStatus = isReconnecting ? 'Reconectando...' : 'Aguardando QR Code...';
        const message = qrExpired ? 'O QR code expirou e um novo está sendo gerado.' :
            isReconnecting ? 'Reconectando ao WhatsApp...' :
                'Aguarde enquanto o QR code é gerado.';
        return res.send(`
      <!DOCTYPE html>
      <html>
      <head>
        <title>WhatsApp Bot - ${isReconnectingStatus}</title>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <style>
          body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; text-align: center; padding: 20px; background: linear-gradient(135deg, #ffc107, #ff8c00); min-height: 100vh; display: flex; align-items: center; justify-content: center; margin: 0; }
          .container { max-width: 500px; background: white; padding: 40px; border-radius: 20px; box-shadow: 0 10px 30px rgba(0,0,0,0.2); }
          .status { padding: 25px; margin: 20px 0; border-radius: 15px; }
          .waiting { background: linear-gradient(135deg, #fff3cd, #ffe69c); color: #856404; border: 2px solid #ffc107; }
          .icon { font-size: 4rem; margin-bottom: 10px; animation: pulse 2s infinite; }
          button { background: linear-gradient(135deg, #ffc107, #ff8c00); color: white; border: none; padding: 15px 30px; border-radius: 10px; cursor: pointer; margin: 10px; font-size: 16px; font-weight: 600; transition: transform 0.2s; }
          button:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0,0,0,0.2); }
          .loading { display: inline-block; width: 20px; height: 20px; border: 3px solid #f3f3f3; border-radius: 50%; border-top: 3px solid #ffc107; animation: spin 1s linear infinite; margin-left: 10px; }
          @keyframes pulse { 0%, 100% { transform: scale(1); } 50% { transform: scale(1.1); } }
          @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
        </style>
        <script>
          setTimeout(() => window.location.reload(), 5000);
        </script>
      </head>
      <body>
        <div class="container">
          <div class="icon">${qrExpired ? '⏰' : isReconnecting ? '🔄' : '⏳'}</div>
          <h1>WhatsApp Bot</h1>
          <div class="status waiting">
            <h2>${isReconnectingStatus} <span class="loading"></span></h2>
            <p>${message}</p>
            <p><small>Tentativa ${connectionAttempts} • Aguarde alguns instantes...</small></p>
          </div>
          <button onclick="window.location.reload()">🔄 Atualizar Agora</button>
          <button onclick="window.location.href='/status'">📊 Ver Status</button>
          <button onclick="forcarNovo()" ${isReconnecting ? 'disabled' : ''}>🆕 Forçar Novo QR</button>
          <p style="margin-top: 30px; color: #666; font-size: 14px;">Atualização automática a cada 5 segundos</p>
        </div>
        <script>
          function forcarNovo() {
            if (confirm('Deseja forçar a geração de um novo QR Code? Isso pode interromper uma conexão em andamento.')) {
              fetch('/force-new-qr', {method: 'POST'}).then(() => {
                alert('Novo QR sendo gerado...');
                setTimeout(() => window.location.reload(), 3000);
              });
            }
          }
        </script>
      </body>
      </html>
    `);
    }
    const qrAge = qrTimestamp ? Math.floor((Date.now() - qrTimestamp.getTime()) / 1000) : 0;
    const timeLeft = Math.max(45 - qrAge, 0);
    return res.send(`
    <!DOCTYPE html>
    <html>
    <head>
      <title>WhatsApp Bot - QR Code</title>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <style>
        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; padding: 20px; background: linear-gradient(135deg, #25D366, #128C7E); min-height: 100vh; margin: 0; }
        .container { max-width: 800px; margin: 0 auto; background: white; padding: 30px; border-radius: 20px; box-shadow: 0 10px 30px rgba(0,0,0,0.2); }
        .header { text-align: center; margin-bottom: 30px; }
        .qr-section { display: flex; flex-wrap: wrap; gap: 30px; align-items: center; justify-content: center; }
        .qr-container { text-align: center; }
        .qr-image { max-width: 280px; width: 100%; border: 4px solid #25D366; border-radius: 15px; box-shadow: 0 5px 20px rgba(0,0,0,0.1); transition: transform 0.3s; }
        .qr-image:hover { transform: scale(1.02); }
        .instructions { flex: 1; min-width: 300px; background: #f8f9fa; padding: 25px; border-radius: 15px; border-left: 5px solid #25D366; }
        .steps { text-align: left; }
        .step { margin: 15px 0; padding: 10px; background: white; border-radius: 8px; border-left: 3px solid #25D366; }
        .countdown { font-size: 1.5rem; font-weight: bold; color: #dc3545; margin: 20px 0; text-align: center; }
        .buttons { text-align: center; margin: 30px 0; }
        button { background: linear-gradient(135deg, #25D366, #128C7E); color: white; border: none; padding: 15px 25px; border-radius: 10px; cursor: pointer; margin: 8px; font-size: 16px; font-weight: 600; transition: all 0.3s; }
        button:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0,0,0,0.2); }
        .btn-secondary { background: linear-gradient(135deg, #007bff, #0056b3); }
        .btn-danger { background: linear-gradient(135deg, #dc3545, #c82333); }
        .progress-bar { width: 100%; height: 6px; background: #e9ecef; border-radius: 3px; margin: 10px 0; overflow: hidden; }
        .progress-fill { height: 100%; background: linear-gradient(90deg, #25D366, #128C7E); transition: width 1s ease; }
        @media (max-width: 768px) { .qr-section { flex-direction: column; } .container { padding: 20px; margin: 10px; } }
      </style>
      <script>
        let timeLeft = ${timeLeft};
        function updateCountdown() {
          const countdownEl = document.getElementById('countdown');
          const progressEl = document.getElementById('progress');
          if (countdownEl && progressEl) {
            countdownEl.textContent = timeLeft;
            const progressPercent = (timeLeft / 45) * 100;
            progressEl.style.width = progressPercent + '%';
            
            if (timeLeft <= 10) {
              countdownEl.style.color = '#dc3545';
              countdownEl.style.animation = 'pulse 1s infinite';
            }
            
            timeLeft--;
            if (timeLeft < 0) {
              window.location.reload();
            }
          }
        }
        setInterval(updateCountdown, 1000);
        
        // Auto-refresh se o QR ainda não foi escaneado
        setTimeout(() => {
          if (!document.hidden) window.location.reload();
        }, ${timeLeft * 1000 + 2000});
      </script>
    </head>
    <body>
      <div class="container">
        <div class="header">
          <h1>📱 WhatsApp Bot - Conectar</h1>
          <p>Escaneie o QR Code com seu celular para conectar</p>
        </div>
        
        <div class="qr-section">
          <div class="qr-container">
            <img src="/public/qrcode.png?${Date.now()}" alt="QR Code WhatsApp" class="qr-image" />
            <div class="countdown">⏰ <span id="countdown">${timeLeft}</span>s</div>
            <div class="progress-bar">
              <div class="progress-fill" id="progress" style="width: ${(timeLeft / 45) * 100}%"></div>
            </div>
          </div>
          
          <div class="instructions">
            <h3>� Como conectar:</h3>
            <div class="steps">
              <div class="step">
                <strong>1️⃣ Abra o WhatsApp</strong><br>
                No seu celular, abra o aplicativo WhatsApp
              </div>
              <div class="step">
                <strong>2️⃣ Acesse o menu</strong><br>
                Toque em <strong>Menu</strong> (⋮) > <strong>Aparelhos conectados</strong>
              </div>
              <div class="step">
                <strong>3️⃣ Conectar aparelho</strong><br>
                Toque em <strong>Conectar um aparelho</strong>
              </div>
              <div class="step">
                <strong>4️⃣ Escaneie o QR</strong><br>
                Aponte a câmera para o QR code ao lado
              </div>
            </div>
            <div style="margin-top: 20px; padding: 15px; background: #e7f3ff; border-radius: 8px; border-left: 3px solid #007bff;">
              <strong>💡 Dica:</strong> Mantenha o celular próximo ao QR code para melhor leitura
            </div>
          </div>
        </div>

        <div class="buttons">
          <button onclick="window.location.reload()">🔄 Atualizar QR</button>
          <button class="btn-secondary" onclick="window.location.href='/status'">📊 Ver Status</button>
          <button class="btn-secondary" onclick="window.open('/qr-image', '_blank')">🖼️ QR em Nova Aba</button>
          <button class="btn-danger" onclick="forcarNovo()">🆕 Gerar Novo QR</button>
        </div>
        
        <div style="text-align: center; margin-top: 30px; padding: 20px; background: #f8f9fa; border-radius: 10px; color: #666;">
          <p><strong>ℹ️ Informações:</strong></p>
          <p>QR gerado há ${qrAge} segundos • Tentativa ${connectionAttempts}</p>
          <p>A página será atualizada automaticamente quando o QR expirar</p>
        </div>
      </div>
      
      <script>
        function forcarNovo() {
          if (confirm('Deseja forçar a geração de um novo QR Code?')) {
            fetch('/force-new-qr', {method: 'POST'}).then(() => {
              alert('Novo QR sendo gerado...');
              setTimeout(() => window.location.reload(), 2000);
            }).catch(() => {
              alert('Erro ao forçar novo QR. Tente novamente.');
            });
          }
        }
      </script>
    </body>
    </html>
  `);
});
app.get('/qr-image', (req, res) => {
    const qrImagePath = path.join(__dirname, '../public/qrcode.png');
    if (!fs.existsSync(qrImagePath)) {
        return res.status(404).json({
            error: 'QR Code não encontrado',
            message: 'QR code ainda não foi gerado ou expirou'
        });
    }
    res.sendFile(qrImagePath);
});
app.post('/restart', authenticateToken, async (req, res) => {
    try {
        console.log('🔄 Reiniciando conexão WhatsApp...');
        await forcarNovoQR();
        return res.status(200).json({
            success: true,
            message: 'Reinicialização iniciada',
            timestamp: new Date().toISOString()
        });
    }
    catch (error) {
        return res.status(500).json({
            error: 'Erro ao reiniciar',
            message: error
        });
    }
});
app.post('/force-new-qr', async (req, res) => {
    try {
        console.log('🆕 Forçando geração de novo QR Code via web...');
        await forcarNovoQR();
        return res.status(200).json({
            success: true,
            message: 'Novo QR Code sendo gerado',
            timestamp: new Date().toISOString()
        });
    }
    catch (error) {
        return res.status(500).json({
            success: false,
            error: 'Erro ao gerar novo QR',
            message: error.toString()
        });
    }
});
app.post('/clear-session', authenticateToken, async (req, res) => {
    try {
        console.log('🧹 Limpando sessão completamente...');
        if (sock) {
            sock.end(undefined);
            sock = null;
        }
        await limparSessao();
        isConnected = false;
        isReconnecting = false;
        connectionAttempts = 0;
        currentQR = null;
        qrExpired = false;
        qrTimestamp = null;
        grupos = [];
        setTimeout(() => {
            iniciarWhatsApp();
        }, 3000);
        return res.status(200).json({
            success: true,
            message: 'Sessão limpa e reconexão iniciada',
            timestamp: new Date().toISOString()
        });
    }
    catch (error) {
        return res.status(500).json({
            error: 'Erro ao limpar sessão',
            message: error.toString()
        });
    }
});
app.get('/', (req, res) => {
    res.json({
        message: 'WhatsApp Bot API - Versão Aprimorada',
        version: '2.1.0',
        status: {
            whatsappConectado: isConnected,
            reconectando: isReconnecting,
            tentativasConexao: connectionAttempts,
            qrCodeDisponivel: !!currentQR && !qrExpired,
            qrIdadeSegundos: qrTimestamp ? Math.floor((Date.now() - qrTimestamp.getTime()) / 1000) : null,
            totalGrupos: grupos.length,
            uptime: Math.floor(process.uptime())
        },
        acesso_rapido: {
            qrCode: `http://localhost:${PORT}/qr`,
            status: `http://localhost:${PORT}/status`,
            grupos: `http://localhost:${PORT}/groups`,
            testeInterface: `http://localhost:${PORT}/public/teste.html`
        },
        endpoints: {
            'POST /send-message': {
                description: 'Envia mensagem e/ou imagem para um grupo',
                headers: { 'Authorization': 'Bearer [TOKEN_REQUERIDO]' },
                contentType: 'multipart/form-data ou application/json',
                body: {
                    grupo: 'Nome do grupo',
                    mensagem: 'Texto da mensagem (opcional se enviar imagem)',
                    legenda: 'Legenda da imagem (opcional)',
                    imagem: 'Arquivo de imagem (campo form-data, opcional)'
                },
                retry: 'Tenta por 60 segundos se não conectado',
                formatacao: {
                    negrito: '*texto*',
                    italico: '_texto_',
                    riscado: '~texto~',
                    monoespaco: '```texto```',
                    quebrasLinha: 'Mantidas automaticamente',
                    mencoes: '@5511999999999 (marcar pessoa pelo número)'
                }
            },
            'GET /groups': {
                description: 'Lista todos os grupos disponíveis',
                headers: { 'Authorization': 'Bearer [TOKEN_REQUERIDO]' }
            },
            'GET /status': {
                description: 'Status detalhado da conexão e sistema',
                auth: false,
                info: 'Inclui uptime, memória, tentativas de conexão'
            },
            'GET /qr': {
                description: 'Interface web para visualizar QR Code',
                auth: false,
                features: ['Auto-refresh', 'Responsivo', 'Countdown', 'Instruções detalhadas']
            },
            'GET /qr-image': {
                description: 'Download direto da imagem QR Code',
                auth: false
            },
            'POST /restart': {
                description: 'Reinicia conexão WhatsApp (com auth)',
                headers: { 'Authorization': 'Bearer [TOKEN_REQUERIDO]' }
            },
            'POST /force-new-qr': {
                description: 'Força geração de novo QR Code',
                auth: false,
                note: 'Para uso na interface web'
            },
            'POST /clear-session': {
                description: 'Limpa sessão completamente e reconecta',
                headers: { 'Authorization': 'Bearer [TOKEN_REQUERIDO]' },
                warning: 'Remove todos os dados de autenticação'
            }
        },
        melhorias_v21: [
            '🔄 Reconexão automática inteligente com delay progressivo',
            '📱 Interface QR Code responsiva e moderna',
            '⏰ Countdown visual para expiração do QR',
            '🆕 Botão para forçar novo QR sem reiniciar servidor',
            '📊 Status detalhado com informações do sistema',
            '🧹 Limpeza automática de sessão corrompida',
            '🔁 Auto-refresh inteligente das páginas',
            '💾 Melhor gerenciamento de memória e recursos'
        ],
        dicas_uso: {
            desconectou: 'Acesse /qr para ver o novo QR Code automaticamente',
            qr_expirado: 'A página se atualiza sozinha, mas você pode forçar novo QR',
            problemas_sessao: 'Use /clear-session para limpar tudo e começar do zero',
            monitoramento: 'Use /status para acompanhar a saúde da conexão'
        },
        security: {
            note: 'Endpoints administrativos requerem token de autorização',
            tokenFormat: 'Bearer [SEU_TOKEN]',
            endpoints_publicos: ['/qr', '/qr-image', '/status', '/force-new-qr']
        }
    });
});
console.log('🚀 Iniciando WhatsApp Bot API...');
app.listen(PORT, () => {
    console.log(`🌐 API rodando na porta ${PORT}`);
    console.log(`📝 Documentação: http://localhost:${PORT}`);
    console.log(`🔑 Token configurado: ${TOKEN_SENHA ? '[DEFINIDO]' : '[NÃO DEFINIDO]'}`);
    console.log(`🏗️ Ambiente: ${NODE_ENV}`);
    console.log(`📱 QR Code: http://localhost:${PORT}/qr`);
    iniciarWhatsApp();
});
