ui/tab_interpretability.py

import streamlit as st

from core.config import BIDDER_NAMES, DATA_DIR
from core.fallback import load_criteria
from core.llm_client import LLM, LLMUnavailable
from core.pdf_utils import render_page_to_image
from core.schemas import Criterion
from ui.components import confidence_bar, verdict_pill

_VERDICT_CFG = {
    "eligible":     ("rgba(34,197,94,0.12)",  "#22C55E", "✅ PASSED"),
    "not_eligible": ("rgba(239,68,68,0.12)",   "#EF4444", "❌ FAILED"),
    "needs_review": ("rgba(245,158,11,0.12)",  "#F59E0B", "⚠️ NEEDS REVIEW"),
}

_RULE_PLAIN = {
    "numeric_threshold":    lambda r: f"must be {r['operator']} {r['value']:,} {r.get('unit') or ''}".strip(),
    "count_threshold":      lambda r: f"must have completed at least {int(r['value'])}",
    "certification_present": lambda _: "valid certificate must be present",
    "document_present":     lambda _: "supporting document must be present",
}


def _get_criteria() -> list[Criterion]:
    data = st.session_state.get("criteria")
    return [Criterion(**c) for c in data] if data else load_criteria()


def _explain(v: dict, crit: Criterion | None) -> str:
    verdict   = v.get("verdict", "")
    extracted = v.get("extracted_value", "") or ""
    reason    = v.get("reason", "") or ""
    if not crit:
        return reason
    rule = crit.rule
    rule_desc = _RULE_PLAIN.get(rule.type, lambda _: "")(rule.model_dump())
    if verdict == "eligible":
        return (f"Found **{extracted}**. " if extracted else "") + reason
    elif verdict == "not_eligible":
        return ((f"Found **{extracted}** — does not meet requirement ({rule_desc}). "
                 if extracted else f"Requirement: {rule_desc}. ") + reason)
    else:
        return (f"Extracted value: **{extracted}**. " if extracted else "") + reason


def _qa_context(bid: str, verdicts: list[dict], criteria: list[Criterion]) -> str:
    cm = {c.id: c for c in criteria}
    lines = [f"BIDDER: {BIDDER_NAMES.get(bid, bid)}", ""]
    for v in verdicts:
        c = cm.get(v["criterion_id"])
        rule = _RULE_PLAIN.get(c.rule.type, lambda _: "")(c.rule.model_dump()) if c else ""
        lines += [
            f"{v['criterion_id']} — {c.title if c else '?'} "
            f"[{'Mandatory' if c and c.mandatory else 'Optional'}]: {v['verdict'].upper()}",
            f"  Requirement: {rule}",
            f"  Extracted: {v.get('extracted_value') or 'not found'}",
            f"  Confidence: {v.get('combined_confidence', 0):.0%}",
            f"  Reason: {v.get('reason', '')}",
        ]
        if v.get("source"):
            s = v["source"]
            lines.append(f"  Evidence: {s.get('doc_name')} page {s.get('page')} "
                         f"[{s.get('source_type')}]")
            if s.get("snippet"):
                lines.append(f'  Snippet: "{s["snippet"][:200]}"')
        lines.append("")
    return "\n".join(lines)


def _answer(question: str, context: str) -> str:
    system = (
        "You are a procurement compliance assistant. Answer questions about an AI-generated "
        "tender evaluation in plain professional English. Always cite specific document names "
        "and page numbers. Be concise (2-4 sentences). Never invent information not in the context. "
        'Return JSON: {"answer": "<your answer>"}'
    )
    try:
        result = LLM().chat_json(system, f"{context}\n\nQUESTION: {question}")
        return result.get("answer", "")
    except LLMUnavailable:
        return _rule_answer(question, context)


def _rule_answer(q: str, context: str) -> str:
    q = q.lower()
    lines = context.splitlines()
    if any(w in q for w in ["reject", "fail", "not eligible", "disqualif"]):
        fails = [l.strip() for l in lines if "NOT_ELIGIBLE" in l or "NEEDS_REVIEW" in l]
        return ("Failing criteria: " + "; ".join(fails[:3]) + ".") if fails else "No failing criteria found."
    if any(w in q for w in ["pass", "eligible", "meet"]):
        passes = [l.strip() for l in lines if "ELIGIBLE" in l and "NOT_ELIGIBLE" not in l]
        return ("Passing criteria: " + "; ".join(passes[:3]) + ".") if passes else "No passing criteria."
    if any(w in q for w in ["turnover", "financial", "c1", "revenue"]):
        rel = [l.strip() for l in lines if "C1" in l or "turnover" in l.lower() or "Extracted" in l]
        return " ".join(rel[:4]) if rel else "Turnover information not found."
    return "Live LLM is unavailable. The evaluation summary above contains the full details."


