"""Screen 6: Proposal.

Generates a grounded proposal from the analysis results and presents it
in a copy-friendly way. Only a small, relevance-filtered subset of the
dossier is ever sent to the AI — the full dossier is never sent, and
evidence IDs / raw API details never appear in the client-facing
proposal. Technical details are gated behind ``SHOW_DEBUG_PANEL=true``.
"""

from __future__ import annotations

import json
import time

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

from app.config import get_settings
from app.services import background_tasks as bg
from app.services.proposal_generator import (
    ProposalGenerationError,
    build_proposal_context,
    generate as generate_proposal,
    recheck_proposal,
)
from app.ui import output_screen, theme

# Background-task name for proposal generation. Each run gets its own id
# (bg.new_task_id), kept in this session under "proposal_task_id".
_PROPOSAL_TASK = "proposal_generation"
# A re-run of the fact-check alone, on the draft already on screen. It is
# polled like a generation run, under the same session keys.
_RECHECK_TASK = "proposal_recheck"

_RECHECK_FAILED_MESSAGE = (
    "Something went wrong in the app while checking the draft again. Your "
    "draft is still below, not fact-checked."
)

# Screen heading and standfirst for an AI draft, by fact-check outcome.
_READY_HEAD = (
    "Your draft is ready",
    "A grounded first draft built only from facts in your dossier. "
    "Read it through, then copy it straight into Upwork.",
)
_CHECK_HEADS = {
    "unverified": (
        "Your draft is ready",
        "The fact-check could not run this time, so this draft has not been "
        "checked against your dossier. Read it closely before you copy it "
        "into Upwork.",
    ),
    "failed": (
        "Your draft needs a closer look",
        "The fact-check found claims your dossier does not support. Read the "
        "flagged claims below the draft before you copy it into Upwork.",
    ),
}

_PROPOSAL_FAILED_MESSAGE = (
    "The AI couldn't write the proposal this time. Wait a minute, then press "
    "Generate Proposal again. If it keeps failing, check the API key on the "
    "Setup screen."
)

# Anything but a provider failure is a fault in the app, not the user's key.
_PROPOSAL_APP_ERROR_MESSAGE = (
    "Something went wrong in the app while writing the proposal. This is not "
    "a problem with your API key. Press Generate Proposal to try again, and "
    "if it keeps failing, share the diagnostics from the sidebar with the "
    "app team."
)


def _copy_button(text: str) -> None:
    """A real one-click copy button (works in deployed Streamlit)."""
    safe = json.dumps(text).replace("</", "<\\/")
    # The button lives in its own component iframe, so it cannot inherit the
    # Aurora stylesheet — the tokens are written inline here instead. Purely
    # presentational; the clipboard behaviour below is unchanged.
    html = f"""
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500&display=swap" rel="stylesheet">
    <style>
      html, body {{ margin: 0; background: transparent; }}
      #ups-copy {{
        border: none; border-radius: 12px; padding: 10px 18px;
        font-family: Inter, ui-sans-serif, system-ui, sans-serif;
        font-size: 14px; font-weight: 500; color: #FFFFFF; cursor: pointer;
        background: linear-gradient(135deg, #7C3AED, #9333EA 55%, #A855F7);
        box-shadow: 0 8px 24px rgba(139, 92, 246, 0.22);
        transition: transform 120ms cubic-bezier(0.2, 0.8, 0.2, 1),
                    box-shadow 120ms cubic-bezier(0.2, 0.8, 0.2, 1);
      }}
      #ups-copy:hover {{ transform: translateY(-1px); box-shadow: 0 10px 28px rgba(139, 92, 246, 0.30); }}
      #ups-copy:active {{ transform: scale(0.98); transition-duration: 80ms; }}
      #ups-copy:focus-visible {{ outline: 2px solid rgba(139, 92, 246, 0.78); outline-offset: 2px; }}
      #ups-copy-msg {{
        margin-left: 12px; color: #22C55E; font-size: 12px;
        font-family: Inter, ui-sans-serif, system-ui, sans-serif;
      }}
      @media (prefers-reduced-motion: reduce) {{
        #ups-copy {{ transition: none; }}
      }}
    </style>
    <button id="ups-copy">Copy Proposal</button>
    <span id="ups-copy-msg"></span>
    <script>
    const btn = document.getElementById('ups-copy');
    const msg = document.getElementById('ups-copy-msg');
    btn.addEventListener('click', async () => {{
        try {{
            await navigator.clipboard.writeText({safe});
            msg.textContent = 'Copied to clipboard';
        }} catch (e) {{
            msg.textContent = 'Press Ctrl/Cmd + C to copy';
        }}
    }});
    </script>
    """
    components.html(html, height=56)


