from __future__ import annotations

import fcntl
import logging
import os
import shutil
import subprocess
import threading
import time
from pathlib import Path

import gi

gi.require_version("Gtk", "3.0")
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk, GLib, Gtk, Pango

try:
    gi.require_version("AyatanaAppIndicator3", "0.1")
    from gi.repository import AyatanaAppIndicator3
except (ImportError, ValueError):
    AyatanaAppIndicator3 = None

from .codex_data import (
    DashboardStats,
    ThreadSummary,
    format_time,
    format_tokens,
    list_logs_result,
    list_threads,
    list_threads_result,
    get_stats,
)
from .paths import CACHE_LOG, CONFIG_TOML, LOCK_PATH
from .processes import ProcessInfo, format_uptime, scan_processes, terminate_process


log = logging.getLogger("codex_dashboard")
_lock_file = None


CSS = b"""
window {
  background: #0f172a;
  color: #e2e8f0;
}
.topbar {
  background: #111827;
  border-bottom: 1px solid #1f2937;
  padding: 10px 12px;
}
.app-title {
  font-size: 18px;
  font-weight: 700;
  color: #f8fafc;
}
.muted {
  color: #94a3b8;
}
.panel {
  background: #0f172a;
}
.stat {
  background: #111827;
  border: 1px solid #1f2937;
  border-radius: 10px;
  padding: 12px;
}
.stat-value {
  font-size: 22px;
  font-weight: 700;
  color: #f8fafc;
}
.badge,
.badge-ok,
.badge-warn,
.badge-idle {
  border-radius: 999px;
  padding: 4px 10px;
  font-weight: 600;
}
.badge {
  background: #1e293b;
  color: #cbd5e1;
}
.badge-ok {
  background: #123a2b;
  color: #86efac;
}
.badge-warn {
  background: #3f2a12;
  color: #fcd34d;
}
.badge-idle {
  background: #1f2937;
  color: #cbd5e1;
}
.row {
  border: 1px solid transparent;
  border-bottom: 1px solid #1e293b;
  border-radius: 8px;
  padding: 10px 12px;
}
.row:hover {
  background: #111827;
  border-color: #334155;
}
button {
  border-radius: 8px;
}
entry {
  border-radius: 8px;
  background: #111827;
  color: #e2e8f0;
}
"""


def _setup_logging() -> None:
    CACHE_LOG.parent.mkdir(parents=True, exist_ok=True)
    logging.basicConfig(
        filename=str(CACHE_LOG),
        level=logging.INFO,
        format="%(asctime)s %(name)s %(levelname)s %(message)s",
    )


