app.py

#!/usr/bin/env python3
"""
BibGuard Gradio web app — minimalist iframe layout.

The right pane embeds the self-contained ``report.html`` produced by
``src/report/html_report.py`` via ``<iframe srcdoc=...>``. This makes the
generated report the single source of truth (per-section filters, full-text
search, dark mode, inline span highlighting all live inside it) and avoids
re-rendering the same content inside Gradio with stale styles.
"""
from __future__ import annotations

import base64
import logging
import os
import tempfile
import time
from pathlib import Path

import gradio as gr

from src.parsers import BibParser, TexParser
from src.fetchers import (
    ArxivFetcher, CrossRefFetcher, SemanticScholarFetcher,
    OpenAlexFetcher, DBLPFetcher,
)
from src.analyzers import MetadataComparator, UsageChecker, DuplicateDetector
from src.report.generator import ReportGenerator, EntryReport
from src.config.yaml_config import (
    BibGuardConfig, BibliographyConfig, SubmissionConfig, OutputConfig,
)
from src.config.workflow import get_default_workflow
from src.checkers import CHECKER_REGISTRY
from src.checkers.retraction_checker import RetractionChecker
from src.checkers.url_checker import URLChecker
from src.utils import http as http_layer
from src.utils.logging_setup import setup as setup_logging, capture_run
from src.utils.validation import validate_bib, validate_tex, format_report
from app_helper import fetch_and_compare_with_workflow

LOG_PATH = setup_logging(os.environ.get("BIBGUARD_LOG", "WARNING"))
logger = logging.getLogger("bibguard.app")
logger.info("BibGuard app starting (log file: %s)", LOG_PATH)

# Configure HTTP layer once at import time.
http_layer.configure(
    contact_email=os.environ.get("BIBGUARD_CONTACT_EMAIL", ""),
    cache_enabled=True,
    cache_ttl_hours=24,
    retry_total=5,
    retry_backoff_factor=1.5,
)


# --------------------------------------------------------------------- presets

PRESETS = {
    "Quick": {
        "check_metadata": False, "check_duplicates": True, "check_usage": True, "check_preprint_ratio": True,
        "url_liveness": False, "retraction": False,
        "submission": {"caption": True, "reference": True, "formatting": True, "equation": True,
                       "ai_artifacts": True, "sentence": True, "consistency": True, "acronym": True,
                       "number": True, "citation_quality": True, "anonymization": True},
    },
    "Standard": {
        "check_metadata": False, "check_duplicates": True, "check_usage": True, "check_preprint_ratio": True,
        "url_liveness": False, "retraction": True,
        "submission": {"caption": True, "reference": True, "formatting": True, "equation": True,
                       "ai_artifacts": True, "sentence": True, "consistency": True, "acronym": True,
                       "number": True, "citation_quality": True, "anonymization": True},
    },
    "Strict": {
        "check_metadata": True, "check_duplicates": True, "check_usage": True, "check_preprint_ratio": True,
        "url_liveness": True, "retraction": True,
        "submission": {"caption": True, "reference": True, "formatting": True, "equation": True,
                       "ai_artifacts": True, "sentence": True, "consistency": True, "acronym": True,
                       "number": True, "citation_quality": True, "anonymization": True},
    },
}


# ----------------------------------------------------------------------- CSS

