(async function() {
    // --- 1. CONFIGURACIÓN Y ESTADO ---
    const wait = (ms) => new Promise(r => setTimeout(r, ms));
    let timerInterval;
    let seconds = 0;

    // --- 2. INTERFAZ DE LOGS (Copiada de tu diseño preferido) ---
    function createLogUI() {
        if (document.getElementById("fb-worker-log")) return;
        const debugBox = document.createElement("div");
        debugBox.id = "fb-worker-log";
        debugBox.style.cssText = `
            position: fixed; bottom: 20px; right: 20px; 
            background: rgba(0,0,0,0.9); color: #00ff00; 
            padding: 20px; z-index: 999999; font-family: 'Consolas', monospace; 
            font-size: 14px; border-radius: 15px; width: 320px;
            border: 2px solid #333; box-shadow: 0 10px 30px rgba(0,0,0,0.5);
        `;
        debugBox.innerHTML = `
            <div style="display:flex; justify-content:space-between; margin-bottom:10px;">
                <b style="color: white">🚀 PUBLICADOR ACTIVO</b>
                <span id="log-timer" style="color: #888;">0s</span>
            </div>
            <div id="log-status" style="margin-bottom: 15px; height: 40px; color: #00ff00;">Iniciando...</div>
            <div style="height: 6px; background: #222; border-radius: 3px; overflow: hidden;">
                <div id="log-progress" style="width: 0%; height: 100%; background: #00ff00; transition: width 0.5s;"></div>
            </div>
        `;
        document.body.appendChild(debugBox);
    }

    function updateLog(msg, progress, color = "#00ff00") {
        const statusEl = document.getElementById("log-status");
        const progressEl = document.getElementById("log-progress");
        if (statusEl) {
            statusEl.innerText = msg;
            statusEl.style.color = color;
        }
        if (progressEl) progressEl.style.width = progress + "%";
        console.log(`[FB-WORKER]: ${msg}`);
    }

    // Busca la función terminar en tu archivo y reemplázala por esta:
    function terminar(status, motivo) {
        updateLog(`Finalizando: ${status}...`, 90, "cyan");
        clearInterval(timerInterval);

        // Pequeño delay para que Facebook no interfiera con el cierre
        setTimeout(() => {
            chrome.runtime.sendMessage({
                type: "PUBLISH_RESULT",
                data: { 
                    status: status, 
                    motivo: motivo, 
                    url: window.location.href 
                }
            }, (response) => {
                if (chrome.runtime.lastError) {
                    console.log("Error enviando resultado:", chrome.runtime.lastError.message);
                }
            });
        }, 1000);
    }

    // --- 3. FUNCIONES DE ACCIÓN (Lógica del script funcional) ---

    async function validarEstadoGrupo() {
        updateLog("🛡️ Validando permisos...", 20);
        const bodyText = document.body.innerText || "";
        const mainEl = document.querySelector('[role="main"]') || document.body;
        const mainText = mainEl.innerText || "";
        const combinedText = (bodyText + " " + mainText).toLowerCase();
        const currentURL = window.location.href;

        // CASO 1: Grupo Pausado (Verificar PRIMERO)
        const esPausado = 
            combinedText.includes("en pausa") ||
            combinedText.includes("pausado") ||
            combinedText.includes("pausada") ||
            combinedText.includes("pausaron") ||
            combinedText.includes("pausó") ||
            combinedText.includes("se ha pausado") ||
            combinedText.includes("se han pausado") ||
            combinedText.includes("se pausó") ||
            combinedText.includes("se pausaron") ||
            combinedText.includes("se puso en pausa") ||
            combinedText.includes("se pusieron en pausa") ||
            combinedText.includes("publicaciones en pausa") ||
            combinedText.includes("publicaciones pausadas") ||
            combinedText.includes("actividad en pausa") ||
            combinedText.includes("actividad pausada") ||
            combinedText.includes("group is paused") ||
            combinedText.includes("group paused") ||
            combinedText.includes("posts are paused") ||
            combinedText.includes("posting is paused") ||
            combinedText.includes("posting paused") ||
            combinedText.includes("activity is paused") ||
            combinedText.includes("activity paused") ||
            combinedText.includes("paused by admin") ||
            combinedText.includes("admin paused");

        if (esPausado) return { valida: false, motivo: "No apto (Grupo Pausado)" };

        // CASO 2: Grupo de Ventas (Marketplace Groups)
        const esVentas = !currentURL.includes('view=group_discussion') && 
                         (bodyText.includes("¿Qué vendes?") || bodyText.includes("What are you selling?"));
        
        // CASO 3: Pendiente de aprobación o Restringido
        const esRestringido = bodyText.includes("pendiente de aprobación") || 
                              bodyText.includes("pending approval") ||
                              bodyText.includes("no tienes permiso") ||
                              bodyText.includes("no longer have permission");

        if (esVentas) return { valida: false, motivo: "Grupo de Ventas (Solo Venta)" };
        if (esRestringido) return { valida: false, motivo: "Restringido/Pendiente" };

        // Verificación Extra: ¿Existe la pestaña Conversación?
        const tabConversacion = Array.from(document.querySelectorAll('a[role="tab"]'))
                                     .find(a => a.innerText.includes("Conversación") || a.innerText.includes("Discussion"));
        
        if (!tabConversacion && !bodyText.includes("Escribe algo")) {
            // Si no hay pestaña de conversación y no vemos el cuadro de texto rápido
            return { valida: false, motivo: "No es un grupo de discusión" };
        }

        return { valida: true, motivo: "OK" };
    }

    async function abrirComposer() {
        updateLog("🔍 Buscando editor...", 30);
        for (let i = 0; i < 20; i++) {
            let boton = Array.from(document.querySelectorAll('[role="button"]'))
                .find(btn => {
                    let txt = btn.innerText?.toLowerCase() || "";
                    return txt.includes("escribe algo") || 
                           txt.includes("crear publicación") || 
                           txt.includes("write something");
                });

            if (boton) {
                updateLog("🎯 Editor encontrado", 40);
                boton.click();
                await wait(3000);
                return true;
            }
            await wait(800);
        }
        return false; 
    }

    async function escribirComoHumano(texto) {
        updateLog("✍️ Buscando campo de texto...", 55);

        if (typeof texto === 'string') {
            texto = texto.replace(/\\n/g, '\n');
        }

        // 🔥 Buscar TODOS los contenteditable visibles
        const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'))
            .filter(el => el.offsetParent !== null); // visibles

        if (!editables.length) {
            updateLog("❌ No hay campos editables", 60, "red");
            return false;
        }

        let campoTexto = null;

        // 🧠 Detectar el correcto (NO el título)
        for (let el of editables) {
            const placeholder = el.getAttribute("data-lexical-editor") 
                || el.innerText 
                || "";

            const aria = el.getAttribute("aria-label") || "";

            if (
                aria.toLowerCase().includes("publicación") ||
                aria.toLowerCase().includes("post") ||
                aria.toLowerCase().includes("algo") ||
                el.innerText === ""
            ) {
                campoTexto = el;
                break;
            }
        }

        // fallback: el último (normalmente es el cuerpo)
        if (!campoTexto) {
            campoTexto = editables[editables.length - 1];
        }

        campoTexto.focus();

        updateLog("✍️ Escribiendo contenido...", 60);

        document.execCommand('selectAll');
        document.execCommand('delete');

        const lineas = texto.split('\n');

        for (let i = 0; i < lineas.length; i++) {
            document.execCommand("insertText", false, lineas[i]);

            if (i < lineas.length - 1) {
                campoTexto.dispatchEvent(new KeyboardEvent("keydown", {
                    key: "Enter",
                    bubbles: true,
                    shiftKey: true
                }));
            }
        }

        campoTexto.dispatchEvent(new InputEvent("input", { bubbles: true }));

        return true;
    }

    async function pegarImagenes(imagenes) {
        if (!imagenes || imagenes.length === 0) {
            updateLog("ℹ️ Sin imágenes", 80);
            return;
        }
        updateLog("🖼️ Pegando imágenes...", 80);

        const elemento = document.activeElement;
        for (let base64 of imagenes) {
            try {
                const response = await fetch(base64);
                const blob = await response.blob();
                const dt = new DataTransfer();
                dt.items.add(new File([blob], "img.png", { type: blob.type }));

                const evento = new ClipboardEvent("paste", {
                    clipboardData: dt,
                    bubbles: true
                });
                elemento.dispatchEvent(evento);
                updateLog("📸 Imagen añadida", 85);
                await wait(3000); 
            } catch (e) {
                updateLog("⚠️ Error en imagen", 80, "orange");
            }
        }
    }

    // --- 4. ORQUESTADOR (Ajustado) ---
async function iniciar() {
    const data = await new Promise(r => chrome.storage.local.get(null, r));
    if (!data.publish_active) return;

    createLogUI();
    timerInterval = setInterval(() => {
        seconds++;
        const t = document.getElementById("log-timer");
        if (t) t.innerText = seconds + "s";
        if (seconds >= 60) {
            updateLog("❌ TIMEOUT", 100, "red");
            terminar("failed", "Timeout 60s");
        }
    }, 1000); // Tu función de timer

    try {
        updateLog("⏳ Esperando carga completa...", 10);
        await wait(5000); // Darle tiempo a FB para renderizar el texto

        // --- NUEVA VALIDACIÓN ---
        const validacion = await validarEstadoGrupo();
        if (!validacion.valida) {
            updateLog(`⚠️ ${validacion.motivo}`, 100, "orange");
            await wait(2000);
            return terminar("skipped", validacion.motivo); // Avisa a la App y salta al siguiente
        }
        // -------------------------

        updateLog("✅ Grupo apto. Continuando...", 25);

        // 1. Abrir Composer
        const abierto = await abrirComposer();
        if (!abierto) return terminar("skipped", "No se halló botón");

        // 2. Escribir
        const escribio = await escribirComoHumano(data.publish_text || "");
        if (!escribio) return terminar("failed", "Fallo al escribir");

        // 3. Imágenes
        await pegarImagenes(data.publish_images);

        // 4. Publicar
        updateLog("🚀 Publicando...", 95);
        await wait(2000);
        
        const postBtn = Array.from(document.querySelectorAll('[role="button"]'))
                             .find(el => el.innerText === "Publicar" || el.innerText === "Post");
        
        if (postBtn && !postBtn.hasAttribute('disabled')) {
            postBtn.click();
            updateLog("✅ ¡PUBLICADO!", 100);
            await wait(4000);
            terminar("success", "OK");
        } else {
            updateLog("❌ Botón bloqueado", 100, "red");
            terminar("failed", "Botón deshabilitado");
        }
        
    } catch (err) {
        updateLog("❌ Error: " + err.message, 100, "red");
        terminar("failed", err.message);
    }
}

    iniciar();
})();