# -*- coding: utf-8 -*-
"""SmartPaper R3-Free UI: Streamlit is an observer, never the paper executor."""
import hashlib
import json
import logging
import os
import re
import secrets
import shutil
import signal
import subprocess
import sys
import time
from datetime import datetime, timezone
from pathlib import Path

import streamlit as st
import streamlit.components.v1 as components

from config import APP_CONFIG
from managed_auth import (
    cancel_generation_task,
    generation_task_status,
    recover_generation_task,
    require_alipay_login,
    render_logged_in_account,
    render_payment_purchase,
    start_generation_task,
)
from i18n import (
    LANGUAGE_OPTIONS, get_amj_csv_template, get_asq_txt_template,
    get_output_suffix, get_target_flag, get_target_language, tr,
)

st.set_page_config(
    page_title="Article Agent",
    page_icon="📊",
    layout="wide",
    initial_sidebar_state="collapsed",
)

WORKSPACE_DIR = APP_CONFIG.get("workspace_dir", ".workspace")
os.makedirs(WORKSPACE_DIR, exist_ok=True)
os.environ["STREAMLIT_SERVER_ENABLE_CORS"] = "false"
os.environ["STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION"] = "false"

WECHAT_BLOCKER_JS = """<script>try{var ua=navigator.userAgent.toLowerCase();if(ua.indexOf('micromessenger')!==-1){var parentDoc=window.parent.document;if(!parentDoc.getElementById('wx-blocker')){var overlay=parentDoc.createElement('div');overlay.id='wx-blocker';overlay.style.cssText='position:fixed;top:0;left:0;width:100vw;height:100vh;background:#1a365d;z-index:9999999;color:white;display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center;font-family:sans-serif;padding:30px;box-sizing:border-box;';overlay.innerHTML='<h2 style="font-size:26px;margin-bottom:15px;font-weight:bold;">环境受限 / Restricted</h2><p style="font-size:18px;line-height:1.6;color:#e2e8f0;max-width:100%;">为了保障最终双语 ZIP 压缩包正常下载，<b>本系统禁止在微信内直接运行</b>。<br><br>👉 <b>请点击右上角 [···] 菜单，选择“在浏览器打开” (Open in Browser)</b></p>';parentDoc.body.appendChild(overlay);}}}catch(e){}</script>"""
components.html(WECHAT_BLOCKER_JS, height=0, width=0)


def inject_file_uploader_i18n(language: str) -> None:
    """Localize Streamlit uploaders without modifying their React structure."""
    payload = {
        "browse": tr(language, "browse_files"),
        "uploaders": [
            {
                "title": tr(language, "drop_docs"),
                "limit": tr(language, "limit_docs"),
            },
            {
                "title": tr(language, "drop_data"),
                "limit": tr(language, "limit_data"),
            },
            {
                "title": tr(language, "drop_docs"),
                "limit": tr(language, "limit_docs"),
            },
            {
                "title": tr(language, "drop_interviews"),
                "limit": tr(language, "limit_interviews"),
            },
        ],
    }

    script = f"""
    <script>
    (() => {{
      const payload = {json.dumps(payload, ensure_ascii=False)};
      const parentDocument = window.parent.document;

      function leafTextElements(root) {{
        return Array.from(
          root.querySelectorAll("p, span, small, div")
        ).filter((element) => (
          element.children.length === 0 &&
          element.textContent.trim().length > 0
        ));
      }}

      function replaceTextSafely(element, value) {{
        if (element && element.textContent.trim() !== value) {{
          element.textContent = value;
        }}
      }}

      function applyUploaderTranslations() {{
        const zones = parentDocument.querySelectorAll(
          '[data-testid="stFileUploaderDropzone"]'
        );

        zones.forEach((zone, index) => {{
          const config = payload.uploaders[index];
          if (!config) return;

          const instructions = zone.querySelector(
            '[data-testid="stFileUploaderDropzoneInstructions"]'
          );

          if (instructions) {{
            const leaves = leafTextElements(instructions);
            replaceTextSafely(leaves[0], config.title);
            replaceTextSafely(leaves[1], config.limit);
          }}

          const button = zone.querySelector("button");
          if (button) {{
            const buttonLeaves = leafTextElements(button);
            const textTarget = buttonLeaves[buttonLeaves.length - 1];

            replaceTextSafely(textTarget, payload.browse);
            button.setAttribute("aria-label", payload.browse);
            button.setAttribute("title", payload.browse);
          }}
        }});
      }}

      [0, 100, 300, 700, 1400, 2500].forEach((delay) => {{
        window.setTimeout(applyUploaderTranslations, delay);
      }});
    }})();
    </script>
    """

    components.html(script, height=0, width=0)