CUSTOM_CSS = """
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');

* { font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; }

/* Reserve space for the vertical scrollbar so expanding the Advanced
   accordion (or anything else that adds content) doesn't shift the
   layout horizontally. `overflow-y: scroll` on html is the universal
   fallback for browsers without scrollbar-gutter.
   `overflow-x: hidden` on body kills any page-width jitter coming from
   inner elements that briefly overflow during streaming updates. */
html { scrollbar-gutter: stable; overflow-y: scroll; overflow-x: hidden; }
body { overflow-x: hidden; }

.gradio-container {
    max-width: 1400px !important;
    margin: 0 auto !important;
    padding: 0 20px !important;
    box-sizing: border-box !important;
    width: 100% !important;
    overflow-x: hidden !important;
}

/* Header strip */
.bg-header {
    padding: 14px 4px 12px !important;
    border-bottom: 1px solid #e5e7eb;
    margin-bottom: 14px;
}

/* ==================================================================
   Top toolbar — single horizontal row with all primary controls.
   Every primary control has the SAME explicit 56px height. The little
   filename/info chip beneath sits in a fixed 18px slot. The columns
   wrap that into a 78px tall toolbar that's identical across cells.
   ================================================================== */
.bg-toolbar {
    margin-bottom: 14px;
    gap: 10px !important;
    align-items: flex-start !important;
}
.bg-toolbar .gr-form { gap: 0 !important; }
.bg-toolbar .gr-block { border: none !important; box-shadow: none !important; padding: 0 !important; }

/* Common: any direct primary control fills column width */
.bg-toolbar > * { width: 100% !important; }

/* ---- Upload buttons ---- */
.bg-upload-btn,
.bg-upload-btn > .wrap,
.bg-upload-btn > div {
    height: 56px !important;
    min-height: 56px !important;
    max-height: 56px !important;
    width: 100% !important;
}
.bg-upload-btn button {
    height: 56px !important;
    min-height: 56px !important;
    max-height: 56px !important;
    width: 100% !important;
    padding: 0 14px !important;
    font-size: 13px !important;
    font-weight: 500 !important;
    border-radius: 8px !important;
    border: 1px dashed #cbd5e1 !important;
    background: #f8fafc !important;
    color: #334155 !important;
    transition: border 0.15s, background 0.15s !important;
    line-height: 1 !important;
}
.bg-upload-btn button:hover {
    border-color: #2563eb !important;
    background: #eff6ff !important;
    color: #1e3a8a !important;
}

/* ---- Run / Stop button (same column, visibility-swapped) ---- */
.bg-run-btn,
.bg-run-btn > .wrap,
.bg-run-btn > div {
    height: 56px !important;
    min-height: 56px !important;
    max-height: 56px !important;
    width: 100% !important;
}
.bg-run-btn button {
    height: 56px !important;
    min-height: 56px !important;
    max-height: 56px !important;
    width: 100% !important;
    font-weight: 600 !important;
    border-radius: 8px !important;
    font-size: 14px !important;
    line-height: 1 !important;
    padding: 0 16px !important;
}
.bg-stop-btn button {
    background: #dc2626 !important;
    color: white !important;
    border: none !important;
}
.bg-stop-btn button:hover { background: #b91c1c !important; }

/* ---- Preset radio as horizontal pill chips ---- */
.bg-preset,
.bg-preset > div,
.bg-preset > .wrap {
    height: 56px !important;
    min-height: 56px !important;
    max-height: 56px !important;
    padding: 0 !important;
}
.bg-preset > label,
.bg-preset .label-wrap { display: none !important; }
.bg-preset .wrap,
.bg-preset > div > div,
.bg-preset fieldset {
    display: flex !important;
    flex-direction: row !important;
    gap: 4px !important;
    flex-wrap: nowrap !important;
    width: 100% !important;
    height: 56px !important;
    align-items: stretch !important;
    border: none !important;
    padding: 0 !important;
    margin: 0 !important;
}
.bg-preset label {
    flex: 1 1 0 !important;
    margin: 0 !important;
    padding: 0 8px !important;
    height: 56px !important;
    min-height: 56px !important;
    max-height: 56px !important;
    border-radius: 8px !important;
    font-size: 13px !important;
    font-weight: 500 !important;
    border: 1px solid #e5e7eb !important;
    background: #ffffff !important;
    cursor: pointer !important;
    text-align: center !important;
    display: inline-flex !important;
    align-items: center !important;
    justify-content: center !important;
    line-height: 1 !important;
    color: #475569 !important;
    transition: background 0.15s, border 0.15s !important;
    white-space: nowrap !important;
}
.bg-preset label:hover { background: #f8fafc !important; border-color: #cbd5e1 !important; }
.bg-preset input[type="radio"] { display: none !important; }
.bg-preset label.selected,
.bg-preset label:has(input:checked) {
    background: #1e3a8a !important;
    color: #ffffff !important;
    border-color: #1e3a8a !important;
}

/* ---- Caption chip beneath each toolbar control ---- */
.bg-fname {
    font-size: 11.5px;
    color: #94a3b8;
    padding: 4px 8px 0 8px;
    line-height: 1.3;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    height: 18px;
    box-sizing: content-box;
}
.bg-fname.ok { color: #166534; font-weight: 500; }

/* ==================================================================
   Advanced settings — gr.Row with each Checkbox as its own card.
   Trick: `display: contents` on Gradio's intermediate wrapper makes
   it vanish from the layout tree, so the actual checkbox blocks
   become direct flex children of .bg-row. Card style is applied to
   each block, not the wrapper, so we get N cards per row instead of
   one big box.
   ================================================================== */
.bg-row {
    display: flex !important;
    flex-direction: row !important;
    gap: 10px !important;
    align-items: stretch !important;
    padding: 4px 0 !important;
}

/* Flatten Gradio's intermediate `.form` / `.gr-form` wrapper so its
   children become direct flex items of .bg-row. */
.bg-row > .form,
.bg-row > .gr-form {
    display: contents !important;
}
/* Some Gradio versions emit a plain `<div>` wrapper instead of `.form`.
   We can't safely `display: contents` every direct div (the spacer is
   one), but if the wrapper has only blocks inside, contents flatten it. */
.bg-row > div:not(.bg-row-spacer):not(.gr-block):not(.block) {
    display: contents !important;
}

/* Each individual checkbox block = a card */
.bg-row .gr-block,
.bg-row .block {
    flex: 1 1 0 !important;
    min-width: 0 !important;
    background: #f8fafc !important;
    border: 1px solid #e5e7eb !important;
    border-radius: 8px !important;
    padding: 8px 12px !important;
    box-shadow: none !important;
    transition: background 0.15s, border 0.15s !important;
}
.bg-row .gr-block:hover,
.bg-row .block:hover {
    background: #eff6ff !important;
    border-color: #cbd5e1 !important;
}
.bg-row label,
.bg-row .gr-checkbox label {
    font-size: 13px !important;
    font-weight: 500 !important;
    line-height: 1.3 !important;
    color: #334155 !important;
    margin: 0 !important;
    padding: 0 !important;
}
.bg-row .gr-info, .bg-row [class*="info"] { display: none !important; }

/* Spacer — invisible flex item that just preserves alignment */
.bg-row .bg-row-spacer {
    flex: 1 1 0 !important;
    background: transparent !important;
    border: none !important;
    box-shadow: none !important;
    padding: 0 !important;
    visibility: hidden !important;
}

/* ==================================================================
   Status strip — thin one-liner above the report.
   The Gradio HTML wrapper itself is pinned to its parent column's width
   so no inner content can change the page geometry during streaming.
   ================================================================== */
#bg-status-wrap,
#bg-status-wrap > * {
    width: 100% !important;
    max-width: 100% !important;
    min-width: 0 !important;
    box-sizing: border-box !important;
    overflow-x: hidden !important;
}
.bg-status {
    padding: 10px 14px;
    border-radius: 10px;
    background: #f8fafc;
    border: 1px solid #e2e8f0;
    font-size: 12.5px;
    line-height: 1.45;
    color: #334155;
    margin: 8px 0 12px 0;
    max-width: 100%;
    overflow: hidden;       /* never let inline content widen the page */
    box-sizing: border-box;
}
.bg-status-row {
    display: flex;
    align-items: center;
    gap: 14px;
    flex-wrap: nowrap;      /* one row, ellipsize the middle */
    min-width: 0;
    width: 100%;
}
.bg-status .bg-status-stage {
    font-weight: 600;
    color: #1e3a8a;
    display: inline-flex;
    align-items: center;
    gap: 8px;
    flex-shrink: 0;
    white-space: nowrap;
}
.bg-status .bg-status-detail {
    color: #475569;
    flex: 1 1 0;
    min-width: 0;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}
.bg-status .bg-status-detail code {
    background: #eef2ff;
    padding: 1px 6px;
    border-radius: 4px;
    font-size: 11.5px;
    color: #1e3a8a;
}
.bg-status .bg-status-meta {
    color: #64748b;
    font-size: 11.5px;
    display: inline-flex;
    flex-wrap: nowrap;
    gap: 12px;
    flex-shrink: 0;
    white-space: nowrap;
}
.bg-status.done { background: #f0fdf4; border-color: #bbf7d0; }
.bg-status.done .bg-status-stage { color: #166534; }
.bg-status.error { background: #fef2f2; border-color: #fecaca; }
.bg-status.error .bg-status-stage { color: #b91c1c; }
.bg-status .spin {
    display: inline-block;
    width: 10px; height: 10px;
    border: 2px solid #cbd5e1;
    border-top-color: #2563eb;
    border-radius: 50%;
    animation: bg-spin 0.9s linear infinite;
}
@keyframes bg-spin { to { transform: rotate(360deg); } }

/* ==================================================================
   Report area — full-width iframe.
   ================================================================== */
.bg-main { padding: 0 !important; }
.bg-report-iframe {
    width: 100%;
    height: 80vh;
    min-height: 620px;
    border: 1px solid #e5e7eb;
    border-radius: 12px;
    background: white;
    box-shadow: 0 1px 2px rgba(0,0,0,0.04);
}

/* Empty / error placeholder (full-width, centered card) */
.bg-empty {
    display: flex; align-items: center; justify-content: center;
    flex-direction: column; gap: 14px;
    min-height: 60vh;
    color: #6b7280; text-align: center;
    border: 2px dashed #e5e7eb; border-radius: 12px;
    padding: 56px 24px;
    background: #fafafa;
}
.bg-empty .bg-empty-icon { font-size: 56px; line-height: 1; }
.bg-empty .bg-empty-title { font-size: 17px; font-weight: 600; color: #374151; }
.bg-empty .bg-empty-hint { font-size: 14px; max-width: 580px; line-height: 1.6; }
.bg-empty .bg-empty-hint code { background: #f3f4f6; padding: 1px 6px; border-radius: 4px; font-size: 13px; }

/* Compact downloads section */
.bg-downloads { gap: 6px !important; }
.bg-downloads .gr-file { min-height: auto !important; }
.bg-downloads .bg-file-input > label > div {
    height: 52px !important;
    min-height: 52px !important;
    max-height: 52px !important;
}

/* Footer */
.bg-footer {
    text-align: center;
    margin-top: 18px;
    padding-top: 12px;
    border-top: 1px solid #f1f5f9;
    font-size: 11.5px;
    color: #9ca3af;
}
.bg-footer code { background: #f3f4f6; padding: 1px 5px; border-radius: 3px; font-size: 11px; }
.bg-footer a { color: #6b7280; text-decoration: none; }
.bg-footer a:hover { text-decoration: underline; }

/* Trim accordion chrome a bit */
.gr-accordion { border-radius: 10px !important; border: 1px solid #e5e7eb !important; }
.gr-accordion > .label-wrap { padding: 8px 12px !important; font-size: 13px !important; }

@media (prefers-color-scheme: dark) {
    .bg-empty { background: #161b22; border-color: #2a313c; color: #9ca3af; }
    .bg-empty .bg-empty-title { color: #e6edf3; }
    .bg-empty .bg-empty-hint code { background: #21262d; }
    .bg-report-iframe { background: #0d1117; border-color: #2a313c; box-shadow: none; }
    .bg-status { background: #0f172a; border-color: #1e293b; color: #cbd5e1; }
    .bg-status .bg-status-stage { color: #93c5fd; }
    .bg-status .bg-status-detail { color: #94a3b8; }
    .bg-status .bg-status-detail code { background: #1e293b; color: #93c5fd; }
    .bg-status .bg-status-meta { color: #64748b; }
    .bg-status.done { background: #052e1a; border-color: #14532d; }
    .bg-status.done .bg-status-stage { color: #86efac; }
    .bg-status.error { background: #2a0e0e; border-color: #7f1d1d; }
    .bg-preset label { background: #161b22 !important; border-color: #2a313c !important; color: #cbd5e1 !important; }
    .bg-preset label:hover { background: #1e293b !important; }
    .bg-preset .selected { background: #2563eb !important; border-color: #2563eb !important; }
    .bg-footer { border-color: #1e293b; }
}
"""