def _flagged_claims(proposal_result: dict) -> list[str]:
    """The claims the fact-check removed or softened, each once, in order."""
    claims = [str(c or "").strip() for c in proposal_result.get("removed_claims") or []]
    claims += [
        str(s.get("original") or "").strip()
        for s in proposal_result.get("softened_claims") or []
        if isinstance(s, dict)
    ]
    return list(dict.fromkeys(c for c in claims if c))


def _start_recheck(proposal_result: dict, *, settings) -> None:
    """Run the fact-check again, in the background, on the draft shown."""
    if st.session_state.get("proposal_generating"):
        return
    task_id = bg.new_task_id(_RECHECK_TASK)
    if bg.start(
        task_id,
        recheck_proposal,
        dict(proposal_result),
        st.session_state.get("confirmed_job_fields") or {},
        settings=settings,
    ):
        st.session_state.proposal_task_id = task_id
        st.session_state.proposal_generating = True
    st.rerun()


def _render_proposal(proposal_result: dict, show_debug: bool, *, settings) -> None:
    prop_meta = proposal_result.get("__meta__") or {}
    verify_meta = proposal_result.get("verification_meta") or {}
    verification_status = proposal_result.get("verification_status")
    # Without the AI the app can only fill a fixed outline from the files.
    # That outline must never pass for a finished proposal.
    written_by_ai = bool(prop_meta.get("used_api"))
    if written_by_ai:
        # A fact-check that could not run gets its own warning below, worded
        # for this screen, instead of the generic stage banner.
        stage_states = [output_screen._stage_user_state(prop_meta)]
        if verification_status != "unverified":
            stage_states.append(output_screen._stage_user_state(verify_meta))
        output_screen.render_clean_stage_banner(*stage_states)
        theme.screen_head(
            "proposal", *_CHECK_HEADS.get(verification_status, _READY_HEAD)
        )
    else:
        theme.screen_head(
            "proposal",
            "AI writing was unavailable",
            "This is only a rough outline, filled in from your files without "
            "the AI. Don't send it as it is: wait a minute, then press "
            "Generate Proposal again.",
        )
        st.warning(
            "Not a finished proposal. The AI service didn't respond this time, "
            "so the outline below is not tailored to the job."
        )

    proposal_text = proposal_result.get("proposal", "")

    # Grounding gate: a draft the fact-check did not confirm is still shown
    # (throwing it away leaves nothing to send), but never as a checked one.
    # A check that could not run says so and offers to run again; a check
    # that failed lists the claims it flagged. Only an empty text has
    # nothing to show.
    if not str(proposal_text or "").strip():
        with st.container(border=True, key="ups_panel_proposal_1"):
            theme.section_label("Proposal not verified")
            st.error(
                "The fact-check left no text to show for this draft. "
                "Please try generating again."
            )
        if show_debug:
            _render_debug_panel(proposal_result, settings=settings)
        return

    if verification_status == "unverified":
        st.warning(
            "Not fact-checked. The check against your dossier could not run "
            "this time, so check every number, client name and tool in this "
            "draft before you send it, or run the check again."
        )
    elif verification_status == "failed":
        st.warning(
            "The fact-check could not confirm parts of this draft against your "
            "dossier. Read the flagged claims below the draft and take out any "
            "that are still in the text before you send it."
        )

    pending_answers = any(
        qa.get("verification_status") == "unverified"
        for qa in proposal_result.get("screening_answers") or []
    )
    if verification_status == "unverified" or pending_answers:
        if st.button(
            "Run fact-check again",
            key="recheck_proposal_btn",
            help="Checks this draft and its screening answers against your dossier without rewriting them.",
        ):
            _start_recheck(proposal_result, settings=settings)

    word_count = proposal_result.get("word_count", 0)
    claims = proposal_result.get("factual_claims") or []
    file_count = len({c.get("source_file") for c in claims if c.get("source_file")})
    theme.proposal_doc(proposal_text, word_count, file_count)

    col_copy, col_dl = st.columns([1, 1])
    with col_copy:
        _copy_button(proposal_text)
    with col_dl:
        st.download_button(
            "Download as .txt",
            data=proposal_text,
            file_name="upwork_proposal.txt",
            mime="text/plain",
            key="download_proposal_btn",
        )

    flagged = _flagged_claims(proposal_result) if verification_status == "failed" else []
    if flagged:
        with st.container(border=True, key="ups_panel_proposal_5"):
            theme.section_label("Flagged by the fact-check")
            for claim in flagged:
                # Plain text: a claim is model output, never markup.
                st.text(f"• {claim}")

    screening_answers = proposal_result.get("screening_answers") or []
    if screening_answers:
        with st.container(border=True, key="ups_panel_proposal_2"):
            theme.section_label("Screening answers")
            for i, qa in enumerate(screening_answers, start=1):
                question = str(qa.get("question") or "").strip()
                answer = str(qa.get("answer") or "").strip()
                if question:
                    st.text(f"Q{i}: {question}")
                answer_status = qa.get("verification_status", "unverified")
                if answer_status == "failed":
                    st.warning("This answer failed its fact-check. Add supporting profile details and regenerate.")
                else:
                    if answer_status not in {"passed", "passed_with_softening"}:
                        st.warning("Draft answer — its fact-check has not passed. Review before sending.")
                    st.text(answer)

    # Start a fresh job without restarting the app.
    st.write("")
    if st.button("Analyze another job", key="new_job_from_proposal_btn",
                 help="Clear this job and upload a new screenshot."):
        from app.ui.screenshot_screen import _clear_screenshots_for_new_job
        _clear_screenshots_for_new_job()
        st.rerun()

    if show_debug:
        _render_debug_panel(proposal_result, settings=settings)


