from __future__ import annotations

import os
from datetime import datetime, timezone

import pandas as pd
import streamlit as st
from dotenv import load_dotenv

from resumesort import AnalysisSettings, analyze_resumes, ui
from resumesort.llm import TinkerLLM
from resumesort.pipeline import build_audit_log, reports_to_dataframe, reports_to_json
from resumesort.report_pdf import build_candidate_pdf
from resumesort.sample_data import load_sample_reports


load_dotenv()

DEFAULT_JD = """We are hiring Software Development Engineers who are passionate about building scalable backend systems,
designing APIs, and working with real-time data. Candidates must have strong fundamentals in Python
and experience with FastAPI, MongoDB, and RESTful services.

We value open-source contributions and expect candidates to showcase real-world projects, preferably on GitHub,
demonstrating skills in backend development, cloud-native systems, or machine learning pipelines.

The ideal candidate will have hands-on experience with FastAPI or Flask/Django, NoSQL databases like MongoDB,
real-time data processing or API integrations, basic ML pipeline knowledge, leadership, and a CGPA above 7.5.
"""

st.set_page_config(page_title="Grifter Filter", page_icon="🔎", layout="wide")
ui.inject_css()


def sidebar_settings() -> AnalysisSettings:
    st.sidebar.markdown('<div class="gf-kicker">Grifter Filter</div>', unsafe_allow_html=True)
    st.sidebar.caption("Evidence-backed resume ranking")

    github_token = os.getenv("GITHUB_TOKEN") or None

    blind_mode = st.sidebar.toggle(
        "Blind screening",
        value=False,
        help="Redacts name, email, GitHub handle, CGPA, and education lines from LLM prompts and all views/exports.",
    )
    deep_fraud = st.sidebar.toggle(
        "Deep fraud checks",
        value=bool(github_token),
        disabled=not github_token,
        help="Contributor share, commit timelines, and root-file checks. Requires a GitHub token.",
    )

    with st.sidebar.expander("Scoring weights"):
        jd_weight = st.slider("JD fit", 0.0, 1.0, 0.45, 0.05)
        verification_weight = st.slider("Verification", 0.0, 1.0, 0.35, 0.05)
        authenticity_weight = st.slider("Authenticity", 0.0, 1.0, 0.20, 0.05)
        total = (jd_weight + verification_weight + authenticity_weight) or 1.0
        st.caption(
            f"Normalized: {jd_weight / total:.0%} fit · {verification_weight / total:.0%} "
            f"verification · {authenticity_weight / total:.0%} authenticity"
        )

    with st.sidebar.expander("Engine & limits"):
        tinker_model = st.text_input("Tinker model", value=os.getenv("TINKER_BASE_MODEL", "openai/gpt-oss-20b"))
        use_tinker = st.toggle("Use Tinker", value=bool(os.getenv("TINKER_API_KEY")))
        max_claims = st.slider("Claims per resume", 3, 15, 8)
        max_repos = st.slider("GitHub repos to inspect", 5, 30, 10)

    tinker_badge = ":green-badge[Tinker connected]" if os.getenv("TINKER_API_KEY") and use_tinker else ":gray-badge[Tinker off — heuristics]"
    github_badge = ":green-badge[GitHub token]" if github_token else ":orange-badge[GitHub anonymous — shallow]"
    st.sidebar.markdown(f"{tinker_badge}  \n{github_badge}")

    return AnalysisSettings(
        tinker_base_model=tinker_model,
        github_token=github_token,
        use_tinker=use_tinker,
        max_claims=max_claims,
        max_repos=max_repos,
        jd_fit_weight=jd_weight,
        verification_weight=verification_weight,
        authenticity_weight=authenticity_weight,
        deep_fraud_checks=deep_fraud,
        blind_mode=blind_mode,
    )


def analyze_form(settings: AnalysisSettings, collapsed: bool) -> None:
    container = st.expander("New screening", expanded=False) if collapsed else st.container(border=True)
    with container:
        if not collapsed:
            st.markdown("**New screening**")
        upload_col, jd_col = st.columns([3, 2])
        with upload_col:
            uploaded_files = st.file_uploader("PDF resumes", type=["pdf"], accept_multiple_files=True)
        with jd_col:
            job_description = st.text_area("Job description", value=DEFAULT_JD, height=180)

        config_chips = [f":gray-badge[{settings.tinker_base_model.split('/')[-1]}]"]
        if settings.blind_mode:
            config_chips.append(":violet-badge[blind]")
        if settings.deep_fraud_checks:
            config_chips.append(":blue-badge[deep fraud]")
        weights_total = (settings.jd_fit_weight + settings.verification_weight + settings.authenticity_weight) or 1.0
        config_chips.append(
            f":gray-badge[{settings.jd_fit_weight / weights_total:.0%}/"
            f"{settings.verification_weight / weights_total:.0%}/"
            f"{settings.authenticity_weight / weights_total:.0%}]"
        )
        st.markdown(" ".join(config_chips))

        run = st.button(
            "Analyze resumes",
            type="primary",
            disabled=not uploaded_files or not job_description.strip(),
        )
        if run:
            started_at = datetime.now(timezone.utc).isoformat()
            with st.status("Analyzing resumes...", expanded=True) as status:
                reports = analyze_resumes(
                    uploaded_files,
                    job_description,
                    settings,
                    progress_callback=status.write,
                )
                status.update(label="Analysis complete", state="complete")
            st.session_state["reports"] = reports
            st.session_state["run_meta"] = {
                "started_at": started_at,
                "finished_at": datetime.now(timezone.utc).isoformat(),
                "settings": settings,
                "job_description": job_description,
                "sample": False,
            }
            st.toast(f"Screened {len(reports)} candidate(s)", icon="✅")
            st.rerun()