EMPTY_PANEL_HTML = """
<div class="bg-empty">
    <div class="bg-empty-icon">📄</div>
    <div class="bg-empty-title">Your interactive report appears here</div>
    <div class="bg-empty-hint">
        Upload a <code>.bib</code> file and a <code>.tex</code> file in the toolbar above,
        pick a preset, then press <strong>Run check</strong>. The report renders as a
        self-contained HTML page with per-section filters, full-text search,
        inline span highlighting, and dark-mode support.
    </div>
</div>
"""

EMPTY_STATUS_HTML = (
    '<div class="bg-status">'
    '<div class="bg-status-row">'
    '<span class="bg-status-stage">○ Idle</span>'
    '<span class="bg-status-detail">Upload <code>.bib</code> + <code>.tex</code> '
    'and press <strong>Run check</strong> to begin.</span>'
    '</div></div>'
)


def _placeholder(message: str, color: str = "#b91c1c") -> str:
    """Inline error/info card shown in place of the iframe."""
    return (
        f'<div class="bg-empty" style="color:{color};border-color:{color}33">'
        f'<div class="bg-empty-icon">⚠️</div>'
        f'<div class="bg-empty-title">{message}</div>'
        f'</div>'
    )


def _html_to_iframe(html: str) -> str:
    """
    Embed an HTML document inside ``<iframe srcdoc>``.

    We escape only ``&`` and ``"`` — these are the two characters that can
    break the attribute value or get re-decoded as entities. ``<`` and ``>``
    must stay raw, otherwise the inner document would be HTML-encoded.
    """
    escaped = html.replace("&", "&amp;").replace('"', "&quot;")
    return (
        f'<iframe class="bg-report-iframe" srcdoc="{escaped}" '
        f'sandbox="allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox" '
        f'loading="lazy"></iframe>'
    )