def _render_debug_panel(proposal_result: dict, *, settings) -> None:
    prop_meta = proposal_result.get("__meta__") or {}
    verify_meta = proposal_result.get("verification_meta") or {}
    with st.expander("Developer Debug Panel", expanded=False):
        if prop_meta.get("used_api"):
            st.success(
                f"`proposal_generation` used LLM API "
                f"(`{prop_meta.get('provider')}` / `{prop_meta.get('model')}`)."
            )
        else:
            st.warning("LOCAL PLACEHOLDER — API NOT USED for `proposal_generation`.")
        st.caption(
            f"Evidence points sent: `{prop_meta.get('evidence_points_sent', 0)}` • "
            f"Approx context chars: `{prop_meta.get('compact_context_chars', 0)}` • "
            f"Retry used: `{'yes' if prop_meta.get('retry_used') else 'no'}`"
        )
        if verify_meta.get("used_api"):
            st.success(
                f"Verification used LLM API "
                f"(`{verify_meta.get('provider')}` / `{verify_meta.get('model')}`)."
            )
        else:
            st.warning(
                f"Verification did not run via the LLM API "
                f"(status `{verify_meta.get('status') or 'unknown'}`)."
            )
        claims = proposal_result.get("factual_claims") or []
        st.caption(f"Citation-backed claims surviving verification: {len(claims)}")