def _acquire_singleton_lock() -> None:
    global _lock_file
    fd = os.open(LOCK_PATH, os.O_CREAT | os.O_WRONLY, 0o644)
    _lock_file = os.fdopen(fd, "w")
    try:
        fcntl.flock(_lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
        _lock_file.truncate(0)
        _lock_file.write(str(os.getpid()))
        _lock_file.flush()
    except BlockingIOError:
        log.warning("CodexDashBoard already running")
        raise SystemExit(0)


def _label(text: str = "", *, xalign: float = 0.0, css: str | None = None) -> Gtk.Label:
    label = Gtk.Label(label=text, xalign=xalign)
    label.set_ellipsize(Pango.EllipsizeMode.END)
    if css:
        label.get_style_context().add_class(css)
    return label


def _button(icon_name: str, tooltip: str) -> Gtk.Button:
    button = Gtk.Button.new_from_icon_name(icon_name, Gtk.IconSize.BUTTON)
    button.set_tooltip_text(tooltip)
    return button


def _clear_list(list_box: Gtk.ListBox) -> None:
    for child in list_box.get_children():
        list_box.remove(child)


def _run_bg(work, done) -> None:
    def worker():
        try:
            result = work()
        except Exception as exc:  # pragma: no cover - UI guard
            log.exception("background task failed")
            result = exc
        GLib.idle_add(done, result)

    threading.Thread(target=worker, daemon=True).start()


def _open_path(path: str | Path) -> None:
    subprocess.Popen(["xdg-open", str(path)], start_new_session=True)


class CodexDashboard(Gtk.Window):
    def __init__(self) -> None:
        super().__init__(title="CodexDashBoard")
        self.set_default_size(940, 640)
        self.set_resizable(True)
        self.set_wmclass("codex-dashboard", "CodexDashBoard")

        self._tray_indicator = None
        self._session_query = ""
        self._log_query = ""
        self._include_archived = False

        self._stats_labels: dict[str, Gtk.Label] = {}
        self._refresh_in_flight: set[str] = set()
        self._overview_sessions = Gtk.ListBox()
        self._overview_processes = Gtk.ListBox()
        self._sessions_list = Gtk.ListBox()
        self._processes_list = Gtk.ListBox()
        self._logs_list = Gtk.ListBox()
        self._status = _label("Ready", css="muted")

        self._setup_css()
        self._build_ui()
        self._build_tray()
        self.connect("delete-event", self._on_delete)

        GLib.timeout_add_seconds(30, self._refresh_visible)
        self._refresh_visible()

    def _setup_css(self) -> None:
        provider = Gtk.CssProvider()
        provider.load_from_data(CSS)
        screen = Gdk.Screen.get_default()
        Gtk.StyleContext.add_provider_for_screen(
            screen,
            provider,
            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
        )

    def _build_ui(self) -> None:
        root = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
        self.add(root)

        topbar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
        topbar.get_style_context().add_class("topbar")
        root.pack_start(topbar, False, False, 0)

        title = _label("CodexDashBoard", css="app-title")
        topbar.pack_start(title, False, False, 0)
        topbar.pack_start(self._status, True, True, 0)

        config_button = _button("emblem-system-symbolic", "Open Codex config")
        config_button.connect("clicked", lambda *_: _open_path(CONFIG_TOML))
        topbar.pack_end(config_button, False, False, 0)

        refresh_button = _button("view-refresh-symbolic", "Refresh")
        refresh_button.connect("clicked", lambda *_: self.refresh_all())
        topbar.pack_end(refresh_button, False, False, 0)

        body = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
        root.pack_start(body, True, True, 0)

        self.stack = Gtk.Stack()
        self.stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
        self.stack.set_transition_duration(120)
        self.stack.connect("notify::visible-child-name", lambda *_: self._refresh_visible())

        sidebar = Gtk.StackSidebar()
        sidebar.set_stack(self.stack)
        sidebar.set_size_request(150, -1)
        body.pack_start(sidebar, False, False, 0)
        body.pack_start(self.stack, True, True, 0)

        self.stack.add_titled(self._build_overview(), "overview", "Overview")
        self.stack.add_titled(self._build_sessions(), "sessions", "Sessions")
        self.stack.add_titled(self._build_processes(), "processes", "Processes")
        self.stack.add_titled(self._build_logs(), "logs", "Logs")

    def _build_overview(self) -> Gtk.Widget:
        scrolled = Gtk.ScrolledWindow()
        scrolled.get_style_context().add_class("panel")
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
        box.set_margin_top(14)
        box.set_margin_bottom(14)
        box.set_margin_start(14)
        box.set_margin_end(14)
        scrolled.add(box)

        stats = Gtk.Grid(column_spacing=10, row_spacing=10)
        box.pack_start(stats, False, False, 0)
        for idx, (key, label_text) in enumerate(
            [
                ("threads", "Threads"),
                ("recent", "Updated Last Hour"),
                ("tokens", "Tokens"),
                ("processes", "Agent Processes"),
            ]
        ):
            card = self._stat_card(label_text)
            stats.attach(card, idx % 3, idx // 3, 1, 1)
            self._stats_labels[key] = card.value_label

        box.pack_start(_label("Letzte 10 Codex Sessions", css="app-title"), False, False, 0)
        box.pack_start(self._overview_sessions, False, False, 0)
        box.pack_start(_label("Active Processes", css="app-title"), False, False, 0)
        box.pack_start(self._overview_processes, False, False, 0)
        return scrolled

    def _stat_card(self, label_text: str) -> Gtk.Box:
        card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
        card.get_style_context().add_class("stat")
        card.set_hexpand(True)
        value = _label("-", css="stat-value")
        label = _label(label_text, css="muted")
        card.pack_start(value, False, False, 0)
        card.pack_start(label, False, False, 0)
        card.value_label = value  # type: ignore[attr-defined]
        return card

    def _build_sessions(self) -> Gtk.Widget:
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
        box.set_margin_top(10)
        box.set_margin_bottom(10)
        box.set_margin_start(10)
        box.set_margin_end(10)

        controls = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        search = Gtk.SearchEntry()
        search.set_placeholder_text("Search title, cwd, branch")
        search.connect("search-changed", self._on_session_search)
        controls.pack_start(search, True, True, 0)

        archived = Gtk.CheckButton(label="Archived")
        archived.connect("toggled", self._on_archived_toggled)
        controls.pack_end(archived, False, False, 0)
        box.pack_start(controls, False, False, 0)

        scrolled = Gtk.ScrolledWindow()
        scrolled.add(self._sessions_list)
        box.pack_start(scrolled, True, True, 0)
        return box

    def _build_processes(self) -> Gtk.Widget:
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
        box.set_margin_top(10)
        box.set_margin_bottom(10)
        box.set_margin_start(10)
        box.set_margin_end(10)
        hint = _label(
            "Codex-related processes. Stop actions ask first.",
            css="muted",
        )
        box.pack_start(hint, False, False, 0)
        scrolled = Gtk.ScrolledWindow()
        scrolled.add(self._processes_list)
        box.pack_start(scrolled, True, True, 0)
        return box

    def _build_logs(self) -> Gtk.Widget:
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
        box.set_margin_top(10)
        box.set_margin_bottom(10)
        box.set_margin_start(10)
        box.set_margin_end(10)
        search = Gtk.SearchEntry()
        search.set_placeholder_text("Search logs")
        search.connect("search-changed", self._on_log_search)
        box.pack_start(search, False, False, 0)
        scrolled = Gtk.ScrolledWindow()
        scrolled.add(self._logs_list)
        box.pack_start(scrolled, True, True, 0)
        return box

    def _build_tray(self) -> None:
        if AyatanaAppIndicator3 is None:
            return
        indicator = AyatanaAppIndicator3.Indicator.new(
            "codex-dashboard",
            "utilities-system-monitor",
            AyatanaAppIndicator3.IndicatorCategory.APPLICATION_STATUS,
        )
        indicator.set_status(AyatanaAppIndicator3.IndicatorStatus.ACTIVE)
        indicator.set_title("CodexDashBoard")

        menu = Gtk.Menu()
        show_item = Gtk.MenuItem(label="Show")
        show_item.connect("activate", lambda *_: self._show_window())
        menu.append(show_item)

        refresh_item = Gtk.MenuItem(label="Refresh")
        refresh_item.connect("activate", lambda *_: self.refresh_all())
        menu.append(refresh_item)

        menu.append(Gtk.SeparatorMenuItem())

        quit_item = Gtk.MenuItem(label="Quit")
        quit_item.connect("activate", lambda *_: Gtk.main_quit())
        menu.append(quit_item)

        menu.show_all()
        indicator.set_menu(menu)
        self._tray_indicator = indicator

    def _show_window(self) -> None:
        self.show_all()
        self.present()

    def _on_delete(self, *_args) -> bool:
        if self._tray_indicator is not None:
            self.hide()
            return True
        Gtk.main_quit()
        return False

    def _on_session_search(self, entry: Gtk.SearchEntry) -> None:
        self._session_query = entry.get_text()
        self.refresh_sessions()

    def _on_archived_toggled(self, button: Gtk.CheckButton) -> None:
        self._include_archived = button.get_active()
        self.refresh_sessions()

    def _on_log_search(self, entry: Gtk.SearchEntry) -> None:
        self._log_query = entry.get_text()
        self.refresh_logs()

    def _refresh_visible(self) -> bool:
        name = self.stack.get_visible_child_name()
        if name == "sessions":
            self.refresh_sessions()
        elif name == "processes":
            self.refresh_processes()
        elif name == "logs":
            self.refresh_logs()
        else:
            self.refresh_overview()
        return True

    def refresh_all(self) -> None:
        self._refresh_visible()

    def _run_refresh_once(self, key: str, work, done) -> None:
        if key in self._refresh_in_flight:
            self._set_status(f"{key.title()} refresh already running")
            return
        self._refresh_in_flight.add(key)

        def wrapped_done(result):
            try:
                return done(result)
            finally:
                self._refresh_in_flight.discard(key)

        _run_bg(work, wrapped_done)

    def refresh_overview(self) -> None:
        def work():
            return get_stats(), list_threads(limit=10), scan_processes()

        def done(result):
            if isinstance(result, Exception):
                self._set_status("Refresh failed")
                return False
            stats, threads, processes = result
            self._render_overview(stats, threads, processes)
            self._set_status("Overview refreshed")
            return False

        self._run_refresh_once("overview", work, done)

    def refresh_sessions(self) -> None:
        def work():
            return list_threads_result(
                query=self._session_query,
                include_archived=self._include_archived,
                limit=120,
            )

        def done(result):
            if isinstance(result, Exception):
                self._set_status("Session refresh failed")
                return False
            if result.error is not None:
                self._render_threads(self._sessions_list, result.data)
                self._set_status(f"Session database error: {result.error.message}")
                return False
            self._render_threads(self._sessions_list, result.data)
            self._set_status(f"{len(result.data)} sessions")
            return False

        self._run_refresh_once("sessions", work, done)

    def refresh_processes(self) -> None:
        def done(result):
            if isinstance(result, Exception):
                self._set_status("Process refresh failed")
                return False
            self._render_processes(self._processes_list, result, full=True)
            self._set_status(f"{len(result)} processes")
            return False

        self._run_refresh_once("processes", scan_processes, done)

    def refresh_logs(self) -> None:
        def work():
            return list_logs_result(query=self._log_query, limit=150)

        def done(result):
            if isinstance(result, Exception):
                self._set_status("Log refresh failed")
                return False
            if result.error is not None:
                self._render_logs(result.data)
                self._set_status(f"Log database error: {result.error.message}")
                return False
            self._render_logs(result.data)
            self._set_status(f"{len(result.data)} log rows")
            return False

        self._run_refresh_once("logs", work, done)

    def _render_overview(
        self,
        stats: DashboardStats,
        threads: list[ThreadSummary],
        processes: list[ProcessInfo],
    ) -> None:
        self._stats_labels["threads"].set_text(str(stats.thread_count))
        self._stats_labels["recent"].set_text(str(stats.recent_hour_count))
        self._stats_labels["tokens"].set_text(format_tokens(stats.total_tokens))
        self._stats_labels["processes"].set_text(str(len(processes)))
        active_cwds = {process.cwd for process in processes if process.cwd}
        self._render_threads(
            self._overview_sessions,
            threads,
            compact=True,
            active_cwds=active_cwds,
        )
        self._render_processes(self._overview_processes, processes[:6], full=False)

    def _render_threads(
        self,
        list_box: Gtk.ListBox,
        threads: list[ThreadSummary],
        *,
        compact: bool = False,
        active_cwds: set[str] | None = None,
    ) -> None:
        _clear_list(list_box)
        if not threads:
            list_box.add(self._empty_row("No Codex sessions found"))
            list_box.show_all()
            return
        for thread in threads:
            list_box.add(
                self._thread_row(thread, compact=compact, active_cwds=active_cwds or set())
            )
        list_box.show_all()

    def _thread_row(
        self,
        thread: ThreadSummary,
        *,
        compact: bool = False,
        active_cwds: set[str] | None = None,
    ) -> Gtk.ListBoxRow:
        row = Gtk.ListBoxRow()
        outer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        outer.get_style_context().add_class("row")
        row.add(outer)

        text_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
        outer.pack_start(text_box, True, True, 0)

        title_prefix = "Thema: " if compact else ""
        title = _label(title_prefix + thread.title)
        title.set_tooltip_text(thread.id)
        text_box.pack_start(title, False, False, 0)

        state_text, state_class = self._thread_state(thread, active_cwds or set())
        meta_parts = [
            "Stand: " + state_text,
            "Update: " + format_time(thread.updated_ms),
            "Projekt: " + (Path(thread.cwd).name if thread.cwd else "no cwd"),
            thread.model or "model?",
        ]
        if thread.reasoning_effort:
            meta_parts.append(thread.reasoning_effort)
        if thread.git_branch:
            meta_parts.append(thread.git_branch)
        if not compact:
            meta_parts.append(format_tokens(thread.tokens_used) + " tokens")
        meta = _label("  |  ".join(meta_parts), css="muted")
        text_box.pack_start(meta, False, False, 0)

        badge = _label(state_text, xalign=0.5, css=state_class)
        outer.pack_end(badge, False, False, 0)

        if not compact:
            open_button = _button("folder-open-symbolic", "Open folder")
            open_button.connect("clicked", lambda *_: self._open_thread_folder(thread))
            outer.pack_end(open_button, False, False, 0)

            resume_button = _button("media-playback-start-symbolic", "Resume in terminal")
            resume_button.connect("clicked", lambda *_: self._resume_thread(thread))
            outer.pack_end(resume_button, False, False, 0)

        return row

    def _thread_state(self, thread: ThreadSummary, active_cwds: set[str]) -> tuple[str, str]:
        if thread.archived:
            return "Archived", "badge"
        if thread.cwd and thread.cwd in active_cwds:
            return "Running", "badge-ok"
        age_ms = int(time.time() * 1000) - thread.updated_ms
        if age_ms <= 10 * 60 * 1000:
            return "Active", "badge-ok"
        if age_ms <= 60 * 60 * 1000:
            return "Recent", "badge-warn"
        return "Idle", "badge-idle"

    def _render_processes(
        self,
        list_box: Gtk.ListBox,
        processes: list[ProcessInfo],
        *,
        full: bool,
    ) -> None:
        _clear_list(list_box)
        if not processes:
            list_box.add(self._empty_row("No Codex-related processes found"))
            list_box.show_all()
            return
        for process in processes:
            list_box.add(self._process_row(process, full=full))
        list_box.show_all()

    def _process_row(self, process: ProcessInfo, *, full: bool) -> Gtk.ListBoxRow:
        row = Gtk.ListBoxRow()
        outer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        outer.get_style_context().add_class("row")
        row.add(outer)

        text_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
        outer.pack_start(text_box, True, True, 0)

        title = _label(f"{process.name}  pid {process.pid}")
        title.set_tooltip_text(process.command)
        text_box.pack_start(title, False, False, 0)

        cwd = Path(process.cwd).name if process.cwd else "-"
        meta = (
            f"{process.ram_mb:.1f} MB  |  {process.cpu:.1f}% CPU  |  "
            f"{format_uptime(process.uptime_seconds)}  |  {cwd}"
        )
        text_box.pack_start(_label(meta, css="muted"), False, False, 0)

        if process.stale:
            badge = _label("Stale", xalign=0.5, css="badge-warn")
            outer.pack_end(badge, False, False, 0)

        if full:
            stop_button = _button("process-stop-symbolic", "Stop process")
            stop_button.connect("clicked", lambda *_: self._confirm_stop(process))
            outer.pack_end(stop_button, False, False, 0)

        return row

    def _render_logs(self, logs) -> None:
        _clear_list(self._logs_list)
        if not logs:
            self._logs_list.add(self._empty_row("No Codex logs found"))
            self._logs_list.show_all()
            return
        for entry in logs:
            row = Gtk.ListBoxRow()
            outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
            outer.get_style_context().add_class("row")
            row.add(outer)

            header = _label(
                f"{format_time(entry.ts_ms)}  |  {entry.level}  |  {entry.target}"
            )
            outer.pack_start(header, False, False, 0)
            if entry.message:
                outer.pack_start(_label(entry.message, css="muted"), False, False, 0)
            elif entry.thread_id:
                outer.pack_start(_label(entry.thread_id, css="muted"), False, False, 0)
            self._logs_list.add(row)
        self._logs_list.show_all()

    def _empty_row(self, text: str) -> Gtk.ListBoxRow:
        row = Gtk.ListBoxRow()
        label = _label(text, css="muted")
        label.set_margin_top(12)
        label.set_margin_bottom(12)
        label.set_margin_start(12)
        label.set_margin_end(12)
        row.add(label)
        return row

    def _resume_thread(self, thread: ThreadSummary) -> None:
        codex = shutil.which("codex")
        kitty = shutil.which("kitty")
        cwd = thread.cwd if thread.cwd and Path(thread.cwd).is_dir() else str(Path.home())
        if codex is None:
            self._set_status("codex command not found")
            return
        if kitty:
            cmd = [kitty, "-e", codex, "resume", thread.id]
        else:
            cmd = [codex, "resume", thread.id]
        try:
            subprocess.Popen(cmd, cwd=cwd, start_new_session=True)
            self._set_status("Resume launched")
        except OSError:
            log.exception("resume failed")
            self._set_status("Resume failed")

    def _open_thread_folder(self, thread: ThreadSummary) -> None:
        path = Path(thread.cwd)
        if path.is_dir():
            _open_path(path)
            self._set_status("Folder opened")
        else:
            self._set_status("Folder missing")

    def _confirm_stop(self, process: ProcessInfo) -> None:
        dialog = Gtk.MessageDialog(
            transient_for=self,
            flags=0,
            message_type=Gtk.MessageType.WARNING,
            buttons=Gtk.ButtonsType.CANCEL,
            text=f"Stop process {process.pid}?",
        )
        dialog.format_secondary_text(process.command)
        dialog.add_button("Stop", Gtk.ResponseType.OK)
        response = dialog.run()
        dialog.destroy()
        if response != Gtk.ResponseType.OK:
            return
        try:
            terminate_process(process.pid)
            self._set_status(f"Sent SIGTERM to {process.pid}")
            self.refresh_processes()
        except OSError:
            log.exception("terminate failed")
            self._set_status("Stop failed")

    def _set_status(self, text: str) -> None:
        self._status.set_text(text)


def main() -> int:
    _setup_logging()
    _acquire_singleton_lock()
    win = CodexDashboard()
    win.connect("destroy", Gtk.main_quit)
    win.show_all()
    Gtk.main()
    return 0