def _status_html(stage: str, detail: str = "", meta: list[str] | None = None,
                 state: str = "running") -> str:
    """Render the live-status strip shown above the report.

    Layout is a single horizontal row: [stage] [detail] [meta chips].
    Wraps cleanly on narrow screens.
    """
    if state == "running":
        stage_icon = '<span class="spin"></span>'
    elif state == "done":
        stage_icon = '<span>✓</span>'
    elif state == "error":
        stage_icon = '<span>⚠</span>'
    else:
        stage_icon = '<span>○</span>'
    detail_html = f'<span class="bg-status-detail">{detail}</span>' if detail else '<span class="bg-status-detail"></span>'
    meta_html = ""
    if meta:
        meta_html = (
            '<span class="bg-status-meta">'
            + " ".join(f"<span>{m}</span>" for m in meta)
            + "</span>"
        )
    return (
        f'<div class="bg-status {state}">'
        f'<div class="bg-status-row">'
        f'<span class="bg-status-stage">{stage_icon}<span>{stage}</span></span>'
        f'{detail_html}{meta_html}'
        f'</div></div>'
    )


# --------------------------------------------------------------- config glue

def create_config_from_ui(
    check_metadata, check_usage, check_duplicates, check_preprint_ratio,
    caption, reference, formatting, equation, ai_artifacts,
    sentence, consistency, acronym, number, citation_quality, anonymization,
) -> BibGuardConfig:
    config = BibGuardConfig()
    config.bibliography = BibliographyConfig(
        check_metadata=check_metadata,
        check_usage=check_usage,
        check_duplicates=check_duplicates,
        check_preprint_ratio=check_preprint_ratio,
        check_relevance=False,  # LLM disabled in web mode
    )
    config.submission = SubmissionConfig(
        caption=caption, reference=reference, formatting=formatting, equation=equation,
        ai_artifacts=ai_artifacts, sentence=sentence, consistency=consistency,
        acronym=acronym, number=number, citation_quality=citation_quality,
        anonymization=anonymization,
    )
    config.output = OutputConfig(quiet=True, minimal_verified=False)
    return config


def apply_preset(name: str):
    p = PRESETS.get(name, PRESETS["Standard"])
    sub = p["submission"]
    return (
        p["check_metadata"], p["check_usage"], p["check_duplicates"], p["check_preprint_ratio"],
        sub["caption"], sub["reference"], sub["formatting"], sub["equation"],
        sub["ai_artifacts"], sub["sentence"], sub["consistency"], sub["acronym"],
        sub["number"], sub["citation_quality"], sub["anonymization"],
        p["url_liveness"], p["retraction"],
    )


_PRESET_CAPTIONS = {
    "Quick":    "local checks only · no network · instant",
    "Standard": "local checks + retraction lookup (CrossRef)",
    "Strict":   "+ URL liveness + multi-source metadata (slow)",
}


def _preset_caption_html(name: str) -> str:
    text = _PRESET_CAPTIONS.get(name, "")
    return f'<div class="bg-fname" style="text-align:center">{text}</div>'


# ------------------------------------------------------------------ run_check
# Streaming generator. Each yield is a 7-tuple:
#   (iframe_html, status_html, html_path, md_path, json_path,
#    cleaned_bib_path, log_path)
# `capture_run` attaches a per-run DEBUG file handler so any exception or
# warning anywhere in the pipeline is recorded with full traceback at
# `<out_dir>/bibguard.log`, which is then downloadable. The status panel
# surfaces warning+error counts so problems aren't invisible.

def run_check(
    bib_file, tex_file,
    check_metadata, check_usage, check_duplicates, check_preprint_ratio,
    caption, reference, formatting, equation, ai_artifacts,
    sentence, consistency, acronym, number, citation_quality, anonymization,
    url_liveness=False, retraction=True,
):
    """Run the full check pipeline as a streaming generator with per-run logging.

    `bib_file` / `tex_file` are filesystem path strings (carried by gr.State),
    not gr.File objects. The status panel is the single source of progress
    feedback — no separate gr.Progress bar.
    """
    started = time.time()

    def _elapsed() -> str:
        return f"⏱ {int(time.time() - started)}s"

    # Initial state: keep current report (None means clear).
    if not bib_file or not tex_file:
        yield (
            _placeholder("Please choose both a .bib and a .tex file in the toolbar."),
            _status_html("Waiting for files",
                         "Pick a .bib and a .tex file from the toolbar to start.",
                         state="error"),
            None, None, None, None, None,
        )
        return

    # Allocate the artifact dir up-front so the per-run log lives next to
    # the report files.
    out_dir = Path(tempfile.mkdtemp(prefix="bibguard_"))
    log_path_target = out_dir / "bibguard.log"

    # Reset per-source circuit breakers so a previous run's flaky source
    # doesn't carry over and skip valid lookups in this run.
    http_layer.reset_breakers()

    with capture_run(target_path=log_path_target) as (log_path, log_stats):
        logger.info("=== run_check start: bib=%s tex=%s ===", bib_file, tex_file)
        try:
            yield from _run_check_impl(
                bib_file, tex_file, out_dir, log_path, log_stats,
                check_metadata, check_usage, check_duplicates, check_preprint_ratio,
                caption, reference, formatting, equation, ai_artifacts,
                sentence, consistency, acronym, number, citation_quality, anonymization,
                url_liveness, retraction, started, _elapsed,
            )
        except Exception as e:
            logger.exception("run_check crashed (entry-level guard)")
            yield (
                _placeholder(f"Unhandled error: {e}"),
                _status_html("Failed", f"{e} — see <code>bibguard.log</code> for the full traceback.",
                             state="error"),
                None, None, None, None, str(log_path),
            )
        finally:
            logger.info("=== run_check end: warnings=%d errors=%d ===",
                        log_stats.warnings, log_stats.errors)


