"""Shared output helpers for the Analysis and Proposal screens.

This module holds the small, reusable pieces both screens rely on:

* clean, user-facing status copy that never leaks provider/model names,
  task names, prompt sizes, or raw error text;
* the mapping from an internal stage-meta dict to a clean user state;
* the developer-only stage-detail renderer (used only when
  ``SHOW_DEBUG_PANEL=true``).

Keeping these here means the visible screens stay focused on layout while
the "what may the user see" rules live in one place.
"""

from __future__ import annotations

import streamlit as st

from app.ui import theme


SUB_SCORE_LABELS = {
    "profile_fit": "Profile Fit",
    "portfolio_proof": "Portfolio Proof",
    "client_quality": "Client Quality",
    "competition": "Competition",
    "budget_value": "Budget / Value",
}


# Beginner-checklist result → status-chip kind.
_BEGINNER_RESULT_CHIP = {
    "Apply Confidently": "ready",
    "Proceed With Caution": "neutral",
    "Do Not Proceed": "missing",
}


# Clean user-facing strings — surfaced regardless of provider/status.
USER_FACING_ERROR = (
    "Analysis could not be completed because the AI service failed. "
    "Please try again."
)
USER_FACING_BASIC_MODE = "Analysis completed in basic mode."


def confidence_badge(label: str) -> str:
    color = {"HIGH": "🟢", "MEDIUM": "🟡", "LOW": "🔴"}.get(label, "⚪")
    return f"{color} {label}"


# Backwards-compatible private alias (kept for any existing imports).
_confidence_badge = confidence_badge


def _stage_user_state(meta: dict) -> str:
    """Map an internal stage meta dict to a user-facing state.

    Returns one of: ``"ok"`` (API ran cleanly), ``"basic"`` (deterministic
    fallback used), ``"error"`` (API failed and no fallback allowed).
    """
    meta = meta or {}
    if meta.get("used_api"):
        return "ok"
    if (meta.get("status") or "") == "local_placeholder":
        return "basic"
    return "error"


def _render_stage_banner_clean(state: str) -> None:
    """Render a single clean user-facing banner per stage.

    Never names the provider, model, task name, or raw error reason on
    the main UI. Technical details are only available behind the debug
    panel.
    """
    if state == "ok":
        return
    if state == "basic":
        st.info(USER_FACING_BASIC_MODE)
        return
    st.error(USER_FACING_ERROR)


def render_clean_stage_banner(*states: str) -> None:
    """Render one consolidated clean banner covering several stages."""
    if "error" in states:
        st.error(USER_FACING_ERROR)
    elif "basic" in states:
        st.info(USER_FACING_BASIC_MODE)


def _render_debug_stage_details(*, match_meta: dict, rec_meta: dict) -> None:
    """Render technical per-stage details (debug panel only)."""

    def _row(meta: dict, label: str, task_name: str) -> None:
        used_api = bool(meta.get("used_api"))
        status = meta.get("status") or "—"
        provider = meta.get("provider") or "—"
        model = meta.get("model") or "—"
        error_message = meta.get("error_message") or ""
        if used_api:
            st.success(f"`{task_name}` used LLM API (`{provider}` / `{model}`).")
        elif status == "local_placeholder":
            st.warning(
                f"LOCAL FALLBACK — API NOT USED for `{task_name}`. "
                + (error_message or f"{label} reverted to deterministic logic.")
            )
        else:
            st.error(
                f"LLM call for `{task_name}` failed (`{status}`). "
                + (error_message or f"{label} could not run via the API.")
            )

    _row(match_meta or {}, "Opportunity matching", "opportunity_matching")
    _row(rec_meta or {}, "Recommendation reasoning", "recommendation_generation")


def _render_debug_score_components(score_result) -> None:
    """Render per-component score provenance (debug panel only).

    Shows the evidence IDs, per-component confidence, and ``source`` that
    are intentionally hidden from the normal UI. ``score_result`` may be a
    plain object without ``components`` (older callers / tests) — those
    are skipped gracefully.
    """
    components = getattr(score_result, "components", {}) or {}
    if not components:
        return
    st.markdown("**Score components:**")
    fp = getattr(score_result, "job_fingerprint", "")
    if fp:
        st.caption(f"scored for job_fingerprint `{fp}`")
    for key, comp in components.items():
        label = SUB_SCORE_LABELS.get(key, key)
        value = getattr(comp, "value", 0)
        max_value = getattr(comp, "max_value", 0)
        confidence = getattr(comp, "confidence", "—")
        source = getattr(comp, "source", "—")
        ids = getattr(comp, "evidence_ids_used", []) or []
        st.write(
            f"- **{label}** {value}/{max_value} · confidence `{confidence}` · "
            f"source `{source}`"
        )
        if ids:
            st.caption("evidence: " + ", ".join(f"`{i}`" for i in ids))


# ---------------------------------------------------------------------------
# Beginner Job Check
# ---------------------------------------------------------------------------


def render_beginner_check_card(beginner_eval: dict, *, show_debug: bool = False) -> None:
    """Render the clean, user-facing Beginner Job Check card.

    Shows only the result chip and at most two short reasons. Raw extracted
    field internals and rule-engine details are never shown here — they
    appear only inside the debug breakdown (``show_debug=True``).
    """
    if not beginner_eval:
        return
    result = beginner_eval.get("result") or "—"
    reasons = (beginner_eval.get("reasons") or [])[:2]
    with st.container(border=True):
        theme.section_label("Beginner Job Check")
        st.markdown(
            theme.status_chip(result, _BEGINNER_RESULT_CHIP.get(result, "neutral")),
            unsafe_allow_html=True,
        )
        for reason in reasons:
            st.write(f"- {reason}")
        if show_debug:
            _render_debug_beginner_details(beginner_eval)


def _render_debug_beginner_details(beginner_eval: dict) -> None:
    """Render the full beginner rule breakdown (debug panel only)."""
    be = beginner_eval or {}
    fields = be.get("fields", {}) or {}
    st.markdown("**Beginner evaluator breakdown:**")

    pay = fields.get("payment_verification", {})
    st.write(
        f"- Payment verification: `{pay.get('result', '—')}` "
        f"(value: {pay.get('value', '—')})"
    )
    pc = fields.get("proposal_count", {})
    st.write(
        f"- Proposal count bucket: `{pc.get('bucket', '—')}` "
        f"(count: {pc.get('count', '—')})"
    )
    pa = fields.get("posted_age", {})
    st.write(
        f"- Posted age bucket: `{pa.get('bucket', '—')}` "
        f"(age_days: {pa.get('age_days', '—')})"
    )
    cr = fields.get("client_rating", {})
    st.write(
        f"- Client rating warning: `{'yes' if cr.get('warning') else 'no'}` "
        f"(rating: {cr.get('rating', '—')})"
    )
    ex = fields.get("experience_level", {})
    st.write(
        f"- Experience level warning: `{'yes' if ex.get('warning') else 'no'}` "
        f"(level: {ex.get('level', '—')})"
    )
    st.write(f"- Triggered rule: `{be.get('triggered_rule', '—')}`")
    if be.get("missing_fields"):
        st.caption("Not visible: " + ", ".join(be["missing_fields"]))