def inject_wechat_browser_notice() -> None:
    """Warn immediately when SmartPaper is opened inside WeChat or WeCom."""
    script = """
    <script>
    (() => {
      const parentWindow = window.parent;
      const parentDocument = parentWindow.document;
      const userAgent = String(
        parentWindow.navigator.userAgent || navigator.userAgent || ""
      );

      const isWechat =
        /MicroMessenger|WeChat|wxwork/i.test(userAgent);

      const noticeId = "smartpaper-wechat-browser-notice";
      const existingNotice = parentDocument.getElementById(noticeId);

      if (!isWechat) {
        if (existingNotice) existingNotice.remove();
        return;
      }

      if (existingNotice) return;

      const overlay = parentDocument.createElement("div");
      overlay.id = noticeId;
      overlay.style.cssText = [
        "position:fixed",
        "inset:0",
        "z-index:2147483647",
        "display:flex",
        "align-items:center",
        "justify-content:center",
        "padding:24px",
        "background:rgba(8,12,20,.96)",
        "box-sizing:border-box"
      ].join(";");

      const card = parentDocument.createElement("div");
      card.style.cssText = [
        "width:min(620px,100%)",
        "padding:30px",
        "border:1px solid rgba(148,163,184,.35)",
        "border-radius:18px",
        "background:#111827",
        "color:#f8fafc",
        "font-family:Arial,'Microsoft YaHei','PingFang SC',sans-serif",
        "line-height:1.7",
        "box-shadow:0 20px 50px rgba(0,0,0,.38)"
      ].join(";");

      const title = parentDocument.createElement("h2");
      title.textContent = "请在浏览器中打开 / Open in Browser";
      title.style.cssText =
        "margin:0 0 14px;font-size:24px;color:#ffffff;";

      const chinese = parentDocument.createElement("p");
      chinese.textContent =
        "微信内置页面可能无法正常完成登录和文件操作。请点击右上角“…”并选择“在浏览器打开”。";
      chinese.style.cssText = "margin:0 0 12px;font-size:16px;";

      const english = parentDocument.createElement("p");
      english.textContent =
        "The WeChat in-app page may not complete sign-in or file operations correctly. Tap “…” in the top-right corner and choose “Open in Browser.”";
      english.style.cssText =
        "margin:0 0 20px;font-size:15px;color:#cbd5e1;";

      const copyButton = parentDocument.createElement("button");
      copyButton.type = "button";
      copyButton.textContent = "复制网址 / Copy link";
      copyButton.style.cssText = [
        "width:100%",
        "padding:12px 16px",
        "border:0",
        "border-radius:10px",
        "background:#1677ff",
        "color:#ffffff",
        "font-size:16px",
        "font-weight:700",
        "cursor:pointer"
      ].join(";");

      copyButton.addEventListener("click", async () => {
        const url = parentWindow.location.href;

        try {
          await parentWindow.navigator.clipboard.writeText(url);
          copyButton.textContent = "已复制 / Copied";
        } catch (_) {
          const textarea = parentDocument.createElement("textarea");
          textarea.value = url;
          textarea.style.position = "fixed";
          textarea.style.opacity = "0";
          parentDocument.body.appendChild(textarea);
          textarea.focus();
          textarea.select();
          parentDocument.execCommand("copy");
          textarea.remove();
          copyButton.textContent = "已复制 / Copied";
        }

        parentWindow.setTimeout(() => {
          copyButton.textContent = "复制网址 / Copy link";
        }, 1800);
      });

      card.appendChild(title);
      card.appendChild(chinese);
      card.appendChild(english);
      card.appendChild(copyButton);
      overlay.appendChild(card);
      parentDocument.body.appendChild(overlay);
    })();
    </script>
    """

    components.html(script, height=0, width=0)



