"""ENGIN industrial diagnostic console built on the tested application core."""

from __future__ import annotations

import html
import logging
from dataclasses import dataclass
from pathlib import Path

import numpy as np
import pandas as pd
import streamlit as st

from engin.charts import cylinder_spectrum, deviation_chart, engine_heatmap
from engin.config import (
    LABEL_COLORS,
    LABEL_DISPLAY,
    LABEL_ICONS,
    NOT_APPLICABLE,
    SEVERITY_DISPLAY,
    AppConfig,
)
from engin.errors import UserFacingError
from engin.explainability import (
    analyze_engine,
    explain_cylinder,
    rank_cylinders,
    summarize_engine,
)
from engin.io import PandasCsvReader
from engin.model import PrecomputedPredictionModel, SklearnPredictionModel
from engin.service import DiagnosisResult, DiagnosticService
from engin.validation import SpectrumFrameValidator

LOGGER = logging.getLogger("engin.app")
BASE_DIR = Path(__file__).resolve().parent
MODEL_VERSION = "engin-2026.08.25-1"
MODEL_ARTIFACT_DIR = BASE_DIR / "artifacts" / MODEL_VERSION


@dataclass(frozen=True)
class AppDependencies:
    service: DiagnosticService
    demo_payload: bytes
    live_inference: bool = True
    startup_warning: str | None = None
    model_version: str = "unknown"


def _reader() -> PandasCsvReader:
    return PandasCsvReader(AppConfig().max_upload_bytes)


@st.cache_resource(show_spinner="Ładowanie modelu diagnostycznego…")
def build_dependencies() -> AppDependencies:
    reader = _reader()
    validator = SpectrumFrameValidator()
    demo_path = BASE_DIR / "test.csv"
    demo_payload = demo_path.read_bytes()
    try:
        model = SklearnPredictionModel.from_artifact(
            MODEL_ARTIFACT_DIR,
            expected_model_version=MODEL_VERSION,
        )
        return AppDependencies(
            service=DiagnosticService(reader=reader, validator=validator, model=model),
            demo_payload=demo_payload,
            model_version=MODEL_VERSION,
        )
    except Exception:
        LOGGER.exception("Live model initialization failed; enabling demo fallback")
        submission = pd.read_csv(BASE_DIR / "predictions.csv")
        diagnostics = pd.read_csv(BASE_DIR / "prediction_diagnostics.csv")
        fallback = PrecomputedPredictionModel(submission, diagnostics)
        return AppDependencies(
            service=DiagnosticService(reader=reader, validator=validator, model=fallback),
            demo_payload=demo_payload,
            live_inference=False,
            startup_warning=(
                "Artefakt modelu nie został załadowany. Aplikacja działa w bezpiecznym "
                "trybie demonstracyjnym na zapisanych predykcjach."
            ),
            model_version="demo-precomputed",
        )


@st.cache_data(show_spinner="Analiza widm i klasyfikacja cylindrów…")
def diagnose_payload(_service: DiagnosticService, payload: bytes) -> DiagnosisResult:
    return _service.diagnose_bytes(payload)


def _load_css() -> None:
    css_path = BASE_DIR / "assets" / "app.css"
    st.markdown(f"<style>{css_path.read_text(encoding='utf-8')}</style>", unsafe_allow_html=True)


def _render_error(error: UserFacingError) -> None:
    st.error(f"**{error.title}**\n\n{error.message}")
    if error.hint:
        st.info(error.hint)
    st.caption(f"Kod błędu: `{error.code}`")


def _format_confidence(value: float | int | None) -> str:
    if value is None or pd.isna(value):
        return "—"
    return f"{100 * float(value):.0f}%"


def _render_header(live_inference: bool) -> None:
    mode = "LIVE INFERENCE" if live_inference else "DEMO FALLBACK"
    st.markdown(
        f"""
        <div class="product-header">
          <div>
            <div class="eyebrow">AESTEEL · DIESEL INJECTION DIAGNOSTICS</div>
            <h1>ENGIN Diagnostic Console</h1>
            <p>Akustyczna diagnostyka każdego cylindra — typ usterki, nasilenie i uzasadnienie.</p>
          </div>
          <div class="runtime-badge">● {mode}<br><span>CPU · LEAKAGE-SAFE</span></div>
        </div>
        """,
        unsafe_allow_html=True,
    )


def _render_summary(summary) -> None:
    st.markdown(
        f"""
        <div class="status-strip status-{html.escape(summary.status_tone)}">
          <div><span>STATUS SILNIKA</span><strong>{html.escape(summary.status)}</strong></div>
          <div><span>NAJWYŻSZE NASILENIE</span><strong>{html.escape(summary.highest_severity_display)}</strong></div>
          <div><span>WYMAGA UWAGI</span><strong>{summary.attention} / {summary.cylinders}</strong></div>
          <div><span>ŚR. SCORE MODELU</span><strong>{_format_confidence(summary.mean_confidence)}</strong></div>
        </div>
        """,
        unsafe_allow_html=True,
    )