def _run_check_impl(
    bib_file, tex_file, out_dir, log_path, log_stats,
    check_metadata, check_usage, check_duplicates, check_preprint_ratio,
    caption, reference, formatting, equation, ai_artifacts,
    sentence, consistency, acronym, number, citation_quality, anonymization,
    url_liveness, retraction, started, _elapsed,
):
    """Inner pipeline. Wrapped in `capture_run` by `run_check`.

    Every yield is a 7-tuple ending with the log path so the user can
    download `bibguard.log` even from intermediate updates.
    """
    log_path_str = str(log_path)

    bib_path = Path(bib_file)
    tex_path = Path(tex_file)
    logger.info("Inputs: bib=%s tex=%s out_dir=%s", bib_path, tex_path, out_dir)

    def _meta_with_logs(extra: list[str]) -> list[str]:
        out = list(extra)
        if log_stats.warnings or log_stats.errors:
            out.append(f"⚠ {log_stats.warnings}w / {log_stats.errors}e logged")
        return out

    yield (
        gr.update(),
        _status_html("Validating files",
                     f"Reading <code>{bib_path.name}</code> and <code>{tex_path.name}</code>",
                     meta=_meta_with_logs([_elapsed()])),
        None, None, None, None, log_path_str,
    )

    # Pre-flight content validation
    bib_rep = validate_bib(bib_path)
    tex_rep = validate_tex(tex_path)
    msg = "\n".join(filter(None, [
        format_report(bib_rep, bib_path.name),
        format_report(tex_rep, tex_path.name),
    ]))
    if not bib_rep.ok or not tex_rep.ok:
        logger.error("File validation failed:\n%s", msg)
        block = (
            f'<div class="bg-empty" style="color:#b91c1c;border-color:#b91c1c33">'
            f'<div class="bg-empty-icon">⚠️</div>'
            f'<div class="bg-empty-title">File validation failed</div>'
            f'<pre style="white-space:pre-wrap;font-size:13px;color:#7f1d1d;'
            f'background:#fef2f2;padding:12px;border-radius:6px;max-width:540px">{msg}</pre>'
            f'</div>'
        )
        yield (
            block,
            _status_html("File validation failed", msg.replace("\n", "<br>"),
                         state="error"),
            None, None, None, None, log_path_str,
        )
        return
    elif msg:
        logger.info("Validation warnings:\n%s", msg)

    config = create_config_from_ui(
        check_metadata, check_usage, check_duplicates, check_preprint_ratio,
        caption, reference, formatting, equation, ai_artifacts,
        sentence, consistency, acronym, number, citation_quality, anonymization,
    )

    yield (
        gr.update(),
        _status_html("Parsing", "Loading bibliography and LaTeX source",
                     meta=_meta_with_logs([_elapsed()])),
        None, None, None, None, log_path_str,
    )

    tex_content = tex_path.read_text(encoding='utf-8', errors='replace')
    bib_parser = BibParser()
    entries = bib_parser.parse_file(str(bib_path))
    tex_parser = TexParser()
    tex_parser.parse_file(str(tex_path))
    logger.info("Parsed %d bib entries from %s", len(entries), bib_path.name)

    bib_config = config.bibliography

    # Init components
    arxiv_fetcher = crossref_fetcher = ss_fetcher = oa_fetcher = dblp_fetcher = None
    comparator = usage_checker = duplicate_detector = None

    if bib_config.check_metadata:
        arxiv_fetcher = ArxivFetcher()
        ss_fetcher = SemanticScholarFetcher()
        oa_fetcher = OpenAlexFetcher()
        dblp_fetcher = DBLPFetcher()
        crossref_fetcher = CrossRefFetcher()
        comparator = MetadataComparator()
    if bib_config.check_usage:
        usage_checker = UsageChecker(tex_parser)
    if bib_config.check_duplicates:
        duplicate_detector = DuplicateDetector()

    report_gen = ReportGenerator(
        minimal_verified=False,
        check_preprint_ratio=bib_config.check_preprint_ratio,
        preprint_warning_threshold=bib_config.preprint_warning_threshold,
    )
    report_gen.set_metadata([str(bib_path)], [str(tex_path)])

    # Submission quality checks
    yield (
        gr.update(),
        _status_html("LaTeX quality checks",
                     f"Running {len(config.submission.get_enabled_checkers())} checkers on the LaTeX source",
                     meta=_meta_with_logs([f"📚 {len(entries)} bib entries", _elapsed()])),
        None, None, None, None, log_path_str,
    )
    submission_results = []
    for name in config.submission.get_enabled_checkers():
        if name in CHECKER_REGISTRY:
            try:
                checker = CHECKER_REGISTRY[name]()
                results = checker.check(tex_content, {})
                for r in results:
                    r.file_path = str(tex_path)
                submission_results.extend(results)
            except Exception:
                logger.exception("Checker %s crashed", name)
    report_gen.set_submission_results(submission_results, None)

    if bib_config.check_duplicates and duplicate_detector:
        try:
            report_gen.set_duplicate_groups(duplicate_detector.find_duplicates(entries))
        except Exception:
            logger.exception("Duplicate detection crashed")
    if bib_config.check_usage and usage_checker:
        try:
            report_gen.set_missing_citations(usage_checker.get_missing_entries(entries))
        except Exception:
            logger.exception("Missing-citation lookup crashed")

    # Per-entry workflow
    total = max(1, len(entries))
    workflow_config = get_default_workflow()
    verified_count = 0
    flagged_count = 0
    not_found_count = 0
    last_yield = time.time()

    def _identifier_chip(entry) -> str:
        """Tiny inline hint about which IDs we have for this entry."""
        bits = []
        if entry.doi: bits.append("DOI")
        if entry.has_arxiv: bits.append("arXiv")
        if entry.title and not bits: bits.append("title")
        elif entry.title: bits.append("title")
        return " + ".join(bits) if bits else "no identifiers"

    def _outcome_label(cmp) -> str:
        if cmp is None:
            return ""
        if cmp.source == "unable":
            return "<span style='color:#b45309'>? no metadata</span>"
        if cmp.is_match:
            return f"<span style='color:#166534'>✓ verified by {cmp.source}</span>"
        return f"<span style='color:#b45309'>⚠ flagged ({cmp.source})</span>"

    for i, entry in enumerate(entries):
        # ── Pre-fetch status: announce identifier set BEFORE the network roundtrip
        # so the user sees what's being attempted, not just the entry name.
        if bib_config.check_metadata and comparator:
            now = time.time()
            if now - last_yield > 0.4 or i == 0:
                ids = _identifier_chip(entry)
                detail = f"<code>{entry.key}</code> · querying via <strong>{ids}</strong>"
                if entry.title:
                    short = entry.title[:70] + ("…" if len(entry.title) > 70 else "")
                    detail += f" — <span style='color:#64748b'>{short}</span>"
                yield (
                    gr.update(),
                    _status_html(
                        f"Verifying entry {i + 1}/{total}",
                        detail,
                        meta=_meta_with_logs([
                            f"📚 {total} total",
                            f"✓ {verified_count}",
                            f"⚠ {flagged_count}",
                            f"? {not_found_count}",
                            _elapsed(),
                        ]),
                    ),
                    None, None, None, None, log_path_str,
                )
                last_yield = now

        usage_result = None
        comparison_result = None
        try:
            if usage_checker:
                usage_result = usage_checker.check_usage(entry)
        except Exception:
            logger.exception("Usage check crashed for entry=%s", entry.key)
        try:
            if bib_config.check_metadata and comparator:
                comparison_result = fetch_and_compare_with_workflow(
                    entry, workflow_config, arxiv_fetcher, crossref_fetcher,
                    ss_fetcher, oa_fetcher, dblp_fetcher, comparator,
                )
                if comparison_result is None or comparison_result.source == "unable":
                    not_found_count += 1
                elif comparison_result.is_match:
                    verified_count += 1
                else:
                    flagged_count += 1
        except Exception:
            logger.exception("Metadata fetch crashed for entry=%s", entry.key)
        report_gen.add_entry_report(EntryReport(
            entry=entry, comparison=comparison_result,
            usage=usage_result, evaluations=[],
        ))

        # ── Post-fetch status: show outcome inline so the user can watch
        # results stream in (verified / flagged / not found).
        now = time.time()
        if now - last_yield > 0.4 or i == total - 1:
            outcome = _outcome_label(comparison_result)
            detail_parts = [f"<code>{entry.key}</code>"]
            if outcome:
                detail_parts.append(outcome)
            if entry.title:
                short = entry.title[:70] + ("…" if len(entry.title) > 70 else "")
                detail_parts.append(f"<span style='color:#64748b'>{short}</span>")
            detail = " · ".join(detail_parts)
            meta = _meta_with_logs([
                f"📚 {i + 1}/{total}",
                f"✓ {verified_count}",
                f"⚠ {flagged_count}",
                f"? {not_found_count}",
                _elapsed(),
            ])
            yield (
                gr.update(),
                _status_html(f"Bibliography {i + 1}/{total}", detail, meta=meta),
                None, None, None, None, log_path_str,
            )
            last_yield = now

    if retraction:
        try:
            doi_count = sum(1 for e in entries if getattr(e, "doi", ""))
            yield (
                gr.update(),
                _status_html("Retraction lookups",
                             f"Querying CrossRef for {doi_count} DOI(s)",
                             meta=_meta_with_logs([_elapsed()])),
                None, None, None, None, log_path_str,
            )
            report_gen.set_retraction_findings(RetractionChecker().check_entries(entries))
        except Exception:
            logger.exception("Retraction lookup crashed")

    if url_liveness:
        try:
            url_count = sum(1 for e in entries if getattr(e, "url", ""))
            yield (
                gr.update(),
                _status_html("URL liveness",
                             f"HEAD-checking {url_count} URL(s) in parallel",
                             meta=_meta_with_logs([_elapsed()])),
                None, None, None, None, log_path_str,
            )
            report_gen.set_url_findings(URLChecker().check_entries(entries))
        except Exception:
            logger.exception("URL liveness crashed")

    # Save artifacts
    yield (
        gr.update(),
        _status_html("Building report",
                     "Rendering self-contained HTML, JSON, and Markdown",
                     meta=_meta_with_logs([_elapsed()])),
        None, None, None, None, log_path_str,
    )
    html_path = out_dir / "report.html"
    md_path = out_dir / "bibliography_report.md"
    json_path = out_dir / "report.json"
    cleaned_bib_path: Path | None = None

    try:
        report_gen.save_html(str(html_path))
        report_gen.save_bibliography_report(str(md_path))
        report_gen.save_json(str(json_path))
        if usage_checker:
            used_keys = {er.entry.key for er in report_gen.entries if er.usage and er.usage.is_used}
            if used_keys:
                cleaned_bib_path = out_dir / f"{bib_path.stem}_only_used.bib"
                bib_parser.filter_file(str(bib_path), str(cleaned_bib_path), used_keys)
    except Exception:
        logger.exception("Artifact generation failed")

    # Embed report.html as iframe srcdoc
    if html_path.exists():
        iframe_html = _html_to_iframe(html_path.read_text(encoding='utf-8'))
    else:
        iframe_html = _placeholder("Report generation failed — see bibguard.log.")

    meta = _meta_with_logs([
        f"📚 {len(entries)} entries",
        f"✓ {verified_count} verified",
        f"⚠ {flagged_count} flagged",
        _elapsed(),
    ])
    state = "done"
    summary = "Report ready. Use the right pane to filter, search, and copy fixes."
    if log_stats.errors > 0:
        state = "error"
        summary = (f"Done with {log_stats.errors} error(s) and {log_stats.warnings} warning(s) "
                   "logged — see <code>bibguard.log</code> for full tracebacks.")
    elif log_stats.warnings > 0:
        summary = (f"Report ready ({log_stats.warnings} warnings logged — see "
                   "<code>bibguard.log</code>).")

    yield (
        iframe_html,
        _status_html("Done", summary, meta=meta, state=state),
        str(html_path) if html_path.exists() else None,
        str(md_path) if md_path.exists() else None,
        str(json_path) if json_path.exists() else None,
        str(cleaned_bib_path) if (cleaned_bib_path and cleaned_bib_path.exists()) else None,
        log_path_str,
    )