for key, default in {
    "is_running": False,
    "zip_buffer": None,
    "zip_filename": "",
    "run_mode": "amj",
    "sp_generation_task": None,
    "sp_pending_launch": None,
    "sp_pending_resume_task_id": "",
    "sp_pending_cancel_task_id": "",
    "sp_payment_required": False,
    "sp_terminal_notice": None,
    "sp_task_recovery_initialized": False,
    "sp_last_ui_task_status": "",
}.items():
    if key not in st.session_state:
        st.session_state[key] = default


def _safe_key(value: str) -> str:
    cleaned = re.sub(r"[^A-Za-z0-9_.-]", "_", str(value or "").strip())
    return cleaned[:100] or "anonymous"


def _new_generation_idempotency_key() -> str:
    return f"gen_{int(time.time() * 1000)}_{secrets.token_urlsafe(18)}"


def _atomic_json(path: Path, value: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_suffix(path.suffix + ".tmp")
    temporary.write_text(json.dumps(value, ensure_ascii=False), encoding="utf-8")
    os.replace(temporary, path)


def _canonical_request_hash(value: dict) -> str:
    material = dict(value or {})
    material.pop("request_hash", None)
    encoded = json.dumps(material, sort_keys=True, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
    return hashlib.sha256(encoded).hexdigest()


def _task_dir(task_id: str) -> Path:
    return Path(_user_workspace) / "tasks" / _safe_key(task_id)


def _task_output_path(task: dict) -> Path | None:
    task_id = str(task.get("task_id") or "").strip()
    filename = os.path.basename(str(task.get("output_filename") or "").strip())
    if not task_id or not filename:
        return None
    return _task_dir(task_id) / "outputs" / filename


def _save_uploaded(items, inputs_dir: Path, prefix: str) -> list[str]:
    saved = []
    for index, item in enumerate(items or []):
        if item is None:
            continue
        original = os.path.basename(str(getattr(item, "name", f"input_{index}")))
        safe_name = re.sub(r"[^A-Za-z0-9_.-]", "_", original)[:140] or f"input_{index}"
        filename = f"{prefix}_{index:02d}_{safe_name}"
        path = inputs_dir / filename
        data = item.getvalue() if hasattr(item, "getvalue") else item.read()
        path.write_bytes(bytes(data or b""))
        saved.append(str(Path("inputs") / filename))
        try:
            item.seek(0)
        except Exception:
            pass
    return saved


def _persist_task_request(task: dict, mode: str, lang_code: str) -> dict:
    task_id = str(task.get("task_id") or "").strip()
    numeric_id = (st.session_state.get("sp_user") or {}).get("numeric_id")
    if not task_id or not isinstance(numeric_id, int) or numeric_id <= 0:
        raise RuntimeError("task_identity_missing")
    task_dir = _task_dir(task_id)
    inputs_dir = task_dir / "inputs"
    inputs_dir.mkdir(parents=True, exist_ok=True)

    if mode == "amj":
        refs = _save_uploaded(st.session_state.get("up_amj_ref") or [], inputs_dir, "ref")
        data = _save_uploaded([st.session_state.get("up_amj_data")], inputs_dir, "data")
        interviews = []
    else:
        refs = _save_uploaded(st.session_state.get("up_asq_ref") or [], inputs_dir, "ref")
        data = []
        interviews = _save_uploaded([st.session_state.get("up_asq_data")], inputs_dir, "interview")

    request_data = {
        "task_id": task_id,
        "user_id": numeric_id,
        "mode": mode,
        "interface_language": lang_code,
        "target_lang": get_target_language(lang_code),
        "output_suffix": get_output_suffix(lang_code),
        "topic": str(st.session_state.get("sp_topic") or DEFAULT_TOPIC),
        "keywords": str(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS),
        "target_words": int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]),
        "reference_files": refs,
        "data_files": data,
        "interview_files": interviews,
        "created_at": datetime.now(timezone.utc).isoformat(),
    }
    request_data["request_hash"] = _canonical_request_hash(request_data)
    _atomic_json(task_dir / "request.json", request_data)
    return request_data


def _pid_alive(pid: int) -> bool:
    if not isinstance(pid, int) or pid <= 0:
        return False
    try:
        os.kill(pid, 0)
        return True
    except OSError:
        return False