def render() -> None:
    st.markdown(
        '<h2 style="font-weight:800;font-size:1.5rem;color:var(--text-color);">Interpretability</h2>'
        '<p style="color:var(--text-color);opacity:0.6;font-size:0.875rem;margin-bottom:1rem;">'
        'Plain-English explanations with source citations. Ask any question about the evaluation.</p>',
        unsafe_allow_html=True,
    )

    vdata = st.session_state.get("verdicts", {})
    if not vdata:
        st.info("No results yet. Load the pre-computed demo from Overview, or run evaluation.")
        return

    criteria = _get_criteria()
    crit_map = {c.id: c for c in criteria}

    bid = st.selectbox("Select bidder", options=list(vdata.keys()),
                       format_func=lambda x: BIDDER_NAMES.get(x, x))
    verdicts = vdata.get(bid, [])
    if not verdicts:
        st.warning("No verdicts for this bidder.")
        return

    company = BIDDER_NAMES.get(bid, bid)
    mand = [v for v in verdicts if crit_map.get(v["criterion_id"]) and
            crit_map[v["criterion_id"]].mandatory]
    failed = [v for v in mand if v["verdict"] == "not_eligible"]
    review = [v for v in mand if v["verdict"] == "needs_review"]
    passed = [v for v in mand if v["verdict"] == "eligible"]

    if failed:
        ov, fg, icon = "not_eligible", "#EF4444", "❌"
        summary = f"Failed {len(failed)} mandatory criterion/criteria. Must meet all to qualify."
    elif review:
        ov, fg, icon = "needs_review", "#F59E0B", "⚠️"
        summary = (f"Passed {len(passed)} mandatory criteria, but {len(review)} "
                   f"require officer sign-off.")
    else:
        ov, fg, icon = "eligible", "#22C55E", "✅"
        summary = f"All {len(passed)} mandatory criteria satisfied."

    bg, _, label = _VERDICT_CFG.get(ov, ("rgba(128,128,128,0.1)", "#888", ov))
    st.markdown(
        f'<div style="background:{bg};border:1px solid {fg}33;border-radius:12px;'
        f'padding:18px 20px;margin-bottom:1.5rem;display:flex;align-items:center;gap:14px;">'
        f'<div style="font-size:2rem;line-height:1;">{icon}</div>'
        f'<div>'
        f'<div style="font-weight:800;font-size:1.05rem;color:{fg};">'
        f'{company} — {label}</div>'
        f'<div style="font-size:0.84rem;color:{fg};opacity:0.85;margin-top:4px;">{summary}</div>'
        f'</div></div>',
        unsafe_allow_html=True,
    )

    st.markdown(
        '<div style="font-size:1rem;font-weight:700;color:var(--text-color);margin-bottom:12px;">'
        'Criterion-by-Criterion Breakdown</div>',
        unsafe_allow_html=True,
    )

    for v in verdicts:
        crit    = crit_map.get(v["criterion_id"])
        verdict = v.get("verdict", "needs_review")
        cbg, cfg_, clabel = _VERDICT_CFG.get(verdict, ("rgba(128,128,128,0.1)", "var(--text-color)", verdict))
        mand_txt = "Mandatory" if (crit and crit.mandatory) else "Optional"
        title    = crit.title if crit else v["criterion_id"]

        with st.container(border=True):
            left, right = st.columns([1, 3])
            with left:
                st.markdown(
                    f'<div style="background:{cbg};border-radius:8px;padding:14px;'
                    f'text-align:center;min-height:80px;display:flex;flex-direction:column;'
                    f'align-items:center;justify-content:center;gap:6px;">'
                    f'<div style="font-weight:800;font-size:0.82rem;color:{cfg_};">{clabel}</div>'
                    f'<div style="font-size:0.7rem;color:{cfg_};opacity:0.75;">{mand_txt}</div>'
                    f'</div>',
                    unsafe_allow_html=True,
                )
                confidence_bar(v.get("combined_confidence", 0.0), "Certainty")
            with right:
                st.markdown(
                    f'<div style="font-weight:700;font-size:0.9rem;color:var(--text-color);">'
                    f'{v["criterion_id"]}: {title}</div>',
                    unsafe_allow_html=True,
                )
                explanation = _explain(v, crit)
                if explanation:
                    st.markdown(
                        f'<p style="font-size:0.875rem;color:var(--text-color);'
                        f'opacity:0.85;margin:8px 0;">{explanation}</p>',
                        unsafe_allow_html=True,
                    )
                src = v.get("source") or {}
                if src:
                    doc, page = src.get("doc_name", ""), src.get("page", "")
                    tier_labels = {"text_pdf": "typed PDF", "tesseract": "Tesseract OCR",
                                   "vision_llm": "Vision LLM"}
                    tier = tier_labels.get(src.get("source_type", ""), "")
                    st.markdown(
                        f'<div style="display:inline-flex;align-items:center;gap:6px;'
                        f'background:rgba(128,128,128,0.08);border:1px solid rgba(128,128,128,0.2);'
                        f'border-radius:6px;padding:5px 10px;font-size:0.78rem;">'
                        f'<span>📄</span>'
                        f'<strong style="color:#3B82F6;">{doc}</strong>'
                        f'<span style="color:var(--text-color);opacity:0.5;">page {page}</span>'
                        f'<span style="color:var(--text-color);opacity:0.3;">·</span>'
                        f'<span style="color:var(--text-color);opacity:0.6;">{tier}</span>'
                        f'</div>',
                        unsafe_allow_html=True,
                    )
                    doc_path = DATA_DIR / "bidders" / bid / doc
                    if doc_path.exists() and doc_path.suffix.lower() == ".pdf":
                        with st.expander(f"View source: {doc}, page {page}", expanded=False):
                            try:
                                img = render_page_to_image(doc_path, int(page))
                                st.image(img, caption=f"{doc} — Page {page}",
                                         use_column_width=True)
                            except Exception:
                                st.caption("Page preview unavailable.")
                    elif doc_path.exists() and doc_path.suffix.lower() in {".png", ".jpg"}:
                        with st.expander(f"View: {doc}", expanded=False):
                            st.image(str(doc_path), use_column_width=True)

    st.divider()

    st.markdown(
        '<div style="font-size:1rem;font-weight:700;color:var(--text-color);margin-bottom:4px;">'
        'Ask About This Evaluation</div>'
        '<p style="font-size:0.82rem;color:var(--text-color);opacity:0.6;margin-bottom:12px;">'
        'Answers cite specific documents and pages.</p>',
        unsafe_allow_html=True,
    )

    with st.expander("Example questions", expanded=False):
        for e in ["Why was this bidder rejected?",
                  "What turnover figure was found, and from which document?",
                  "Does this bidder have a valid ISO 9001:2015 certificate?",
                  "Why is the turnover verdict in review?"]:
            st.markdown(f"- _{e}_")

    question = st.text_input("", placeholder="Ask anything about this bidder's evaluation…",
                             key=f"qa_{bid}", label_visibility="collapsed")
    if st.button("Get Answer", type="primary", key=f"qa_btn_{bid}"):
        if not question.strip():
            st.warning("Please enter a question.")
        else:
            context = _qa_context(bid, verdicts, criteria)
            with st.spinner("Looking up the answer…"):
                answer = _answer(question, context)
            st.markdown(
                f'<div style="background:rgba(37,99,235,0.08);'
                f'border:1px solid rgba(37,99,235,0.2);border-radius:10px;'
                f'padding:16px 18px;margin-top:8px;">'
                f'<div style="font-size:0.72rem;font-weight:700;color:#3B82F6;'
                f'text-transform:uppercase;letter-spacing:0.07em;margin-bottom:8px;">Answer</div>'
                f'<div style="font-size:0.9rem;color:var(--text-color);line-height:1.7;">'
                f'{answer}</div></div>',
                unsafe_allow_html=True,
            )
            with st.expander("Full context used", expanded=False):
                st.code(context, language="text")