def _select_cylinder(session_key: str, cylinder: int) -> None:
    st.session_state[session_key] = cylinder


def _render_cylinder_grid(analysis, session_key: str) -> None:
    st.markdown("### Mapa cylindrów")
    columns = st.columns(4)
    selected_cylinder = int(st.session_state[session_key])
    for index, row in analysis.diagnostics.iterrows():
        cylinder = int(row["cylinder"])
        label = str(row["label"])
        severity = str(row["severity"])
        icon = LABEL_ICONS[label]
        short_label = LABEL_DISPLAY[label]
        if severity != NOT_APPLICABLE:
            short_label += f" · {SEVERITY_DISPLAY[severity]}"
        button_label = f"{icon}  C{cylinder:02d}\n{short_label}"
        with columns[index % 4]:
            st.button(
                button_label,
                key=f"cylinder_{analysis.engine_id}_{cylinder}",
                width="stretch",
                type="primary" if cylinder == selected_cylinder else "secondary",
                on_click=_select_cylinder,
                args=(session_key, cylinder),
            )


def _render_engine_overview(analysis) -> None:
    left, right = st.columns([1.45, 1.0], gap="large")
    with left:
        st.plotly_chart(engine_heatmap(analysis), width="stretch", key=f"heatmap_{analysis.engine_id}")
    with right:
        st.markdown("### Priorytet kontroli")
        ranking = rank_cylinders(analysis).head(6).copy()
        ranking["Cylinder"] = ranking["cylinder"].map(lambda value: f"C{int(value):02d}")
        ranking["Diagnoza"] = ranking["label_display"]
        ranking["Nasilenie"] = ranking["severity_display"]
        ranking["Score modelu"] = ranking["label_confidence"].map(_format_confidence)
        ranking["Priorytet"] = ranking["priority_display"]
        st.dataframe(
            ranking[["Cylinder", "Diagnoza", "Nasilenie", "Score modelu", "Priorytet"]],
            hide_index=True,
            width="stretch",
            height=315,
        )
        st.caption("Kolejność: severity, odchylenie widma, następnie score modelu. Score nie jest skalibrowanym prawdopodobieństwem.")


def _render_cylinder_detail(analysis, cylinder: int) -> None:
    explanation = explain_cylinder(analysis, cylinder)
    row = analysis.diagnostics[analysis.diagnostics["cylinder"].eq(cylinder)].iloc[0]
    color = LABEL_COLORS[explanation.label]
    severity_confidence = row.get("severity_confidence", np.nan)
    st.markdown(
        f"""
        <div class="diagnosis-card" style="--diagnosis-color:{color}">
          <div>
            <span class="diagnosis-kicker">CYLINDER {explanation.cylinder:02d}</span>
            <h2>{html.escape(explanation.label_display)}</h2>
            <p>{html.escape(explanation.severity_display)}</p>
          </div>
          <div class="diagnosis-metrics">
            <div><span>Score label</span><strong>{_format_confidence(explanation.confidence)}</strong></div>
            <div><span>Score severity</span><strong>{_format_confidence(severity_confidence)}</strong></div>
            <div><span>Średnie odchylenie</span><strong>{explanation.anomaly_score:.1f} mV</strong></div>
          </div>
        </div>
        """,
        unsafe_allow_html=True,
    )
    spectrum_col, deviation_col = st.columns([1.25, 1.0], gap="large")
    with spectrum_col:
        st.plotly_chart(
            cylinder_spectrum(analysis, cylinder),
            width="stretch",
            key=f"spectrum_{analysis.engine_id}_{cylinder}",
        )
    with deviation_col:
        st.plotly_chart(
            deviation_chart(analysis, cylinder),
            width="stretch",
            key=f"deviation_{analysis.engine_id}_{cylinder}",
        )

    why, next_step = st.columns(2, gap="large")
    with why:
        st.markdown("#### Dlaczego taka diagnoza?")
        st.write(explanation.reason)
        frequencies = " · ".join(f"{value} kHz" for value in explanation.top_frequencies)
        st.markdown(f"**Najbardziej anomalne pasma:** `{frequencies}`")
    with next_step:
        st.markdown("#### Rekomendowany następny krok")
        st.write(explanation.recommendation)
        source_label = "Reguła OOD" if explanation.decision_source == "ood_override" else "Klasyfikator spektralny"
        st.caption(f"Źródło decyzji: {source_label}")
        st.caption("Score modelu służy do porównania predykcji; nie jest kalibrowanym prawdopodobieństwem awarii.")