def render_landing(settings: AnalysisSettings) -> None:
    ui.render_hero()
    st.write("")
    ui.render_value_props()
    st.write("")
    cta_col, status_col = st.columns([1, 2], vertical_alignment="center")
    with cta_col:
        if st.button("Try sample data", type="primary"):
            st.session_state["reports"] = load_sample_reports()
            st.session_state["run_meta"] = {
                "started_at": datetime.now(timezone.utc).isoformat(),
                "finished_at": datetime.now(timezone.utc).isoformat(),
                "settings": settings,
                "job_description": DEFAULT_JD,
                "sample": True,
            }
            st.toast("Sample screening loaded — three fictional candidates", icon="🧪")
            st.rerun()
    with status_col:
        status = TinkerLLM(settings.tinker_base_model, enabled=settings.use_tinker).status
        suffix = f" ({status.reason})" if status.reason else ""
        st.caption(f"Engine: {status.provider}{suffix}")


def render_results(settings: AnalysisSettings) -> None:
    reports = ui.get_reports()
    run_meta = st.session_state.get("run_meta", {})
    run_settings: AnalysisSettings = run_meta.get("settings", settings)
    blind = bool(run_settings.blind_mode)
    if blind != settings.blind_mode:
        st.caption("Blind-screening change takes effect on the next analysis run.")
    if run_meta.get("sample"):
        st.markdown(":violet-badge[sample data] &nbsp; Fictional candidates for demo purposes.")

    shortlist = ui.get_shortlist()
    labels = [ui.candidate_label(report, blind, index) for index, report in enumerate(reports)]

    # --- KPI strip ---
    total_claims = sum(len(r.verdicts) for r in reports)
    supported_claims = sum(1 for r in reports for v in r.verdicts if v.verdict == "SUPPORTED")
    high_signals = sum(1 for r in reports for s in r.fraud_signals if s.severity == "high")
    kpi_cols = st.columns(4)
    kpi_cols[0].metric("Candidates", len(reports), border=True)
    kpi_cols[1].metric("Top candidate", labels[0], delta=f"{reports[0].scores.final_score:.1f}", border=True)
    kpi_cols[2].metric("Claims supported", f"{supported_claims}/{total_claims}", border=True)
    kpi_cols[3].metric("High-risk signals", high_signals, border=True)

    # --- Toolbar: heading + run health + export ---
    heading_col, health_col, export_col = st.columns([4, 1, 1], vertical_alignment="center")
    heading_col.subheader("Ranking")
    llm_calls = sum(report.llm_api_calls for report in reports)
    llm_successes = sum(report.llm_api_successes for report in reports)
    llm_parse_failures = sum(report.llm_parse_failures for report in reports)
    llm_truncations = sum(report.llm_truncations for report in reports)
    llm_errors = [report.llm_error for report in reports if report.llm_error]
    with health_col.popover("Run health"):
        st.markdown(f"**Tinker calls:** {llm_successes}/{llm_calls} succeeded")
        st.markdown(f"**Unusable responses:** {llm_parse_failures} (fell back to heuristics)")
        if llm_truncations:
            st.markdown(f"**Truncated + retried:** {llm_truncations}")
        st.markdown(f"**Provider:** {reports[0].llm_provider}")
        if llm_errors:
            st.error(f"Latest error: {llm_errors[-1]}")
        elif llm_calls and not llm_parse_failures:
            st.success("All LLM calls returned usable output.")
        elif llm_calls:
            st.warning("Some LLM responses were unusable; heuristic fallbacks filled in.")
        else:
            st.info("Run used heuristics only (no LLM calls).")
    with export_col.popover("Export"):
        df_export = reports_to_dataframe(reports, blind=blind)
        st.download_button(
            "CSV ranking",
            data=df_export.to_csv(index=False).encode("utf-8"),
            file_name="grifter_final_ranking.csv",
            mime="text/csv",
        )
        st.download_button(
            "JSON reports",
            data=reports_to_json(reports, blind=blind).encode("utf-8"),
            file_name="grifter_reports.json",
            mime="application/json",
        )
        if run_meta:
            audit = build_audit_log(
                reports, run_settings, run_meta.get("started_at", ""), run_meta.get("finished_at", "")
            )
            st.download_button(
                "Audit log",
                data=audit.encode("utf-8"),
                file_name="grifter_audit_log.json",
                mime="application/json",
            )

    # --- Ranking table (inline status editing) ---
    table = pd.DataFrame(
        {
            "candidate": labels,
            "status": [shortlist.get(ui.shortlist_key(r), "") for r in reports],
            "final": [r.scores.final_score for r in reports],
            "jd_fit": [r.scores.jd_fit_score for r in reports],
            "verification": [r.scores.verification_score for r in reports],
            "authenticity": [r.scores.authenticity_score for r in reports],
            "signals": [len(r.fraud_signals) for r in reports],
            "github": [None if blind else (r.profile.github_url or "") for r in reports],
        }
    )
    edited = st.data_editor(
        table,
        hide_index=True,
        width="stretch",
        disabled=["candidate", "final", "jd_fit", "verification", "authenticity", "signals", "github"],
        column_config={
            "candidate": st.column_config.TextColumn("Candidate", pinned=True),
            "status": st.column_config.SelectboxColumn("Status", options=ui.SHORTLIST_OPTIONS, default=""),
            "final": st.column_config.ProgressColumn("Final", min_value=0, max_value=100, format="%.0f", color="#22B8A8"),
            "jd_fit": st.column_config.NumberColumn("JD fit", format="%.0f"),
            "verification": st.column_config.NumberColumn("Verification", format="%.0f"),
            "authenticity": st.column_config.NumberColumn("Authenticity", format="%.0f"),
            "signals": st.column_config.NumberColumn("Signals"),
            "github": st.column_config.LinkColumn("GitHub", display_text="profile"),
        },
        key="ranking_editor",
    )
    for index, report in enumerate(reports):
        new_status = edited.iloc[index]["status"] or ""
        key = ui.shortlist_key(report)
        if shortlist.get(key, "") != new_status:
            shortlist[key] = new_status
            st.toast(f"{labels[index]}: {new_status or 'status cleared'}")

    # --- Candidate detail ---
    st.subheader("Candidate detail")
    if len(labels) <= 8:
        selected_label = st.pills("Candidate", labels, default=labels[0], label_visibility="collapsed")
    else:
        selected_label = st.selectbox("Candidate", labels)
    if not selected_label:
        return
    selected_index = labels.index(selected_label)
    selected = reports[selected_index]
    selected_key = ui.shortlist_key(selected)

    ui.render_candidate_header(selected, selected_label, blind)

    action_cols = st.columns([2, 3, 2], vertical_alignment="bottom")
    with action_cols[0]:
        current_status = shortlist.get(selected_key, "")
        new_status = st.segmented_control(
            "Decision",
            ["shortlist", "maybe", "reject"],
            default=current_status or None,
            key=f"decision_{selected_key}",
        )
        shortlist[selected_key] = new_status or ""
    with action_cols[1]:
        overrides = ui.get_overrides()
        overrides[selected_key] = st.text_input(
            "Reviewer note (human override)",
            value=overrides.get(selected_key, ""),
            help="Recorded in the audit log. The human decision always wins.",
        )
    with action_cols[2]:
        pdf_display_name = selected_label if blind else None
        pdf_stem = f"candidate_{selected_index + 1}" if blind else selected.profile.source_name.replace(".pdf", "")
        st.download_button(
            "Download PDF report",
            data=build_candidate_pdf(selected, display_name=pdf_display_name),
            file_name=f"grifter_report_{pdf_stem}.pdf",
            mime="application/pdf",
        )

    overview_tab, claims_tab, authenticity_tab, interview_tab = st.tabs(
        ["Overview", "Claims & evidence", "Authenticity", "Interview kit"]
    )
    with overview_tab:
        st.markdown("**Summary**")
        st.write(selected.summary)
        if selected.flags:
            st.markdown(" ".join(f":orange-badge[{flag}]" for flag in selected.flags))
        if not blind:
            fields = {
                "Email": selected.profile.email,
                "GitHub": selected.profile.github_url,
                "CGPA (/10)": selected.profile.cgpa,
                "Claimed experience": (
                    f"{selected.profile.claimed_years_experience:.0f} yrs"
                    if selected.profile.claimed_years_experience
                    else None
                ),
                "Leadership signals": "yes" if selected.profile.leadership else "no",
            }
            field_cols = st.columns(2)
            for i, (label, value) in enumerate([(k, v) for k, v in fields.items() if v is not None]):
                field_cols[i % 2].markdown(
                    f'<p class="gf-field">{label}</p><p class="gf-value">{value}</p>',
                    unsafe_allow_html=True,
                )
        with st.popover("Raw data"):
            st.json(selected.to_dict() if not blind else {"note": "raw data hidden in blind mode"})
    with claims_tab:
        ui.render_claim_cards(selected)
    with authenticity_tab:
        ui.render_fraud_panel(selected)
    with interview_tab:
        ui.render_interview_questions(selected)


settings = sidebar_settings()
ui.render_disclaimer()

has_reports = bool(ui.get_reports())
if not has_reports:
    render_landing(settings)
    st.write("")
analyze_form(settings, collapsed=has_reports)
if has_reports:
    render_results(settings)