from __future__ import annotations

from pathlib import Path
from sqlite3 import Connection

from jarvis_finance.config.settings import ensure_runtime_dirs, find_repo_root, load_settings
from jarvis_finance.dashboard.demo_data import load_synthetic_demo_data
from jarvis_finance.dashboard.pages import PAGES
from jarvis_finance.dashboard import data as dashboard_data
from jarvis_finance.storage.database import connect
from jarvis_finance.storage.migrations import apply_migrations

USER_PAGE_TITLES = ["Command Center", "Portfolio", "Crypto", "Wallets", "Position hinzufügen", "Reports"]
ADMIN_PAGE_TITLES = ["Ledger", "Audit", "Alerts", "Data Quality", "Import Wizard", "Settings", "Crypto Manage", "Equity/ETF Manage", "Manual Review Queue", "Watchlist", "Portfolio Übersicht"]
TITLE_ALIASES = {"Settings / Data Quality": "Settings", "Data Quality Center": "Data Quality", "Equities/ETFs": "Portfolio"}


def safe_connect_existing_db(db_path: Path) -> Connection | None:
    if not db_path.exists():
        return None
    conn = connect(db_path)
    apply_migrations(conn)
    return conn


def create_demo_db(db_path: Path) -> None:
    db_path.parent.mkdir(parents=True, exist_ok=True)
    conn = connect(db_path)
    try:
        load_synthetic_demo_data(conn)
    finally:
        conn.close()


def get_user_navigation_titles() -> list[str]:
    return list(USER_PAGE_TITLES)


def get_admin_navigation_titles() -> list[str]:
    return list(ADMIN_PAGE_TITLES)


def _display_title(page) -> str:
    return TITLE_ALIASES.get(page.PAGE_TITLE, page.PAGE_TITLE)


def _page_by_display_title() -> dict[str, object]:
    return {_display_title(page): page for page in PAGES}


def run_app() -> None:
    import streamlit as st

    st.set_page_config(page_title="JARVIS Finance", layout="wide")
    st.sidebar.title("JARVIS Finance")
    st.sidebar.caption("Investment Dashboard · lokal · auditierbar")

    try:
        repo_root = find_repo_root()
        settings = load_settings(repo_root=repo_root)
    except Exception as exc:
        st.error(f"Settings-/Runtime-Ladeprüfung fehlgeschlagen: {exc}")
        st.info("Prüfe JARVIS_FINANCE_RUNTIME_DIR. Runtime muss ausserhalb des Repos liegen.")
        return

    ensure_runtime_dirs(settings)
    db_path = settings.db_path
    conn = safe_connect_existing_db(db_path)

    if conn is None:
        st.title("JARVIS Finance Dashboard")
        st.error(f"Keine lokale SQLite-DB gefunden: {db_path}")
        st.info("Das Dashboard erstellt oder verändert keine echte Datenbank automatisch.")
        st.caption("Für lokale Entwicklung kann explizit eine synthetische Dummy-DB aus tests/fixtures geladen werden.")
        if st.button("Synthetische Dummy-DB jetzt erstellen", type="primary"):
            create_demo_db(db_path)
            st.success("Synthetische Dummy-DB erstellt. Bitte Seite neu laden.")
        return

    try:
        page_map = _page_by_display_title()
        mode = st.sidebar.radio("Modus", ["User Mode", "Admin / Review / Debug"], index=0)
        st.sidebar.markdown("---")
        if mode == "User Mode":
            names = [name for name in USER_PAGE_TITLES if name in page_map]
            requested = st.session_state.pop("jarvis_requested_page", None) if hasattr(st, "session_state") else None
            default_index = names.index(requested) if requested in names else 0
            if requested in names and hasattr(st, "session_state"):
                st.session_state["jarvis_user_navigation"] = requested
            selected = st.sidebar.radio("Hauptnavigation", names, index=default_index, key="jarvis_user_navigation")
            st.sidebar.caption("Technische IDs und Rohdaten sind im User Mode ausgeblendet.")
        else:
            user_default = [name for name in USER_PAGE_TITLES if name in page_map]
            admin_names = [name for name in ADMIN_PAGE_TITLES if name in page_map]
            selected = st.sidebar.radio("Admin / Daten", admin_names or user_default, index=0)
            st.sidebar.warning("Admin Mode: technische IDs, Rohdaten und Review-Details sichtbar.")
        st.session_state["jarvis_dashboard_mode"] = mode
        st.session_state["jarvis_admin_mode"] = mode != "User Mode"
        edit_enabled = bool(st.sidebar.toggle("Bearbeiten aktivieren", value=bool(st.session_state.get("jarvis_edit_mode", False))))
        st.session_state["jarvis_edit_mode"] = edit_enabled
        if edit_enabled:
            st.sidebar.warning("Edit Mode aktiv: Änderungen schreiben in die Runtime-DB und benötigen Review/Bestätigung.")
        else:
            st.sidebar.info("Read-only Mode: Schreibaktionen sind deaktiviert.")

        st.sidebar.write(f"DB: `{db_path}`")
        safe = dashboard_data.get_safe_mode_status(conn)
        st.sidebar.info(f"DB-Modus: {safe['db_mode']} | Write Mode: {safe['write_mode']}")
        st.sidebar.caption(f"Backup: {safe['last_backup_at']}")
        st.sidebar.warning("Keine Live-API-Abfragen beim Seitenreload. Preise nur aus lokaler DB/Cache. Echte Daten liegen außerhalb Git.")
        page = page_map[selected]
        page.render(st, conn)
    finally:
        conn.close()


if __name__ == "__main__":
    run_app()