dzgui/dzgui/controllers/mc.py

import logging
import threading

from typing import Any, TYPE_CHECKING, Union

import dzgui.util._json as JSON  # noqa


from dzgui.const.enum import (
    ButtonType,
    ContextMenu,
    FilterMode,
    NotebookPage,
    Preferences,
    ServerTab,
)

from dzgui.config.userprefs import UserPrefs
from dzgui.const.constants import APP_NAME
from dzgui.controllers.emitter import Emitter
from dzgui.managers.config import ConfigManager
from dzgui.managers.connection import ConnectionManager
from dzgui.managers.contextmenu import ContextMenuManager
from dzgui.managers.notes import NoteManager
from dzgui.model.servers import ServerModelManager
from dzgui.util.diag import write_diagnostic
from dzgui.util.format import format_exception, format_player_count
from dzgui.util.open_links import open_user_workshop, open_workshop_page
from dzgui.views.dialogs.filepicker import FilePicker
from dzgui.views.dialogs.generic import ExceptionDialog

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk, GLib, GObject  # noqa E402

logger = logging.getLogger(APP_NAME)

if TYPE_CHECKING:
    from dzgui.api.servers import Record
    from dzgui.managers.connection import Prerequisites
    from dzgui.managers.filter import FilterManager
    from dzgui.util.dist import Haversine
    from dzgui.views.base import Notebook, Grid, OuterWindow
    from dzgui.views.components.buttonbox import ContextualButton
    from dzgui.views.components.filter_panel import FilterPanel
    from dzgui.views.components.right_panel import RightPanel
    from dzgui.views.components.statusbar import Statusbar
    from dzgui.views.pages.offline import OfflineLoader
    from dzgui.views.pages.options import Options
    from dzgui.views.pages.preconnect import PreConnectionAssistant
    from dzgui.views.pages.servers import ServerNotebook
    from dzgui.views.trees.tree_log import LogTreeView
    from dzgui.views.trees.tree_menu import MenuTreeView
    from dzgui.views.trees.tree_mods import ModTreeView, OfflineModTreeView
    from dzgui.views.trees.tree_servers import ServerTreeView


class AppNavigation:
    window: "OuterWindow"
    grid: "Grid"
    right_panel: "RightPanel"
    statusbar: "Statusbar"
    notebook: "Notebook"
    modtreeview: "ModTreeView"
    menu: "MenuTreeView"
    servers: "ServerNotebook"
    saved: "ServerTreeView"
    recent: "ServerTreeView"
    lan: "ServerTreeView"
    logtreeview: "LogTreeView"
    filters: "FilterPanel"
    preconnect: "PreConnectionAssistant"
    options: "Options"
    offline_loader: "OfflineLoader"