def _pid_is_task_executor(pid: int, task_id: str, task_dir: Path) -> bool:
    """Best-effort Linux identity check before trusting/killing a launch PID.

    Hugging Face Spaces run on Linux. A stale PID can be reused, so a bare
    ``os.kill(pid, 0)`` is never enough to identify our executor.
    """
    if not _pid_alive(pid):
        return False
    try:
        raw = (Path("/proc") / str(pid) / "cmdline").read_bytes()
        command = raw.replace(b"\x00", b" ").decode("utf-8", errors="ignore")
    except Exception:
        return False
    return (
        "task_executor.py" in command
        and f"--task-id {task_id}" in command
        and str(task_dir.resolve()) in command
    )


def _launch_executor(task_id: str, *, force: bool = False) -> int:
    """Launch only after a PID-bound claim handshake is observed.

    ``subprocess.Popen`` proves only that the OS accepted a child process. R3.1
    waits until that exact child has successfully claimed the D1 task and
    written ``executor_claim.json``. A child that exits/import-fails before
    claim is therefore never reported as a running executor.
    """
    task_dir = _task_dir(task_id)
    request_path = task_dir / "request.json"
    if not request_path.is_file():
        raise RuntimeError("task_request_manifest_missing")
    request_data = json.loads(request_path.read_text(encoding="utf-8"))
    numeric_id = int(request_data.get("user_id") or 0)
    request_hash = str(request_data.get("request_hash") or "").strip()
    if numeric_id <= 0 or not request_hash:
        raise RuntimeError("task_request_identity_invalid")

    launch_marker_path = task_dir / "executor_launch.json"
    claim_marker_path = task_dir / "executor_claim.json"
    if launch_marker_path.is_file():
        try:
            marker = json.loads(launch_marker_path.read_text(encoding="utf-8"))
            pid = int(marker.get("pid") or 0)
            verified_executor = _pid_is_task_executor(pid, task_id, task_dir)
            if verified_executor and not force:
                claim_marker = {}
                if claim_marker_path.is_file():
                    try:
                        claim_marker = json.loads(claim_marker_path.read_text(encoding="utf-8"))
                    except Exception:
                        claim_marker = {}
                if int(claim_marker.get("pid") or 0) == pid and int(claim_marker.get("execution_epoch") or 0) > 0:
                    return pid
            if verified_executor and force:
                try:
                    os.kill(pid, signal.SIGTERM)
                except OSError:
                    pass
        except Exception:
            pass

    # A stale claim file must never satisfy a new launch/resume handshake.
    try:
        claim_marker_path.unlink(missing_ok=True)
    except TypeError:
        if claim_marker_path.exists():
            claim_marker_path.unlink()

    log_path = task_dir / "executor.log"
    task_dir.mkdir(parents=True, exist_ok=True)
    command = [
        sys.executable,
        str(Path(__file__).resolve().parent / "task_executor.py"),
        "--task-dir", str(task_dir.resolve()),
        "--task-id", str(task_id),
        "--user-id", str(numeric_id),
    ]
    executor_env = os.environ.copy()
    executor_env["SMARTPAPER_EXECUTOR_LOG_PATH"] = str(log_path.resolve())
    process = subprocess.Popen(
        command,
        cwd=str(Path(__file__).resolve().parent),
        stdin=subprocess.DEVNULL,
        # Inherit stdout/stderr so executor bootstrap/errors are visible in HF
        # Container Logs; task_executor also writes the same log to executor.log.
        close_fds=True,
        start_new_session=True,
        env=executor_env,
    )
    _atomic_json(launch_marker_path, {"pid": process.pid, "launched_at": datetime.now(timezone.utc).isoformat()})
    logging.info("[SP_UI] executor_spawned task_id=%s pid=%s", task_id, process.pid)

    timeout_seconds = float(APP_CONFIG.get("executor_bootstrap_timeout_seconds", 20))
    poll_seconds = max(0.05, float(APP_CONFIG.get("executor_bootstrap_poll_ms", 100)) / 1000.0)
    deadline = time.monotonic() + timeout_seconds
    while time.monotonic() < deadline:
        if claim_marker_path.is_file():
            try:
                claim_marker = json.loads(claim_marker_path.read_text(encoding="utf-8"))
            except Exception:
                claim_marker = {}
            if (
                int(claim_marker.get("pid") or 0) == int(process.pid)
                and str(claim_marker.get("task_id") or "") == str(task_id)
                and str(claim_marker.get("request_hash") or "") == request_hash
                and int(claim_marker.get("execution_epoch") or 0) > 0
                and str(claim_marker.get("executor_instance_id") or "").strip()
            ):
                logging.info(
                    "[SP_UI] executor_claim_confirmed task_id=%s pid=%s epoch=%s",
                    task_id, process.pid, claim_marker.get("execution_epoch"),
                )
                return int(process.pid)
        return_code = process.poll()
        if return_code is not None:
            logging.error("[SP_UI] executor_bootstrap_exit task_id=%s pid=%s rc=%s", task_id, process.pid, return_code)
            raise RuntimeError(f"executor_bootstrap_failed_exit_{return_code}")
        time.sleep(poll_seconds)

    try:
        process.terminate()
    except Exception:
        pass
    logging.error("[SP_UI] executor_claim_timeout task_id=%s pid=%s", task_id, process.pid)
    raise RuntimeError("executor_claim_timeout")