def render() -> None:
    if not st.session_state.get("fields_confirmed"):
        debug = bool(getattr(get_settings(), "show_debug_panel", False))
        if debug:
            st.error("This step is locked. Confirm the job details first.")
            if st.button(
                "Back to Confirm Details", key="back_to_confirm_from_proposal"
            ):
                st.session_state.current_step = "confirmation"
                st.rerun()
        else:
            st.error(
                "This step is locked. Extract job details from a screenshot first."
            )
            if st.button(
                "Back to Job Screenshot", key="back_to_screenshot_from_proposal"
            ):
                st.session_state.current_step = "screenshot"
                st.rerun()
        return

    recommendation = st.session_state.get("recommendation_result")
    if not recommendation:
        st.info("Run the analysis first so the proposal can build on it.")
        if st.button("Go to Analysis", key="go_to_analysis_from_proposal"):
            st.session_state.current_step = "analysis"
            st.rerun()
        return

    settings = get_settings()
    show_debug = bool(getattr(settings, "show_debug_panel", False))

    confirmed_job = st.session_state.get("confirmed_job_fields") or {}
    evidence_index = st.session_state.get("evidence_index") or []
    match_data = st.session_state.get("match_data")

    # Screen head rendered inside _render_proposal; show a brief label here.
    st.markdown(
        '<p style="font-family:var(--ff-mono);font-size:10px;letter-spacing:.16em;'
        'text-transform:uppercase;color:var(--text-faint);margin:0 0 .5rem">Proposal</p>',
        unsafe_allow_html=True,
    )

    # The warning follows the verdict the user was shown on the Analysis
    # screen — the job checklist — not the hidden fit-score tier, which could
    # read "Do Not Proceed" under a "Proceed with caution" verdict.
    beginner_eval = (match_data or {}).get("beginner_evaluation")
    if isinstance(beginner_eval, dict) and beginner_eval.get("result"):
        do_not_proceed = bool(beginner_eval.get("instant_no"))
    else:
        do_not_proceed = recommendation.get("verdict") == "Do Not Proceed"

    with st.container(border=True, key="ups_panel_proposal_3"):
        theme.section_label("Generate")

        override_ok = True
        if do_not_proceed:
            st.warning(
                "This opportunity is not strongly recommended. Generate anyway?"
            )
            override_ok = st.checkbox(
                "Yes, generate the proposal anyway", key="proposal_override_checkbox"
            )

        gate_blocked = do_not_proceed and not override_ok
        generate_clicked = st.button(
            "Generate Proposal",
            type="primary",
            disabled=gate_blocked,
            key="generate_proposal_btn",
            help=(
                "Drafts a grounded proposal using only a small, relevant subset "
                "of your evidence."
            ),
        )

        if show_debug:
            preview = build_proposal_context(
                confirmed_job,
                evidence_index,
                match_result=match_data,
                recommendation_result=recommendation,
                max_evidence_points=settings.max_proposal_evidence_points,
                max_context_chars=settings.max_proposal_context_chars,
            )
            pmeta = preview.get("__meta__") or {}
            st.caption(
                f"Debug — evidence points selected: "
                f"{pmeta.get('evidence_points_selected', 0)} • "
                f"candidate data chars before prompt fitting: {pmeta.get('approx_context_chars', 0)}"
            )

        # A click while this session's draft is still being written keeps
        # that run going instead of paying for a duplicate one.
        if (
            generate_clicked
            and not gate_blocked
            and not st.session_state.get("proposal_generating")
        ):
            # Run generation on a BACKGROUND thread so switching steps or
            # browser tabs doesn't kill it. Everything the worker needs is
            # passed explicitly — it never touches st.session_state. The run
            # id lives only in this session, so no other visitor can collect
            # this draft.
            task_id = bg.new_task_id(_PROPOSAL_TASK)
            if bg.start(
                task_id,
                generate_proposal,
                confirmed_job,
                list(evidence_index),
                recommendation,
                match_data=match_data,
                canonical_profile=st.session_state.get("canonical_profile"),
                complexity=None,
                settings=settings,
            ):
                st.session_state.proposal_task_id = task_id
                st.session_state.proposal_generating = True
                st.session_state.verified_proposal = None
                st.session_state.generated_proposal = None
            st.rerun()

    # ── Poll the background generation (runs on every render, so it resumes
    #    even if the user navigated away and came back). ───────────────────
    if st.session_state.get("proposal_generating"):
        task_id = st.session_state.get("proposal_task_id") or ""
        rechecking = task_id.startswith(_RECHECK_TASK + ":")
        tstate = bg.status(task_id)
        if tstate["status"] == "running":
            with st.container(border=True, key="ups_panel_proposal_4"):
                if rechecking:
                    theme.section_label("Fact-checking")
                    st.info(
                        "Checking your draft against your dossier again… this "
                        "keeps running even if you switch to another step or tab."
                    )
                else:
                    theme.section_label("Generating")
                    st.info(
                        "✍️ Writing your proposal… this keeps running even if you "
                        "switch to another step or tab. Come back here anytime — "
                        "your draft will be waiting."
                    )
            time.sleep(1.0)
            st.rerun()
        elif tstate["status"] == "done":
            res = bg.pop(task_id)["result"]
            st.session_state.proposal_generating = False
            st.session_state.proposal_task_id = None
            if res is not None:
                st.session_state.generated_proposal = {
                    "proposal": res.get("draft_proposal") or res.get("proposal", ""),
                    "word_count": res.get("word_count", 0),
                }
                st.session_state.verified_proposal = res
            st.rerun()
        elif tstate["status"] == "error":
            failed = bg.pop(task_id)
            st.session_state.proposal_generating = False
            st.session_state.proposal_task_id = None
            if rechecking:
                # The draft itself is fine: it stays on screen, still marked
                # as not fact-checked.
                st.error(_RECHECK_FAILED_MESSAGE)
            else:
                st.session_state.generated_proposal = None
                st.session_state.verified_proposal = None
                if isinstance(failed.get("exc"), ProposalGenerationError):
                    st.error(_PROPOSAL_FAILED_MESSAGE)
                else:
                    st.error(_PROPOSAL_APP_ERROR_MESSAGE)
                return
        else:  # idle: the run is gone (expired), so there is nothing to collect
            st.session_state.proposal_generating = False
            st.session_state.proposal_task_id = None

    proposal_result = st.session_state.get("verified_proposal")
    if proposal_result:
        _render_proposal(proposal_result, show_debug, settings=settings)