class Controller(GObject.GObject):
    def __init__(self) -> None:
        self.dist_cache: dict[str, "Haversine"] = {}
        self.mediator = AppNavigation()

        self.prefs: UserPrefs

        self.emitter = Emitter()
        self.emitter.connect("map_selection_changed", self._on_map_selection_changed)
        self.emitter.connect("check_toggled", self._on_check_toggled)

        # NOTE: suppress requests until entire UI is loaded
        self.loaded = False

        self.exit_event = threading.Event()
        self.cancel_event = threading.Event()
        self.connection_man: ConnectionManager

    def get_emitter(self) -> Emitter:
        return self.emitter

    def register_widget(self, attr: str, widget: Gtk.Widget) -> None:
        try:
            setattr(self.mediator, attr, widget)
        except AttributeError:
            logger.critical(f"{attr} is not a valid AppNavigation attribute.")

    def get_prefs(self) -> UserPrefs:
        return self.prefs

    def set_prefs(self, prefs: UserPrefs) -> None:
        self.config_man = ConfigManager(prefs, self)
        self.notes_man = NoteManager(self, prefs.paths.notes)

        self.prefs = prefs

    def query_config(self, key: Preferences) -> Any:
        return self.config_man.lookup(key)

    def suppress_signal(
        self, owner: Any, child: Any, func_name: str, state: bool
    ) -> None:

        func = getattr(owner, func_name)
        if state:
            child.handler_block_by_func(func)
        else:
            child.handler_unblock_by_func(func)

    def get_active_context(self) -> "ServerTab":
        return self.get_active_treeview().get_enum()

    def get_active_treeview(self) -> "ServerTreeView":
        return self.mediator.notebook.servers.get_active_treeview()

    def grab_active_treeview(self) -> None:
        self.get_active_treeview().grab_focus()

    def save_res_and_quit(self, *args: Any) -> None:
        treeview = self.get_active_treeview()
        window = self.get_window()
        self.config_man.save_res_and_quit(treeview, window)

    def set_statusbar(self, enum: "NotebookPage | ServerTab", text: str) -> None:
        self.mediator.statusbar.set_by_context(enum, text)

    def remove_statusbar(self, context: "NotebookPage | ServerTab") -> None:
        self.mediator.statusbar.pop(context)

    def set_statusbar_dist(
        self, haversine: Union["Haversine", None], enum: "ServerTab"
    ) -> None:
        """
        NOTE: prevents race condition when server tab changed,
        but allows caching the distance in the background
        """
        context = self.get_active_context()
        page = self.mediator.notebook.get_page_by_enum()
        if page != NotebookPage.SERVERS:
            self.emitter.emit("distcalc_ended", None, context)
            return
        if enum != context:
            self.emitter.emit("distcalc_ended", None, context)
            return

        if haversine is None:
            self.emitter.emit("distcalc_ended", None, context)
            return
        dist = haversine.get_rounded(self.prefs.use_miles)
        self.emitter.emit("distcalc_ended", dist, context)

    def toggle_config(self, key: Preferences) -> None:
        # NOTE: Preferences.DIST is dynamic
        if key == Preferences.DIST:
            self.prefs.use_miles = not self.prefs.use_miles
        self.config_man.toggle_config(key)

    def update_config(self, key: Preferences, value: str) -> None:
        self.config_man.update_config(key, value)

    def open_keybindings(self) -> None:
        notebook = self.mediator.grid.notebook
        notebook.toggle_keybindings()

    def focus_notebook(self) -> None:
        notebook = self.mediator.grid.notebook
        notebook.focus_current()

    def show_developers_page(self) -> None:
        self.open_page(NotebookPage.DEVELOPERS)

    def open_page(self, page: NotebookPage) -> None:
        self.mediator.grid.notebook.set_page_by_enum(page)

    def open_page_by_button(self, button: "ContextualButton") -> None:
        # TODO: consolidate methods with set_page_by_enum
        match button.context:
            case ButtonType.EXIT:
                self.save_res_and_quit()
                return
            case ButtonType.OPTIONS:
                try:
                    # TODO: where to put config file check
                    self.mediator.grid.notebook.settings.populate_settings()
                except Exception as e:
                    msg = format_exception(e)
                    logger.critical(msg)
                    return
            case ButtonType.MODS:
                self.load_mods()

        self.open_page(button.opens)

    def get_help_row(self) -> str:
        return self.mediator.menu.get_row_enum()

    def open_user_workshop(self, uid: str) -> None:
        # NOTE: uid may contain leading zeroes, not a real integer
        client = self.query_config(Preferences.CLIENT)
        open_user_workshop(uid, client)

    def load_mods(self) -> None:
        self.mediator.modtreeview.load_mods()

    def uncolorize_mods(self) -> None:
        mod_man = self.mediator.modtreeview.get_mod_man()
        mod_man.uncolorize_mods()

    def highlight_stale(self) -> None:
        mod_man = self.mediator.modtreeview.get_mod_man()
        mod_man.highlight_stale()

    def toggle_mod_selection(self, state: bool) -> None:
        mod_man = self.mediator.modtreeview.get_mod_man()
        mod_man.toggle_mod_selection(state)

    def unsub_mods(
        self, treeview: Union["ModTreeView", "OfflineModTreeView", None] = None
    ) -> None:
        if treeview is None:
            view = self.mediator.modtreeview
        else:
            view = treeview
        mod_man = view.get_mod_man()
        mod_man.unsub_mods()

    def get_mod_store(self) -> Gtk.TreeModel | None:
        return self.mediator.modtreeview.get_model()

    def set_fav(self, name: str, record: str, simple_ip: str) -> None:
        try:
            self.config_man.set_fav(name, record)
            self.emitter.emit("fav_server_changed", name, simple_ip)
        except Exception as e:
            logger.critical(e)
            return

    def menu_action(self, action: ContextMenu, tree: "ServerTreeView") -> None:
        context_man = ContextMenuManager(tree, self)
        context_man.process(action)

    def populate_log(self) -> None:
        log = self.prefs.paths.debug
        try:
            self.mediator.logtreeview.populate_log(log)
            self.open_page(NotebookPage.LOG)
        except Exception as e:
            dialog = ExceptionDialog(self, str(e))
            dialog.show_all()
            dialog.run()

    def select_colorized(self) -> None:
        mod_man = self.mediator.modtreeview.get_mod_man()
        mod_man.select_colorized()

    def get_all_tree_filters(self) -> dict[str, dict[str, bool]]:
        servers = self.get_servers()
        all_filters: dict[str, dict[str, bool]] = {}
        trees = (
            servers.get_browser(),
            servers.get_saved(),
            servers.get_recent(),
            servers.get_lan(),
        )
        for tree in trees:
            enum = str(tree.get_enum())
            filters = tree.get_filter_man().get_filters()
            all_filters[enum] = filters
        return all_filters

    def get_filter_man(self) -> "FilterManager":
        """Each ServerTreeView has an atomic FilterManager"""
        return self.get_active_treeview().get_filter_man()

    def dump_diagnostics(self) -> None:
        picker = FilePicker(self.mediator.window)
        file = picker.pick_file()
        if file is not None:
            try:
                write_diagnostic(self.prefs.paths.config, file)
            except Exception as e:
                dialog = ExceptionDialog(self, str(e))
                dialog.show_all()
                dialog.run()

    def update_steam_api_key(self, text: str) -> None:
        self.config_man.update_steam_api_key(text)

    def set_resolution(self, window: "OuterWindow") -> None:
        self.config_man.set_resolution(window)

    def propagate_column_width(self, col: Gtk.TreeViewColumn) -> None:
        GLib.idle_add(self.mediator.servers.update_tab_widths, col)

    def refresh_tree(self) -> None:
        treeview = self.get_active_treeview()
        treeview.set_loaded(False)
        ServerModelManager(self, treeview).refresh()

    def get_player_count(self) -> str:
        treeview = self.get_active_treeview()
        model, control = treeview.get_model_and_control_model()
        count = format_player_count(model, control)
        return count

    def get_statusbar(self) -> "Statusbar":
        return self.mediator.statusbar

    def populate_model(self, tv: "ServerTreeView") -> None:
        # NOTE: skip on previously loaded tabs
        if tv.is_loaded():
            self.emitter.emit("servers_loaded", tv.get_enum())
            return
        self.mediator.statusbar.set_by_context(tv.get_enum(), "")
        self.mediator.filters.button_grid.block_toggles(True)
        self.populate_filter_prefs()
        self.mediator.filters.button_grid.block_toggles(False)
        self.emitter.emit("lan_page_initialized")
        ServerModelManager(self, tv).load()

    def populate_filter_prefs(self) -> None:
        tv = self.get_active_treeview()
        filters = self.config_man.get_filters(tv)
        if filters is None:
            return
        filter_man = self.get_filter_man()
        for filt, state in filters.items():
            filter_man.set_filter(filt, state)
        self.mediator.filters.set_filters(filters)

    def get_dist_cache(self) -> dict[str, "Haversine"]:
        return self.dist_cache

    def set_dist_cache(self, addr: str, haversine: "Haversine") -> None:
        self.dist_cache[addr] = haversine

    def get_map_store(self) -> Gtk.ListStore:
        filter_man = self.get_filter_man()
        return filter_man.get_map_store()

    def get_enabled_filters(self) -> dict:
        filter_man = self.get_filter_man()
        return filter_man.get_filters()

    # FIXME: wipe maps store when changing tabs if model is none

    def has_server_model(self) -> bool:
        treeview = self.get_active_treeview()
        proxy_man = treeview.get_proxy_man()
        control = proxy_man.get_control()
        if control is None:
            return False
        if len(control) < 1:
            return False
        return True

    def _on_check_toggled(self, emitter: Emitter, label: str, state: bool) -> None:
        filter_man = self.get_filter_man()
        filter_man.set_filter(label, state)

        mode = FilterMode.TOGGLE_ON if state else FilterMode.TOGGLE_OFF
        ServerModelManager(self, self.get_active_treeview()).refilter(mode)

    def _on_map_selection_changed(self, emitter: Emitter, selection: str) -> None:
        smm = ServerModelManager(self, self.get_active_treeview())
        smm.refilter(FilterMode.TOGGLE_ON)

    def get_notebook(self) -> "Notebook":
        return self.mediator.notebook

    def get_prior_page(self) -> NotebookPage:
        return self.mediator.notebook.get_prior_page()

    def get_servers(self) -> "ServerNotebook":
        return self.mediator.servers

    def get_server_notebook(self) -> Gtk.Notebook:
        return self.mediator.servers.notebook

    def get_window(self) -> "OuterWindow":
        return self.mediator.window

    def get_menu(self) -> "MenuTreeView":
        return self.mediator.menu

    def unset_fav(self) -> None:
        self.config_man.unset_fav()

    def has_favorites(self) -> bool:
        favs = self.config_man.get_favorites()
        if len(favs) < 1:
            return False
        return True

    def get_config_man(self) -> ConfigManager:
        return self.config_man

    def add_by_str(self, addr: str) -> None:
        saved_tree = self.get_servers().get_saved()
        ServerModelManager(self, saved_tree).add_by_ip(addr)

    def add_by_record(self, record: "Record") -> None:
        saved_tree = self.get_servers().get_saved()
        ServerModelManager(self, saved_tree).add_by_record(record)

    def remove_by_record(self, record: "Record") -> None:
        saved_tree = self.get_servers().get_saved()
        ServerModelManager(self, saved_tree).remove_by_record(record)

    def add_to_history(self, row: dict[str, Any], record: "Record") -> None:
        tv = self.get_servers().get_recent()
        ServerModelManager(self, tv).add_to_history((row, record))

    # def append_to_history(self, record: "Record") -> None:
    #     self.config_man.append_to_history_file(record)

    def remove_from_history(self, record: "Record") -> None:
        # NOTE: remove action is only possible from history tree context menu,
        # i.e., the active tree
        tv = self.get_active_treeview()
        ServerModelManager(self, tv).remove_from_history(record)

    def connect_by_str(self, addr: str) -> None:
        self.connection_man = ConnectionManager(self)
        self.connection_man.connect_by_ip(addr)

    def connect_by_record(self, record: "Record") -> None:
        self.connection_man = ConnectionManager(self)
        self.connection_man.connect_by_record(record)

    def get_details(self, record: "Record") -> None:
        ConnectionManager(self).query_details(record)

    def get_modlist(self, record: "Record") -> None:
        ConnectionManager(self).query_modlist_and_present(record)

    def get_server_name(self) -> str:
        tv = self.get_active_treeview()
        return tv.get_name()

    def open_workshop_page(self, mod: str) -> None:
        cmd = self.query_config(Preferences.CLIENT)
        open_workshop_page(mod, cmd)

    def has_note(self) -> bool:
        # TODO: get record string, store in memory
        # get note by record, get is in favs, etc. store as a block
        # this is only used by context mixin
        note = self.get_note()
        if len(note) > 0:
            return True
        return False

    def get_note_by_record(self, record: str) -> str:
        return self.notes_man.get_note(record)

    def get_note(self) -> str:
        tv = self.get_active_treeview()
        record = tv.get_record_string()
        return self.notes_man.get_note(record)

    def add_note(self, note: str) -> None:
        # TODO: record should be cached upon creation of dialog
        tv = self.get_active_treeview()
        record = tv.get_record_string()
        self.notes_man.add_note(record, note)

    def delete_note(self) -> None:
        # TODO: record should be cached upon creation of dialog
        tv = self.get_active_treeview()
        record = tv.get_record_string()
        self.notes_man.delete_note(record)

    def refresh_players(self, record: "Record") -> None:
        treeview = self.get_active_treeview()
        model, treeiter = treeview.get_selection().get_selected()
        ServerModelManager(self, treeview).update_playercount(treeiter, record)

    def get_active_keyword(self) -> str:
        return self.get_filter_man().get_active_keyword()

    def set_active_keyword(self, keyword: str) -> None:
        self.get_filter_man().set_active_keyword(keyword)
        ServerModelManager(self, self.get_active_treeview()).refilter(
            FilterMode.TOGGLE_ON
        )

    def get_modtreeview(self) -> "ModTreeView":
        return self.mediator.modtreeview

    def get_exit_event(self) -> threading.Event:
        return self.exit_event

    def set_exit_event(self) -> None:
        self.exit_event.set()

    def set_cancel_event(self) -> None:
        self.cancel_event.set()

    def get_cancel_event(self) -> threading.Event:
        return self.cancel_event

    def clear_cancel_event(self) -> None:
        self.cancel_event.clear()

    def open_connection_assistant(self, prereqs: "Prerequisites") -> None:
        self.open_page(NotebookPage.CONNECTION)
        self.mediator.preconnect.populate(prereqs)

    def set_start_tab(self) -> None:
        ind = self.config_man.get_start_tab()
        logger.info(f"Setting start tab to index {ind}")
        self.get_servers().notebook.set_current_page(ind)

    def get_debug_args(self) -> str:
        return self.connection_man.get_debug_args()

    def update_and_load_to_menu(self) -> None:
        self.connection_man.update_and_connect(menu_only=True)

    def update_and_connect(self) -> None:
        self.connection_man.update_and_connect()

    def update_status(self) -> None:
        self.mediator.preconnect.mark_finished()

    def get_steam_client_name(self) -> str:
        return self.mediator.options.get_client_name()

    def present_window(self) -> None:
        self.mediator.window.present_with_time(Gdk.CURRENT_TIME)

    def is_cancel_pending(self) -> bool:
        if self.get_exit_event().is_set():
            return True
        if self.get_cancel_event().is_set():
            self.clear_cancel_event()
            return True
        return False

    def open_offline(self) -> None:
        self.open_page(NotebookPage.OFFLINE)
        mod_man = self.mediator.modtreeview.get_mod_man()
        store = mod_man.store
        self.mediator.offline_loader.populate(store)