def _process_pending_cancel() -> None:
    task_id = str(st.session_state.get("sp_pending_cancel_task_id") or "").strip()
    if not task_id:
        return
    result = cancel_generation_task(task_id)
    if result.get("cancelled"):
        shutil.rmtree(_task_dir(task_id), ignore_errors=True)
    st.session_state["sp_pending_cancel_task_id"] = ""
    st.session_state["sp_generation_task"] = dict(result.get("task") or {}) or None
    st.rerun()


def _process_pending_resume() -> None:
    task_id = str(st.session_state.get("sp_pending_resume_task_id") or "").strip()
    if not task_id:
        return
    if not (_task_dir(task_id) / "request.json").is_file():
        st.session_state["sp_pending_resume_task_id"] = ""
        st.session_state["sp_pending_cancel_task_id"] = task_id
        st.session_state["sp_terminal_notice"] = {
            "kind": "error",
            "message": "Local checkpoint/request files are unavailable after runtime replacement; the reserved quota will be released.",
        }
        st.rerun()
    _launch_executor(task_id, force=True)
    st.session_state["sp_pending_resume_task_id"] = ""
    st.rerun()


def _process_pending_launch(lang_code: str) -> None:
    pending = st.session_state.get("sp_pending_launch")
    if not isinstance(pending, dict):
        return
    mode = str(pending.get("mode") or "").strip().lower()
    idempotency_key = str(pending.get("idempotency_key") or "").strip()
    try:
        response = start_generation_task(
            idempotency_key=idempotency_key,
            mode=mode,
            interface_language=lang_code,
            target_words=int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]),
        )
    except Exception as exc:
        st.session_state["sp_pending_launch"] = None
        raw = str(exc or "")
        if "payment_required" in raw:
            st.session_state["sp_payment_required"] = True
            st.error(tr(lang_code, "quota_exhausted"))
            render_payment_purchase(lang_code)
        else:
            st.error(raw)
        return
    task = dict(response.get("task") or {})
    task_id = str(task.get("task_id") or "").strip()
    if not task_id:
        st.session_state["sp_pending_launch"] = None
        st.error("task_start_missing_task_id")
        return
    st.session_state["sp_generation_task"] = task
    st.session_state["sp_last_ui_task_status"] = str(task.get("status") or "")
    try:
        request_path = _task_dir(task_id) / "request.json"
        if not request_path.is_file():
            _persist_task_request(task, mode, lang_code)
        _launch_executor(task_id)
    except Exception as exc:
        st.session_state["sp_pending_launch"] = None
        st.session_state["sp_pending_cancel_task_id"] = task_id
        st.session_state["sp_terminal_notice"] = {"kind": "error", "message": str(exc)[:800]}
        st.rerun()
    st.session_state["sp_pending_launch"] = None
    st.session_state["sp_payment_required"] = False
    st.rerun()


inject_wechat_browser_notice()

DEFAULT_TOPIC = "Generative Artificial Intelligence in Ubiquitous Learning: Evaluating a Chatbot-based Recommendation Engine for Personalized and Context-aware Education"
DEFAULT_KEYWORDS = "Ubiquitous computing; Context awareness; Deep learning; Personalized educational; Educational technologies; HCI; Recommendation system; LLMs; Generative AI; ChatGPT; Prompting engineering; Few-shot prompting"

def _current_language_code() -> str:
    choice = st.session_state.get("interface_language_choice")
    return LANGUAGE_OPTIONS.get(choice, "zh")


authenticated_user = require_alipay_login(_current_language_code())
if not bool(st.session_state.get("sp_task_recovery_initialized")):
    recover_generation_task()
    st.session_state["sp_task_recovery_initialized"] = True