def _render_technical(result: DiagnosisResult) -> None:
    st.markdown("### Kontrola jakości i architektura")
    c1, c2, c3, c4 = st.columns(4)
    c1.metric("Grouped Macro F1", "0.981")
    c2.metric("Severity accuracy", "0.930")
    c3.metric("Walidacyjne ML", "33.65 / 40")
    c4.metric("Bramka jakości", "CI GREEN")
    st.markdown(
        """
        - **Zero leakage:** każdy fold zawiera kompletne, wcześniej niewidziane silniki.
        - **Odporność na braki:** wynik sprawdzony przy dokładnie 5% zamaskowanych komórek widma.
        - **CPU-first:** Logistic Regression + Extra Trees, bez GPU i z deterministycznymi seedami.
        - **Explainability:** każda diagnoza korzysta z referencji pozostałych cylindrów tego samego silnika.
        """
    )
    with st.expander("Pokaż dane diagnostyczne"):
        st.dataframe(result.diagnostics, width="stretch", hide_index=True)


def render_app(dependencies: AppDependencies | None = None) -> None:
    st.set_page_config(
        page_title="ENGIN Diagnostic Console",
        page_icon="⚙️",
        layout="wide",
        initial_sidebar_state="expanded",
    )
    _load_css()
    deps = dependencies or build_dependencies()
    _render_header(deps.live_inference)

    with st.sidebar:
        st.markdown("## Centrum diagnostyczne")
        source = st.radio(
            "Źródło danych",
            ["Dane demonstracyjne", "Wgraj plik CSV"],
            captions=["50 silników testowych", "Własne kompletne silniki 8/12/16"],
        )
        payload: bytes | None
        if source == "Dane demonstracyjne":
            payload = deps.demo_payload
            st.success("Załadowano bezpieczny zestaw demonstracyjny")
        else:
            uploaded = st.file_uploader("Plik pomiarowy CSV", type=["csv"])
            payload = uploaded.getvalue() if uploaded is not None else None
            if payload is None:
                st.info("Wgraj CSV, aby rozpocząć diagnozę.")
                st.caption("Wymagane: kompletne silniki oraz mV_0...mV_20.")

    if deps.startup_warning:
        st.warning(deps.startup_warning)
    if payload is None:
        st.markdown("### Oczekiwanie na dane")
        st.write("Po wgraniu pliku aplikacja zweryfikuje strukturę przed uruchomieniem modelu.")
        return

    try:
        result = diagnose_payload(deps.service, payload)
    except UserFacingError as exc:
        _render_error(exc)
        return
    except Exception:
        LOGGER.exception("Unexpected application failure")
        st.error("**Nieoczekiwany błąd aplikacji**\n\nDiagnoza została bezpiecznie przerwana; dane nie zostały zmodyfikowane.")
        st.info("Uruchom aplikację ponownie lub użyj zestawu demonstracyjnego.")
        return

    for warning in result.warnings:
        st.warning(warning)

    with st.sidebar:
        engine_id = st.selectbox("Aktywny silnik", result.engine_ids)
        st.download_button(
            "Pobierz predictions.csv",
            data=result.submission.to_csv(index=False).encode("utf-8"),
            file_name="predictions.csv",
            mime="text/csv",
            width="stretch",
        )
        st.download_button(
            "Pobierz diagnostykę",
            data=result.diagnostics.to_csv(index=False).encode("utf-8"),
            file_name="prediction_diagnostics.csv",
            mime="text/csv",
            width="stretch",
        )
        st.divider()
        st.caption(
            f"Model {deps.model_version} · CPU inference · brak połączeń zewnętrznych"
        )

    analysis = analyze_engine(result, str(engine_id))
    summary = summarize_engine(analysis)
    _render_summary(summary)

    session_key = f"selected_cylinder_{analysis.engine_id}"
    available = analysis.measurements["cylinder"].astype(int).tolist()
    if session_key not in st.session_state or st.session_state[session_key] not in available:
        st.session_state[session_key] = summary.top_cylinder
    _render_cylinder_grid(analysis, session_key)

    overview_tab, detail_tab, technical_tab = st.tabs(
        ["Przegląd silnika", "Szczegóły cylindra", "Walidacja i model"]
    )
    with overview_tab:
        _render_engine_overview(analysis)
    with detail_tab:
        selected_from_box = st.selectbox(
            "Cylinder do analizy",
            available,
            format_func=lambda value: f"Cylinder {value:02d}",
            key=session_key,
        )
        _render_cylinder_detail(analysis, int(selected_from_box))
    with technical_tab:
        _render_technical(result)


if __name__ == "__main__":
    render_app()