# --------------------------------------------------------------------- layout

def create_app() -> gr.Blocks:
    # Inline app icon as a base64 data URL — works regardless of cwd.
    icon_html = '<span style="font-size:28px">🛡️</span>'
    try:
        icon_path = Path(__file__).parent / "assets" / "icon-192.png"
        if icon_path.exists():
            with open(icon_path, "rb") as f:
                b64 = base64.b64encode(f.read()).decode()
            icon_html = (
                f'<img src="data:image/png;base64,{b64}" '
                f'style="width:32px;height:32px;border-radius:6px" alt="BibGuard">'
            )
    except Exception as e:
        logger.debug("Icon load failed; using emoji fallback: %s", e, exc_info=True)

    with gr.Blocks(
        title="BibGuard — Bibliography & LaTeX Quality Auditor",
    ) as app:

        gr.HTML(f"""
        <div class="bg-header" style="display:flex;align-items:center;gap:10px">
            {icon_html}
            <strong style="font-size:18px">BibGuard</strong>
            <span style="color:#6b7280;font-size:13px">— Bibliography & LaTeX quality auditor</span>
            <span style="flex:1"></span>
            <a href="https://github.com/thinkwee/BibGuard" target="_blank"
               style="color:#6b7280;text-decoration:none;font-size:13px">GitHub ↗</a>
        </div>
        """)

        # ───────────────────────── Top toolbar ─────────────────────────
        # All primary controls on a single horizontal row, every primary
        # widget pinned to 56px height. gr.UploadButton replaces gr.File
        # because the latter's drop-zone doesn't shrink to a toolbar.
        with gr.Row(elem_classes=["bg-toolbar"]):
            with gr.Column(scale=2, min_width=200):
                bib_btn = gr.UploadButton(
                    "📚 Choose .bib file",
                    file_types=[".bib"], file_count="single",
                    elem_classes=["bg-upload-btn"],
                )
                bib_status = gr.HTML('<div class="bg-fname">no file selected</div>')
            with gr.Column(scale=2, min_width=200):
                tex_btn = gr.UploadButton(
                    "📄 Choose .tex file",
                    file_types=[".tex"], file_count="single",
                    elem_classes=["bg-upload-btn"],
                )
                tex_status = gr.HTML('<div class="bg-fname">no file selected</div>')
            with gr.Column(scale=3, min_width=280):
                preset = gr.Radio(
                    choices=list(PRESETS.keys()),
                    value="Standard",
                    show_label=False,
                    elem_classes=["bg-preset"],
                )
                preset_caption = gr.HTML(
                    _preset_caption_html("Standard"),
                )
            with gr.Column(scale=1, min_width=140):
                run_btn = gr.Button("▶  Run check", variant="primary",
                                    elem_classes=["bg-run-btn"])
                stop_btn = gr.Button("◼  Stop", variant="stop",
                                     elem_classes=["bg-run-btn", "bg-stop-btn"],
                                     visible=False)
                gr.HTML('<div class="bg-fname" style="text-align:center">&nbsp;</div>')

        # Holds the selected file paths (strings). Updated by the UploadButton
        # callbacks below so run_check sees plain paths regardless of how the
        # user picked the files.
        bib_path_state = gr.State(value=None)
        tex_path_state = gr.State(value=None)

        # Advanced fine-grained toggles. Default closed — most users just
        # pick a preset and go. Each tab is composed of gr.Row blocks of
        # exactly 4 cells so columns line up vertically. Short rows are
        # padded with invisible spacer HTML.
        def _spacer():
            return gr.HTML('<div class="bg-row-spacer">&nbsp;</div>',
                           elem_classes=["bg-row-spacer"])

        with gr.Accordion("⚙️  Advanced settings", open=False):
            with gr.Tabs():
                with gr.TabItem("Bibliography"):
                    with gr.Row(elem_classes=["bg-row"]):
                        check_metadata = gr.Checkbox(label="Metadata verify", value=False)
                        check_usage = gr.Checkbox(label="Usage", value=True)
                        check_duplicates = gr.Checkbox(label="Duplicates", value=True)
                        check_preprint_ratio = gr.Checkbox(label="Preprints", value=True)
                    with gr.Row(elem_classes=["bg-row"]):
                        retraction = gr.Checkbox(label="Retractions", value=True)
                        url_liveness = gr.Checkbox(label="URL liveness", value=False)
                        _spacer()
                        _spacer()

                with gr.TabItem("LaTeX format"):
                    with gr.Row(elem_classes=["bg-row"]):
                        caption = gr.Checkbox(label="Captions", value=True)
                        reference = gr.Checkbox(label="References", value=True)
                        formatting = gr.Checkbox(label="Formatting", value=True)
                        equation = gr.Checkbox(label="Equations", value=True)

                with gr.TabItem("Writing"):
                    with gr.Row(elem_classes=["bg-row"]):
                        ai_artifacts = gr.Checkbox(label="AI artifacts", value=True)
                        sentence = gr.Checkbox(label="Sentences", value=True)
                        consistency = gr.Checkbox(label="Consistency", value=True)
                        acronym = gr.Checkbox(label="Acronyms", value=True)
                    with gr.Row(elem_classes=["bg-row"]):
                        number = gr.Checkbox(label="Numbers", value=True)
                        citation_quality = gr.Checkbox(label="Citations", value=True)
                        anonymization = gr.Checkbox(label="Anonymization", value=True)
                        _spacer()

        # ───────────────────────── Status strip ─────────────────────────
        status_panel = gr.HTML(value=EMPTY_STATUS_HTML, elem_id="bg-status-wrap")

        # ───────────────────────── Report (full width) ───────────────────
        with gr.Row(elem_classes=["bg-main"]):
            report_panel = gr.HTML(value=EMPTY_PANEL_HTML)

        # ───────────────────────── Downloads ────────────────────────────
        with gr.Accordion("📥 Downloads", open=False):
            with gr.Row(elem_classes=["bg-downloads"]):
                download_html = gr.File(label="report.html (offline)",
                                        interactive=False, elem_classes=["bg-file-input"])
                download_md = gr.File(label="bibliography_report.md",
                                      interactive=False, elem_classes=["bg-file-input"])
                download_json = gr.File(label="report.json",
                                        interactive=False, elem_classes=["bg-file-input"])
                download_bib = gr.File(label="cleaned .bib",
                                       interactive=False, elem_classes=["bg-file-input"])
                download_log = gr.File(label="bibguard.log",
                                       interactive=False, elem_classes=["bg-file-input"])

        gr.HTML(
            '<div class="bg-footer">'
            'Set <code>$BIBGUARD_CONTACT_EMAIL</code> for the polite-pool User-Agent · '
            f'persistent log at <code>{LOG_PATH}</code> · '
            'set <code>BIBGUARD_DEBUG=1</code> for verbose console output.'
            '</div>'
        )

        preset.change(
            fn=apply_preset,
            inputs=[preset],
            outputs=[
                check_metadata, check_usage, check_duplicates, check_preprint_ratio,
                caption, reference, formatting, equation,
                ai_artifacts, sentence, consistency, acronym,
                number, citation_quality, anonymization,
                url_liveness, retraction,
            ],
        )
        preset.change(
            fn=_preset_caption_html,
            inputs=[preset],
            outputs=[preset_caption],
        )

        # ---- Upload-button callbacks: store path in state + update chip ----

        def _on_bib_upload(f):
            if f is None:
                return None, '<div class="bg-fname">no file selected</div>'
            path = getattr(f, "name", str(f))
            return path, f'<div class="bg-fname ok">📚 {Path(path).name}</div>'

        def _on_tex_upload(f):
            if f is None:
                return None, '<div class="bg-fname">no file selected</div>'
            path = getattr(f, "name", str(f))
            return path, f'<div class="bg-fname ok">📄 {Path(path).name}</div>'

        bib_btn.upload(_on_bib_upload, inputs=[bib_btn], outputs=[bib_path_state, bib_status])
        tex_btn.upload(_on_tex_upload, inputs=[tex_btn], outputs=[tex_path_state, tex_status])

        # Run pipeline:
        #   1. Toggle visibility: hide Run, show Stop.
        #   2. Stream run_check yields into report + status + downloads.
        #   3. After completion, swap buttons back.
        # Stop button cancels the streaming task via Gradio's `cancels=`.
        def _show_stop():
            return gr.update(visible=False), gr.update(visible=True)

        def _show_run():
            return gr.update(visible=True), gr.update(visible=False)

        run_event = run_btn.click(
            fn=_show_stop, inputs=None, outputs=[run_btn, stop_btn],
        ).then(
            fn=run_check,
            inputs=[
                bib_path_state, tex_path_state,
                check_metadata, check_usage, check_duplicates, check_preprint_ratio,
                caption, reference, formatting, equation, ai_artifacts,
                sentence, consistency, acronym, number, citation_quality, anonymization,
                url_liveness, retraction,
            ],
            outputs=[report_panel, status_panel,
                     download_html, download_md, download_json, download_bib, download_log],
        ).then(
            fn=_show_run, inputs=None, outputs=[run_btn, stop_btn],
        )

        stop_btn.click(
            fn=lambda: (
                gr.update(visible=True),
                gr.update(visible=False),
                _status_html("Cancelled",
                             "Run interrupted by user. Partial results discarded.",
                             state="error"),
            ),
            inputs=None,
            outputs=[run_btn, stop_btn, status_panel],
            cancels=[run_event],
        )

    return app


app = create_app()


if __name__ == "__main__":
    _favicon = Path(__file__).parent / "assets" / "icon-192.png"
    app.launch(
        favicon_path=str(_favicon) if _favicon.exists() else None,
        show_error=True,
        css=CUSTOM_CSS,
        theme=gr.themes.Soft(),
    )