_user_workspace = os.path.join(WORKSPACE_DIR, "users", _safe_key(authenticated_user.get("id")))
os.makedirs(_user_workspace, exist_ok=True)


def render_workspace_controls(user):
    top_toolbar = st.container()
    with top_toolbar:
        language_col, account_col = st.columns([5.4, 4.6])
        with language_col:
            lang_choice = st.radio(
                "Language", list(LANGUAGE_OPTIONS.keys()), index=0, horizontal=True,
                label_visibility="collapsed", key="interface_language_choice",
            )
        lang_code = LANGUAGE_OPTIONS[lang_choice]
        st.session_state["sp_lang_code"] = lang_code
        st.session_state["sp_target_lang"] = get_target_language(lang_code)
        st.session_state["sp_output_suffix"] = get_output_suffix(lang_code)
        st.session_state["sp_target_flag"] = get_target_flag(lang_code)
        with account_col:
            render_logged_in_account(lang_code, user)

    task = st.session_state.get("sp_generation_task") or {}
    task_status = str(task.get("status") or "")
    active = task_status in {"created", "running", "resumable", "cancelling"}
    st.session_state["is_running"] = active

    st.markdown(f"<div class='main-title'><h2>{tr(lang_code, 'title')}</h2></div>", unsafe_allow_html=True)

    if task_status == "resumable":
        st.warning(tr(lang_code, "checkpoint_warning"))
        colA, colB = st.columns([1, 1])
        if colA.button(tr(lang_code, "resume"), key="resume_task"):
            st.session_state["sp_pending_resume_task_id"] = str(task.get("task_id") or "")
            st.rerun()
        if colB.button(tr(lang_code, "clear"), key="clear_task"):
            st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "")
            st.rerun()
        st.markdown("---")

    st.text_input(tr(lang_code, "topic_label"), value=DEFAULT_TOPIC, disabled=active, key="sp_topic")
    st.text_input(tr(lang_code, "keywords_label"), value=DEFAULT_KEYWORDS, disabled=active, key="sp_keywords")
    st.number_input(
        tr(lang_code, "words_label"),
        min_value=int(APP_CONFIG["target_words_min"]),
        max_value=int(APP_CONFIG["target_words_max"]),
        value=int(APP_CONFIG["target_words_default"]),
        step=1000,
        disabled=active,
        key="sp_words",
    )

    tab_amj, tab_asq = st.tabs([tr(lang_code, "tab_amj"), tr(lang_code, "tab_asq")])
    with tab_amj:
        st.markdown(tr(lang_code, "amj_config"))
        st.info(tr(lang_code, "amj_info"))
        st.file_uploader(tr(lang_code, "upload_reference"), type=["pdf", "doc", "docx"], accept_multiple_files=True, key="up_amj_ref", disabled=active)
        st.file_uploader(tr(lang_code, "upload_stats"), type=["csv", "xlsx", "xls"], key="up_amj_data", disabled=active)
        with st.expander(tr(lang_code, "amj_expander")):
            st.markdown(tr(lang_code, "amj_hint"))
            template = get_amj_csv_template(lang_code)
            st.code(template, language="csv")
            st.download_button(label=tr(lang_code, "download_amj_template"), data=template, file_name="AMJ_Data_Template.csv", mime="text/csv", use_container_width=True)
        if st.button(tr(lang_code, "start_amj"), disabled=active, key="btn_amj"):
            st.session_state["run_mode"] = "amj"
            st.session_state["sp_pending_launch"] = {"mode": "amj", "idempotency_key": _new_generation_idempotency_key()}
            st.rerun()

    with tab_asq:
        st.markdown(tr(lang_code, "asq_config"))
        st.info(tr(lang_code, "asq_info"))
        st.file_uploader(tr(lang_code, "upload_reference"), type=["pdf", "doc", "docx"], accept_multiple_files=True, key="up_asq_ref", disabled=active)
        st.file_uploader(tr(lang_code, "upload_interviews"), type=["txt", "pdf", "doc", "docx"], key="up_asq_data", disabled=active)
        with st.expander(tr(lang_code, "asq_expander")):
            st.markdown(tr(lang_code, "asq_hint"))
            template = get_asq_txt_template(lang_code)
            st.code(template, language="text")
            st.download_button(label=tr(lang_code, "download_asq_template"), data=template, file_name="ASQ_Interview_Template.txt", mime="text/plain", use_container_width=True)
        if st.button(tr(lang_code, "start_asq"), disabled=active, key="btn_asq"):
            st.session_state["run_mode"] = "asq"
            st.session_state["sp_pending_launch"] = {"mode": "asq", "idempotency_key": _new_generation_idempotency_key()}
            st.rerun()

    inject_file_uploader_i18n(lang_code)


render_workspace_controls(authenticated_user)
lang_code = str(st.session_state.get("sp_lang_code") or _current_language_code())

_notice = st.session_state.pop("sp_terminal_notice", None)
if isinstance(_notice, dict) and _notice.get("message"):
    (st.error if _notice.get("kind") == "error" else st.warning)(str(_notice.get("message")))

_process_pending_cancel()
_process_pending_resume()
_process_pending_launch(lang_code)

if st.session_state.get("sp_payment_required"):
    render_payment_purchase(lang_code)


def _render_monitor_box(task: dict) -> None:
    status = str(task.get("status") or "")
    node = str(task.get("current_node") or status or "")
    progress = max(0, min(100, int(task.get("progress_pct") or 0)))
    if status in {"created", "running", "resumable", "cancelling"}:
        st.progress(progress, text=f"{progress}% — {node}")
    st.markdown(f"""
    <div class='log-box'>
        <div><b>{tr(lang_code, 'monitor_pipeline')}:</b> {status}</div><div><b>{tr(lang_code, 'monitor_node')}:</b> {node}</div><div><b>{tr(lang_code, 'monitor_log')}:</b> checkpoint {int(task.get('checkpoint_seq') or 0)} · {str(task.get('checkpoint_stage') or '')}</div><hr>
        <div><b>{tr(lang_code, 'monitor_compute')}:</b></div>
        <div style='display: flex; gap: 8px;'>
            <span style='background: #fef3c7; padding: 4px 8px; border-radius: 4px; color: black;'>🧠 DeepSeek: <b>{int(task.get('ds_calls') or 0)}</b></span>
            <span style='background: #dbeafe; padding: 4px 8px; border-radius: 4px; color: black;'>📚 S2: <b>{int(task.get('s2_calls') or 0)}</b></span>
            <span style='background: #d1fae5; padding: 4px 8px; border-radius: 4px; color: black;'>🌐 OpenAlex: <b>{int(task.get('oa_calls') or 0)}</b></span>
        </div>
    </div>
    """, unsafe_allow_html=True)


def _render_task_status_once() -> None:
    task = st.session_state.get("sp_generation_task") or {}
    task_id = str(task.get("task_id") or "").strip()
    if not task_id:
        return
    previous_status = str(st.session_state.get("sp_last_ui_task_status") or str(task.get("status") or ""))
    status = str(task.get("status") or "")
    if status in {"created", "running", "resumable", "cancelling"}:
        try:
            result = generation_task_status(task_id)
            task = dict(result.get("task") or task)
            st.session_state["sp_generation_task"] = task
            status = str(task.get("status") or "")
        except Exception as exc:
            logging.warning("[SP_UI] status_poll_error task_id=%s error=%s", task_id, type(exc).__name__)
    st.session_state["sp_last_ui_task_status"] = status
    _render_monitor_box(task)
    if status == "completed":
        output_path = _task_output_path(task)
        if output_path and output_path.is_file():
            st.success(tr(lang_code, "success"))
            st.download_button(label=tr(lang_code, "download"), data=output_path.read_bytes(), file_name=output_path.name, mime="application/zip")
        else:
            st.warning("The task completed, but the local output file is unavailable after runtime replacement.")
    elif status == "failed":
        st.error(str(task.get("safe_error_detail") or task.get("safe_error_code") or tr(lang_code, "node_error")))
    elif status == "cancelled":
        detail = str(task.get("safe_error_detail") or "")
        if detail:
            st.warning(detail)

    # Only boundary transitions need one full app rerun so static controls pick
    # up resume/terminal state. Running progress never reruns the whole page.
    if previous_status and status != previous_status and status in {"resumable", "completed", "failed", "cancelled"}:
        st.rerun()


if getattr(st, "fragment", None) is not None:
    @st.fragment(run_every=5)
    def _task_monitor_fragment():
        _render_task_status_once()
    _task_monitor_fragment()
else:
    _render_task_status_once()