Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

49.9 KB
Raw Blame
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

use backend_wgpu::capture;
use iced::keyboard::key::Code;
use iced::theme::Mode;
use iced::widget::{Stack, button, column, container, row, scrollable, stack, text};
use iced::{Background, Border, Color, Element, Length, Padding, Subscription, Task, Theme, window};

use crate::cache::{self, LibraryCache};
use crate::config::{self, Config};
use crate::game::{AspectMode, CpuMode, Format, Game, Platform, ThemePreference};
use crate::keybinds::{self, KeyTarget};
use crate::library::{self, ScanProgress};
use crate::player::{self, PlayerState, PlayerStatus};
use crate::setup::{self, Field, Setup, Step};
use crate::theme::{self, Palette};
use crate::update::{self, Outcome};
use crate::widgets::input_settings::{self, BindTarget, InputTab, InvertTarget, KeyboardTab};
use crate::widgets::{game_row, menubar, overlay, search_bar, statusbar};

const REPO_URL: &str = "https://github.com/ioncodes/gecko";
pub(crate) const ISSUE_URL: &str = "https://github.com/ioncodes/gecko/issues/new?template=bug_report.md";
const DOUBLE_CLICK_WINDOW: Duration = Duration::from_millis(400);
const TOAST_DURATION: Duration = Duration::from_secs(3);

#[derive(Debug, Clone)]
pub enum Message {
    Noop,
    MenuSetup,
    SetupClose,
    SetupBack,
    SetupNext,
    SetupPick(Field),
    SetupClear(Field),
    SetupPicked(Field, Option<PathBuf>),
    SetupValidated(Result<(), String>),
    SetupInstall,
    SetupInstalled(Result<Box<Config>, String>),
    LibraryWindowOpened(window::Id),
    PlayerWindowOpened(window::Id, Box<Game>, Arc<PlayerState>),
    PlayerTick,
    PlayerCaptureMouse(window::Id, bool),
    PlayerFocused(window::Id, bool),
    WindowClosed(window::Id),
    LibraryPicked(Platform, Option<PathBuf>),
    ScanRequested,
    ScanProgress(ScanProgress),
    SearchChanged(String),
    MenuChooseLibrary(Platform),
    MenuOpenGame,
    MenuOpenDol(Platform),
    GameFilePicked(Option<PathBuf>),
    DolFilePicked(Platform, Option<PathBuf>),
    GameFileLoaded(Result<Box<Game>, String>),
    MenuRescan,
    MenuQuit,
    MenuToggleCpu(CpuMode),
    MenuToggleSkipIpl,
    MenuToggleIplHle,
    MenuToggleMemoryCard,
    MenuToggleSram,
    MenuSetTheme(ThemePreference),
    MenuSetUpscale(u32),
    MenuToggleTexturePacks,
    MenuSetAspect(AspectMode),
    MenuAbout,
    AboutClose,
    MenuInputSettings,
    MenuKeyboardSettings,
    InputClose,
    InputTab(InputTab),
    InputCapture(BindTarget),
    InputTick,
    InputPointer(String),
    InputSensitivity(f32),
    WiiPreset(crate::config::WiiPresetId),
    WiiPresetReset,
    InputToggleNunchuk,
    InputToggleLeftStick,
    InputToggleStickDpad,
    InputToggleInvert(InvertTarget),
    InputReset,
    KeyboardClose,
    KeyboardTab(KeyboardTab),
    KeyboardCapture(KeyTarget),
    KeyboardCaptured(Code),
    KeyboardReset,
    OpenUrl(String),
    CheckForUpdates,
    UpdateChecked(Outcome),
    GameClicked(usize),
    LaunchPlayer(usize),
    SystemThemeLoaded(Mode),
    SystemThemeChanged(Mode),
    PlayerToggleFullscreen(window::Id),
    PlayerToggleOverlay(window::Id),
    PlayerToggleUncapped(window::Id),
    PlayerTogglePause(window::Id),
    PlayerScreenshot(window::Id),
    PlayerSaveState(window::Id),
    PlayerLoadState(window::Id),
}

#[derive(Debug, Clone)]
pub enum UpdateState {
    Idle,
    Checking,
    UpToDate,
    Available(String),
    Unpublished,
    Failed,
}

pub struct Toast {
    title: String,
    detail: String,
    expires: Instant,
}

impl Toast {
    fn new(title: impl Into<String>, detail: impl Into<String>) -> Self {
        Self {
            title: title.into(),
            detail: detail.into(),
            expires: Instant::now() + TOAST_DURATION,
        }
    }
}

pub struct PlayerWindow {
    pub(crate) game: Game,
    pub(crate) state: Arc<PlayerState>,
    pub(crate) fullscreen: bool,
    pub(crate) mouse_capture: Arc<Mutex<player::MouseCapture>>,
    pub(crate) capture_intent: bool,
    pub(crate) captured: bool,
    pub(crate) overlay: bool,
    pub(crate) toast: Option<Toast>,
}

pub struct App {
    cache: LibraryCache,
    config: Config,
    cli_gcn_override: Option<PathBuf>,
    cli_wii_override: Option<PathBuf>,
    games: Vec<Game>,
    search: String,
    search_lc: String,
    scanning: bool,
    setup: Option<Setup>,
    about_open: bool,
    input_open: bool,
    input_tab: InputTab,
    input_capture: Option<BindTarget>,
    input_capture_baseline: u32,
    keyboard_open: bool,
    keyboard_tab: KeyboardTab,
    key_capture: Option<KeyTarget>,
    input_pad_name: Option<String>,
    system_mode: Mode,
    palette: Palette,
    last_click: Option<(usize, Instant)>,
    library_window: Option<window::Id>,
    players: HashMap<window::Id, PlayerWindow>,
    update: UpdateState,
}

impl App {
    pub fn boot(cli_gcn: Option<PathBuf>, cli_wii: Option<PathBuf>) -> (Self, Task<Message>) {
        let config_path = config::config_path();
        let config = config::load(&config_path);
        let setup = Setup::new(&config, cli_gcn.clone(), cli_wii.clone());
        let setup = setup.needed(&config, config_path.is_file()).then_some(setup);

        let cache = cache::load(&cache::cache_path());

        let mut games: Vec<Game> = cache.entries.values().map(|e| e.game.clone()).collect();
        games.sort_by(|a, b| a.title_lc.cmp(&b.title_lc));

        let has_any_root =
            cli_gcn.is_some() || cli_wii.is_some() || config.gcn_library.is_some() || config.wii_library.is_some();

        let palette = self::resolve_palette(config.theme, Mode::Light);
        let app = Self {
            cache,
            config,
            cli_gcn_override: cli_gcn,
            cli_wii_override: cli_wii,
            games,
            search: String::new(),
            search_lc: String::new(),
            scanning: false,
            setup,
            about_open: false,
            input_open: false,
            input_tab: InputTab::Gc,
            input_capture: None,
            input_capture_baseline: 0,
            keyboard_open: false,
            keyboard_tab: KeyboardTab::Gc,
            key_capture: None,
            input_pad_name: None,
            system_mode: Mode::Light,
            palette,
            last_click: None,
            library_window: None,
            players: HashMap::new(),
            update: UpdateState::Idle,
        };

        let (_, open_lib) = window::open(window::Settings {
            size: iced::Size::new(900.0, 720.0),
            ..window::Settings::default()
        });

        let mut tasks: Vec<Task<Message>> = Vec::new();
        tasks.push(open_lib.map(Message::LibraryWindowOpened));
        tasks.push(iced::system::theme().map(Message::SystemThemeLoaded));
        if has_any_root {
            tasks.push(Task::done(Message::ScanRequested));
        }

        (app, Task::batch(tasks))
    }

    pub fn title(&self, window_id: window::Id) -> String {
        if Some(window_id) == self.library_window {
            "Gecko".to_owned()
        } else if let Some(player) = self.players.get(&window_id) {
            format!("Gecko — {}", player.game.title)
        } else {
            "Gecko".to_owned()
        }
    }

    pub fn theme(&self, _window_id: window::Id) -> Theme {
        theme::theme(&self.palette)
    }

    pub fn subscription(&self) -> Subscription<Message> {
        let mut subs = vec![
            iced::system::theme_changes().map(Message::SystemThemeChanged),
            window::close_events().map(Message::WindowClosed),
        ];

        if !self.players.is_empty() {
            subs.push(window::frames().map(|_| Message::PlayerTick));
        }

        if self.input_open {
            subs.push(iced::time::every(Duration::from_millis(100)).map(|_| Message::InputTick));
        }

        if self.keyboard_open && self.key_capture.is_some() {
            subs.push(iced::event::listen_with(self::capture_key_event));
        }

        Subscription::batch(subs)
    }

    pub fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Noop => Task::none(),
            Message::MenuSetup => {
                if self.setup.is_none() {
                    self.setup = Some(Setup::new(
                        &self.config,
                        self.cli_gcn_override.clone(),
                        self.cli_wii_override.clone(),
                    ));
                }
                Task::none()
            }
            Message::SetupClose => {
                if self.idle_setup().is_some() {
                    self.setup = None;
                }
                Task::none()
            }
            Message::SetupBack => {
                if let Some(setup) = self.idle_setup() {
                    setup.step = setup.step.prev();
                    setup.error = None;
                }
                Task::none()
            }
            Message::SetupClear(field) => {
                if let Some(setup) = self.idle_setup() {
                    *setup.sources.path_mut(field) = None;
                    setup.error = None;
                }
                Task::none()
            }
            Message::SetupPick(field) => {
                let Some(setup) = self.idle_setup() else {
                    return Task::none();
                };

                setup.busy = true;
                Task::perform(setup::pick(field), move |path| Message::SetupPicked(field, path))
            }
            Message::SetupPicked(field, path) => {
                if let Some(setup) = &mut self.setup {
                    setup.busy = false;
                    if path.is_some() {
                        *setup.sources.path_mut(field) = path;
                        setup.error = None;
                    }
                }
                Task::none()
            }
            Message::SetupNext => {
                let Some(setup) = self.idle_setup().filter(|s| s.step != Step::Finish) else {
                    return Task::none();
                };

                setup.busy = true;
                setup.error = None;
                let sources = setup.sources.clone();
                let step = setup.step;
                Task::perform(
                    async move {
                        tokio::task::spawn_blocking(move || {
                            setup::validate_step(&sources, step).map_err(|e| format!("{e:#}"))
                        })
                        .await
                        .unwrap_or_else(|e| Err(e.to_string()))
                    },
                    Message::SetupValidated,
                )
            }
            Message::SetupValidated(result) => {
                if let Some(setup) = &mut self.setup {
                    setup.busy = false;
                    match result {
                        Ok(()) => setup.step = setup.step.next(),
                        Err(error) => setup.error = Some(error),
                    }
                }
                Task::none()
            }
            Message::SetupInstall => {
                let Some(setup) = self.idle_setup().filter(|s| s.step == Step::Finish) else {
                    return Task::none();
                };

                setup.busy = true;
                setup.error = None;
                let sources = setup.sources.clone();
                Task::perform(setup::run_install(sources, self.config.clone()), |result| {
                    Message::SetupInstalled(result.map(Box::new))
                })
            }
            Message::SetupInstalled(result) => {
                match result {
                    Ok(config) => {
                        self.config = *config;
                        self.setup = None;
                        self.cli_gcn_override = None;
                        self.cli_wii_override = None;
                        return Task::done(Message::ScanRequested);
                    }
                    Err(error) => {
                        if let Some(setup) = &mut self.setup {
                            setup.busy = false;
                            setup.error = Some(error);
                        }
                    }
                }
                Task::none()
            }
            Message::LibraryWindowOpened(id) => {
                self.library_window = Some(id);
                Task::none()
            }
            Message::PlayerWindowOpened(id, game, state) => {
                state.refresh_wii_input(&self.config);
                tracing::info!(window = ?id, title = %game.title, "player window opened");
                self.players.insert(
                    id,
                    PlayerWindow {
                        game: *game,
                        state,
                        fullscreen: false,
                        mouse_capture: Arc::new(Mutex::new(player::MouseCapture::default())),
                        capture_intent: false,
                        captured: false,
                        overlay: false,
                        toast: None,
                    },
                );
                Task::none()
            }
            Message::PlayerCaptureMouse(id, capture) => {
                let Some(player) = self.players.get_mut(&id) else {
                    return Task::none();
                };

                player.capture_intent = capture;
                self.apply_mouse_capture(id, capture)
            }
            Message::PlayerFocused(id, focused) => {
                let Some(player) = self.players.get(&id) else {
                    return Task::none();
                };

                if !focused {
                    player.state.clear_input();
                }

                let capture = focused && player.capture_intent;
                self.apply_mouse_capture(id, capture)
            }
            Message::PlayerTick => {
                let now = Instant::now();
                for player in self.players.values_mut() {
                    if player.captured {
                        player.mouse_capture.lock().unwrap().poll();
                    }
                    if player.toast.as_ref().is_some_and(|t| now >= t.expires) {
                        player.toast = None;
                    }
                }
                Task::none()
            }
            Message::WindowClosed(id) => {
                if Some(id) == self.library_window {
                    self.library_window = None;
                    iced::exit()
                } else if let Some(player) = self.players.remove(&id) {
                    tracing::info!(window = ?id, "player window closed");
                    player.state.shutdown();
                    Task::none()
                } else {
                    Task::none()
                }
            }
            Message::LibraryPicked(_, None) => Task::none(),
            Message::LibraryPicked(platform, Some(path)) => {
                match platform {
                    Platform::Gcn => self.config.gcn_library = Some(path),
                    Platform::Wii => self.config.wii_library = Some(path),
                }
                self.persist_config();
                Task::done(Message::ScanRequested)
            }
            Message::ScanRequested => {
                let roots = self.effective_library_roots();
                self.scanning = true;
                let prior = self.cache.clone();
                Task::stream(library::scan_library_stream(roots, prior)).map(Message::ScanProgress)
            }
            Message::ScanProgress(ScanProgress::Started { cached, pending }) => {
                self.games = cached;
                self.games.sort_by(|a, b| a.title_lc.cmp(&b.title_lc));
                tracing::info!(cached = self.games.len(), pending, "scan started");
                Task::none()
            }
            Message::ScanProgress(ScanProgress::Loaded(game)) => {
                self.insert_game_sorted(*game);
                Task::none()
            }
            Message::ScanProgress(ScanProgress::Checkpoint(cache)) => {
                self.cache = *cache;
                Task::none()
            }
            Message::ScanProgress(ScanProgress::Finished(cache)) => {
                self.cache = *cache;
                self.scanning = false;
                tracing::info!(total = self.games.len(), "scan finished");
                Task::none()
            }
            Message::ScanProgress(ScanProgress::Error(err)) => {
                tracing::warn!(%err, "scan failed");
                self.scanning = false;
                Task::none()
            }
            Message::SearchChanged(q) => {
                self.search_lc = q.to_lowercase();
                self.search = q;
                Task::none()
            }
            Message::MenuChooseLibrary(platform) => {
                let title = match platform {
                    Platform::Gcn => "Select GameCube folder",
                    Platform::Wii => "Select Wii folder",
                };
                Task::perform(
                    async move {
                        rfd::AsyncFileDialog::new()
                            .set_title(title)
                            .pick_folder()
                            .await
                            .map(|h| h.path().to_path_buf())
                    },
                    move |opt| Message::LibraryPicked(platform, opt),
                )
            }
            Message::MenuOpenGame => Task::perform(
                async move {
                    rfd::AsyncFileDialog::new()
                        .set_title("Open game")
                        .add_filter("Disc images", &["iso", "rvz", "zip"])
                        .pick_file()
                        .await
                        .map(|h| h.path().to_path_buf())
                },
                Message::GameFilePicked,
            ),
            Message::MenuOpenDol(platform) => {
                let title = match platform {
                    Platform::Gcn => "Open GameCube DOL",
                    Platform::Wii => "Open Wii DOL",
                };
                Task::perform(
                    async move {
                        rfd::AsyncFileDialog::new()
                            .set_title(title)
                            .add_filter("DOL executables", &["dol"])
                            .pick_file()
                            .await
                            .map(|h| h.path().to_path_buf())
                    },
                    move |opt| Message::DolFilePicked(platform, opt),
                )
            }
            Message::GameFilePicked(None) => Task::none(),
            Message::GameFilePicked(Some(path)) => {
                let Some(format) = Format::from_path(&path) else {
                    tracing::warn!(path = %path.display(), "unsupported file type");
                    return Task::none();
                };

                Task::perform(
                    async move {
                        tokio::task::spawn_blocking(move || library::load_header(&path, format).map(Box::new))
                            .await
                            .unwrap_or_else(|err| Err(err.to_string()))
                    },
                    Message::GameFileLoaded,
                )
            }
            Message::DolFilePicked(_, None) => Task::none(),
            Message::DolFilePicked(platform, Some(path)) => Task::perform(
                async move {
                    tokio::task::spawn_blocking(move || library::load_dol(&path, platform).map(Box::new))
                        .await
                        .unwrap_or_else(|err| Err(err.to_string()))
                },
                Message::GameFileLoaded,
            ),
            Message::GameFileLoaded(Err(err)) => {
                tracing::warn!(%err, "failed to load picked game");
                Task::none()
            }
            Message::GameFileLoaded(Ok(game)) => {
                tracing::info!(path = %game.path.display(), title = %game.title, "launching picked game");
                self.launch_game(*game)
            }
            Message::MenuRescan => {
                if self.effective_library_roots().is_empty() {
                    Task::done(Message::MenuChooseLibrary(Platform::Gcn))
                } else {
                    Task::done(Message::ScanRequested)
                }
            }
            Message::MenuQuit => iced::exit(),
            Message::MenuToggleCpu(mode) => {
                self.config.cpu_mode = mode;
                self.persist_config();
                Task::none()
            }
            Message::MenuToggleIplHle => {
                self.config.ipl_hle = !self.config.ipl_hle;
                self.persist_config();
                Task::none()
            }
            Message::MenuToggleSkipIpl => {
                self.config.skip_ipl = !self.config.skip_ipl;
                self.persist_config();
                Task::none()
            }
            Message::MenuToggleMemoryCard => {
                self.config.memcard_enabled = !self.config.memcard_enabled;
                self.persist_config();
                Task::none()
            }
            Message::MenuToggleSram => {
                self.config.sram_enabled = !self.config.sram_enabled;
                self.persist_config();
                Task::none()
            }
            Message::MenuSetTheme(pref) => {
                self.config.theme = pref;
                self.persist_config();
                self.refresh_palette();
                Task::none()
            }
            Message::MenuSetUpscale(scale) => {
                self.config.upscale = scale;
                self.persist_config();
                Task::none()
            }
            Message::MenuToggleTexturePacks => {
                self.config.texture_packs = !self.config.texture_packs;
                self.persist_config();
                Task::none()
            }
            Message::MenuSetAspect(aspect) => {
                self.config.aspect = aspect;
                self.persist_config();
                Task::none()
            }
            Message::MenuAbout => {
                self.about_open = true;
                Task::none()
            }
            Message::MenuInputSettings => {
                self.input_open = true;
                self.input_capture = None;
                self.keyboard_open = false;
                self.input_pad_name = self::pad_state().1;
                Task::none()
            }
            Message::InputClose => {
                self.input_open = false;
                self.input_capture = None;
                Task::none()
            }
            Message::InputTab(tab) => {
                self.input_tab = tab;
                self.input_capture = None;
                Task::none()
            }
            Message::InputCapture(target) => {
                if self.input_capture == Some(target) {
                    self.input_capture = None;
                } else {
                    self.input_capture = Some(target);
                    self.input_capture_baseline = self::pad_state().0.unwrap_or(0);
                }
                Task::none()
            }
            Message::MenuKeyboardSettings => {
                self.keyboard_open = true;
                self.key_capture = None;
                self.input_open = false;
                Task::none()
            }
            Message::KeyboardClose => {
                self.keyboard_open = false;
                self.key_capture = None;
                Task::none()
            }
            Message::KeyboardTab(tab) => {
                self.keyboard_tab = tab;
                self.key_capture = None;
                Task::none()
            }
            Message::InputTick => {
                let (buttons, name) = self::pad_state();
                self.input_pad_name = name;

                if let Some(target) = self.input_capture
                    && let Some(buttons) = buttons
                {
                    self.input_capture_baseline &= buttons;

                    let fresh = buttons & !self.input_capture_baseline;
                    if let Some(button) = input_settings::pressed_button(fresh) {
                        *input_settings::field(&mut self.config.input, target) =
                            Some(hostinput::config::button_name(button).to_owned());
                        self.input_capture = None;
                        self.persist_config();
                    }
                }

                Task::none()
            }
            Message::InputPointer(source) => {
                self.config.input.wii.pointer = Some(source);
                self.persist_config();
                Task::none()
            }
            Message::InputSensitivity(delta) => {
                let current = self.config.input.wii.pointer_sensitivity.unwrap_or(1.0);
                self.config.input.wii.pointer_sensitivity = Some((current + delta).clamp(0.25, 4.0));
                self.persist_config();
                Task::none()
            }
            Message::WiiPreset(id) => {
                self.config.select_wii_preset(id);
                self.input_capture = None;
                self.key_capture = None;
                self.persist_config();
                Task::none()
            }
            Message::WiiPresetReset => {
                self.config.reset_wii_preset();
                self.input_capture = None;
                self.key_capture = None;
                self.persist_config();
                Task::none()
            }
            Message::InputToggleNunchuk => {
                let current = self.config.input.wii.nunchuk_attached.unwrap_or(true);
                self.config.input.wii.nunchuk_attached = Some(!current);
                self.persist_config();
                Task::none()
            }
            Message::InputToggleLeftStick => {
                let current = self.config.input.wii.left_stick_dpad.unwrap_or(false);
                self.config.input.wii.left_stick_dpad = Some(!current);
                self.persist_config();
                Task::none()
            }
            Message::InputToggleStickDpad => {
                let current = self.config.input.wii.stick_dpad.unwrap_or(true);
                self.config.input.wii.stick_dpad = Some(!current);
                self.persist_config();
                Task::none()
            }
            Message::InputToggleInvert(target) => {
                let field = input_settings::invert_field(&mut self.config.input, target);
                *field = Some(!field.unwrap_or(false));
                self.persist_config();
                Task::none()
            }
            Message::InputReset => {
                match self.input_tab {
                    InputTab::Wii => {
                        self.config.input.wii = config::WiiPreset::defaults(self.config.active_wii_preset()).controller
                    }
                    InputTab::Gc => self.config.input.gc = Default::default(),
                }
                self.input_capture = None;
                self.persist_config();
                Task::none()
            }
            Message::KeyboardCapture(target) => {
                self.key_capture = if self.key_capture == Some(target) {
                    None
                } else {
                    Some(target)
                };
                Task::none()
            }
            Message::KeyboardCaptured(code) => {
                if let Some(target) = self.key_capture
                    && let Some(name) = keybinds::key_name(code)
                {
                    *keybinds::field(&mut self.config.keyboard, target) = Some(name.to_owned());
                    self.key_capture = None;
                    self.persist_config();
                }
                Task::none()
            }
            Message::KeyboardReset => {
                match self.keyboard_tab {
                    KeyboardTab::Wii => {
                        self.config.keyboard.wii = config::WiiPreset::defaults(self.config.active_wii_preset()).keyboard
                    }
                    KeyboardTab::Gc => self.config.keyboard.gc = Default::default(),
                    KeyboardTab::Hotkeys => self.config.keyboard.hotkeys = Default::default(),
                }
                self.key_capture = None;
                self.persist_config();
                Task::none()
            }
            Message::AboutClose => {
                self.about_open = false;
                Task::none()
            }
            Message::OpenUrl(url) => {
                if let Err(err) = webbrowser::open(&url) {
                    tracing::warn!(%err, %url, "failed to open URL");
                }
                Task::none()
            }
            Message::CheckForUpdates => {
                if matches!(self.update, UpdateState::Checking) {
                    return Task::none();
                }

                self.update = UpdateState::Checking;
                Task::perform(update::check(), Message::UpdateChecked)
            }
            Message::UpdateChecked(outcome) => {
                self.update = match outcome {
                    Outcome::UpToDate => UpdateState::UpToDate,
                    Outcome::Available(url) => {
                        tracing::info!(%url, "update available");
                        UpdateState::Available(url)
                    }
                    Outcome::Unpublished => UpdateState::Unpublished,
                    Outcome::Failed(err) => {
                        tracing::warn!(%err, "update check failed");
                        UpdateState::Failed
                    }
                };
                Task::none()
            }
            Message::GameClicked(idx) => {
                let now = Instant::now();
                let is_double = self
                    .last_click
                    .is_some_and(|(prev, when)| prev == idx && now.duration_since(when) <= DOUBLE_CLICK_WINDOW);

                if is_double {
                    self.last_click = None;
                    Task::done(Message::LaunchPlayer(idx))
                } else {
                    self.last_click = Some((idx, now));
                    if let Some(game) = self.games.get(idx) {
                        tracing::info!(path = %game.path.display(), title = %game.title, "game selected");
                    }
                    Task::none()
                }
            }
            Message::LaunchPlayer(idx) => {
                let Some(game) = self.games.get(idx).cloned() else {
                    return Task::none();
                };

                self.launch_game(game)
            }
            Message::SystemThemeLoaded(mode) | Message::SystemThemeChanged(mode) => {
                self.system_mode = mode;
                self.refresh_palette();
                Task::none()
            }
            Message::PlayerToggleFullscreen(id) => {
                let Some(player) = self.players.get_mut(&id) else {
                    return Task::none();
                };

                player.fullscreen = !player.fullscreen;
                let mode = if player.fullscreen {
                    window::Mode::Fullscreen
                } else {
                    window::Mode::Windowed
                };
                window::set_mode(id, mode)
            }
            Message::PlayerToggleOverlay(id) => {
                if let Some(player) = self.players.get_mut(&id) {
                    player.overlay = !player.overlay;
                }
                Task::none()
            }
            Message::PlayerToggleUncapped(id) => {
                let Some(player) = self.players.get_mut(&id) else {
                    return Task::none();
                };

                let (title, detail) = if player.state.toggle_throttle() {
                    ("Speed limit on", "Throttled to native speed")
                } else {
                    ("Speed limit off", "Running uncapped")
                };

                player.toast = Some(Toast::new(title, detail));
                Task::none()
            }
            Message::PlayerTogglePause(id) => {
                if let Some(player) = self.players.get(&id) {
                    player.state.toggle_pause();
                }
                Task::none()
            }
            Message::PlayerScreenshot(id) => {
                let Some(player) = self.players.get_mut(&id) else {
                    return Task::none();
                };

                let (title, detail) = match player.state.capture_frame() {
                    Some(frame) => {
                        let path = self::screenshot_path(&player.game.game_id);
                        let name = path
                            .file_name()
                            .map(|n| n.to_string_lossy().into_owned())
                            .unwrap_or_default();
                        capture::save_png_async(path, frame, true);
                        ("Screenshot saved", name)
                    }
                    None => ("Screenshot failed", "No frame to capture yet".to_owned()),
                };

                player.toast = Some(Toast::new(title, detail));
                Task::none()
            }
            Message::PlayerSaveState(id) => {
                let Some(player) = self.players.get_mut(&id) else {
                    return Task::none();
                };

                player.state.request_save_state();
                player.toast = Some(Toast::new("Saving state", player.game.game_id.clone()));
                Task::none()
            }
            Message::PlayerLoadState(id) => {
                let Some(player) = self.players.get_mut(&id) else {
                    return Task::none();
                };

                player.state.request_load_state();
                player.toast = Some(Toast::new("Loading state", player.game.game_id.clone()));
                Task::none()
            }
        }
    }

    pub fn view(&self, window_id: window::Id) -> Element<'_, Message> {
        if Some(window_id) == self.library_window {
            self.library_view()
        } else if let Some(player) = self.players.get(&window_id) {
            self.player_view(window_id, player)
        } else {
            container(text("")).width(Length::Fill).height(Length::Fill).into()
        }
    }

    fn library_view(&self) -> Element<'_, Message> {
        let palette = &self.palette;

        let body: Element<'_, Message> = if self.games.is_empty() {
            let (msg, hint) = if self.scanning {
                ("Scanning...", "Reading disc headers")
            } else if self.effective_library_roots().is_empty() {
                ("No libraries set", "Choose a GameCube or Wii folder from the File menu")
            } else {
                ("No games found", "Drop ISO, RVZ, or ZIP files into the library folder")
            };
            game_row::empty_state(palette, msg, hint)
        } else {
            let mut list = column![].spacing(0);
            for (idx, game) in self.games.iter().enumerate() {
                if !game.matches_lc(&self.search_lc) {
                    continue;
                }
                list = list.push(game_row::game_row(palette, idx, game));
            }
            scrollable(list).height(Length::Fill).width(Length::Fill).into()
        };

        let bg = palette.bg;
        let text_color = palette.text;
        let main = column![
            menubar::menubar(
                palette,
                self.config.cpu_mode,
                self.config.theme,
                self.config.ipl_hle,
                self.config.skip_ipl,
                self.config.upscale,
                self.config.texture_packs,
                self.config.aspect,
                self.config.memcard_enabled,
                self.config.sram_enabled,
            ),
            search_bar::search_bar(palette, &self.search),
            body,
            statusbar::statusbar(
                palette,
                self.config.cpu_mode,
                self.games.len(),
                self.scanning,
                &self.update
            ),
        ];

        let root = container(main)
            .width(Length::Fill)
            .height(Length::Fill)
            .style(move |_| container::Style {
                background: Some(Background::Color(bg)),
                text_color: Some(text_color),
                ..container::Style::default()
            });

        let mut root_element: Element<'_, Message> = root.into();
        if self.about_open {
            root_element = stack![root_element, self::about_overlay(palette)].into();
        }
        if self.input_open {
            root_element = stack![
                root_element,
                input_settings::overlay(
                    palette,
                    &self.config.input,
                    self.input_tab,
                    self.input_capture,
                    self.input_pad_name.as_deref(),
                    self.config.active_wii_preset(),
                )
            ]
            .into();
        }
        if self.keyboard_open {
            root_element = stack![
                root_element,
                input_settings::keyboard_overlay(
                    palette,
                    &self.config.keyboard,
                    self.keyboard_tab,
                    self.key_capture,
                    self.config.active_wii_preset()
                )
            ]
            .into();
        }

        if let Some(setup) = &self.setup {
            root_element = stack![root_element, setup.view(palette, &self.config)].into();
        }
        root_element
    }

    fn player_view<'a>(&'a self, window_id: window::Id, player: &'a PlayerWindow) -> Element<'a, Message> {
        let palette = &self.palette;
        let bg = palette.bg;
        let text_color = palette.text;

        let status = player.state.status();
        let shader: Element<'a, Message> =
            player::shader_widget(player.state.clone(), window_id, player.captured).into();

        let overlay: Option<Element<'a, Message>> = match &status {
            PlayerStatus::Ready => None,
            PlayerStatus::Booting => Some(self::overlay_card(
                palette,
                &format!("Loading {}", player.game.title),
                Some("Decompressing disc and warming up CPU heatsink..."),
                false,
            )),
            PlayerStatus::Failed(msg) => Some(self::overlay_card(palette, "Cannot start game", Some(msg), true)),
        };

        let mut layers: Vec<Element<'a, Message>> = vec![shader];
        if let Some(ov) = overlay {
            layers.push(ov);
        }
        let paused = player.state.is_paused();
        if player.overlay || paused {
            let stats = player.overlay.then(|| player.state.fps());
            layers.push(self::corner_overlay(palette, paused, stats));
        }
        if let Some(toast) = &player.toast {
            layers.push(self::toast_overlay(palette, toast));
        }

        let body: Element<'a, Message> = Stack::with_children(layers)
            .width(Length::Fill)
            .height(Length::Fill)
            .into();

        container(body)
            .width(Length::Fill)
            .height(Length::Fill)
            .style(move |_| container::Style {
                background: Some(Background::Color(bg)),
                text_color: Some(text_color),
                ..container::Style::default()
            })
            .into()
    }

    fn apply_mouse_capture(&mut self, id: window::Id, capture: bool) -> Task<Message> {
        let Some(player) = self.players.get_mut(&id) else {
            return Task::none();
        };

        let capture = capture && player.game.platform == Platform::Wii;
        player.captured = capture;
        let mouse_capture = player.mouse_capture.clone();

        window::run(id, move |window| {
            if let Err(error) = mouse_capture.lock().unwrap().set(window, capture) {
                tracing::warn!(%error, "failed to change player mouse capture");
            }
            Message::Noop
        })
        .discard()
    }

    fn idle_setup(&mut self) -> Option<&mut Setup> {
        self.setup.as_mut().filter(|s| !s.busy)
    }

    fn effective_library_roots(&self) -> Vec<PathBuf> {
        let mut roots = Vec::new();
        if let Some(p) = self
            .cli_gcn_override
            .clone()
            .or_else(|| self.config.gcn_library.clone())
        {
            roots.push(p);
        }

        if let Some(p) = self
            .cli_wii_override
            .clone()
            .or_else(|| self.config.wii_library.clone())
        {
            roots.push(p);
        }

        roots
    }

    fn persist_config(&mut self) {
        self.config.store_wii_preset();
        for player in self.players.values() {
            player.state.refresh_wii_input(&self.config);
        }
        let path = config::config_path();
        if let Err(err) = config::save(&path, &self.config) {
            tracing::warn!(%err, path = %path.display(), "failed to persist config");
        }
    }

    fn insert_game_sorted(&mut self, game: Game) {
        if let Some(index) = self.games.iter().position(|existing| existing.path == game.path) {
            if self.games[index].title_lc == game.title_lc {
                self.games[index] = game;
                return;
            }
            self.games.remove(index);
        }

        let pos = self
            .games
            .binary_search_by(|g| g.title_lc.cmp(&game.title_lc))
            .unwrap_or_else(|p| p);
        self.games.insert(pos, game);
    }

    fn refresh_palette(&mut self) {
        self.palette = self::resolve_palette(self.config.theme, self.system_mode);
    }

    fn launch_game(&self, game: Game) -> Task<Message> {
        let state = PlayerState::new(&game, &self.config);
        let (_, open) = window::open(window::Settings {
            size: iced::Size::new(960.0, 720.0),
            ..window::Settings::default()
        });

        open.map(move |id| Message::PlayerWindowOpened(id, Box::new(game.clone()), state.clone()))
    }
}

fn version_label() -> String {
    let hash = env!("GECKO_GIT_HASH");
    let channel = env!("GECKO_CHANNEL");
    if channel.is_empty() {
        hash.to_owned()
    } else {
        format!("{hash}-{channel}")
    }
}

fn resolve_palette(pref: ThemePreference, system_mode: Mode) -> Palette {
    let effective = match pref {
        ThemePreference::Light => Mode::Light,
        ThemePreference::Dark => Mode::Dark,
        ThemePreference::System => system_mode,
    };
    Palette::for_mode(effective)
}

fn screenshot_path(game_id: &str) -> PathBuf {
    capture::timestamped_path(game_id)
}

fn corner_card<'a>(palette: &Palette, content: Element<'a, Message>) -> Element<'a, Message> {
    let card_bg = Color { a: 0.85, ..palette.bg };
    let border_2 = palette.border_2;

    container(content)
        .padding(Padding::from([8, 12]))
        .style(move |_: &Theme| container::Style {
            background: Some(Background::Color(card_bg)),
            border: Border {
                color: border_2,
                width: 1.0,
                radius: 8.0.into(),
            },
            ..container::Style::default()
        })
        .into()
}

fn corner_overlay(palette: &Palette, paused: bool, stats: Option<(f32, f32)>) -> Element<'static, Message> {
    let mut cards = column![].spacing(8).align_x(iced::Alignment::End);

    if paused {
        cards = cards.push(self::corner_card(palette, self::pause_icon(palette)));
    }

    if let Some((fps, native_pct)) = stats {
        let label = text(format!("{fps:.1} FPS  {native_pct:.0}%"))
            .size(13)
            .color(palette.text);
        cards = cards.push(self::corner_card(palette, label.into()));
    }

    container(cards)
        .width(Length::Fill)
        .align_x(iced::Alignment::End)
        .padding(12)
        .into()
}

fn pause_icon(palette: &Palette) -> Element<'static, Message> {
    let bar_color = palette.text;
    let bar = move || {
        container(text(""))
            .width(5)
            .height(16)
            .style(move |_: &Theme| container::Style {
                background: Some(Background::Color(bar_color)),
                border: Border {
                    radius: 1.5.into(),
                    ..Border::default()
                },
                ..container::Style::default()
            })
    };

    row![bar(), bar()].spacing(4).into()
}

fn toast_overlay<'a>(palette: &Palette, toast: &'a Toast) -> Element<'a, Message> {
    let content = column![
        text(&toast.title).size(13).color(palette.text),
        text(&toast.detail).size(11).color(palette.text_dim),
    ]
    .spacing(2);
    let card = self::corner_card(palette, content.into());

    container(card)
        .width(Length::Fill)
        .height(Length::Fill)
        .align_x(iced::Alignment::End)
        .align_y(iced::Alignment::End)
        .padding(12)
        .into()
}

fn overlay_card(palette: &Palette, title: &str, detail: Option<&str>, error: bool) -> Element<'static, Message> {
    let bg = palette.bg;
    let border_2 = palette.border_2;
    let text_color = palette.text;
    let dim = palette.text_dim;
    let accent = if error { palette.purple } else { palette.accent };

    let backdrop_color = Color {
        a: 0.55,
        ..(if palette.is_dark { Color::BLACK } else { palette.text })
    };

    let mut card_col = column![text(title.to_owned()).size(20).color(text_color)].spacing(8);
    card_col = card_col.push(
        container(text(""))
            .width(40)
            .height(2)
            .style(move |_: &Theme| container::Style {
                background: Some(Background::Color(accent)),
                ..container::Style::default()
            }),
    );
    if let Some(detail) = detail {
        card_col = card_col.push(text(detail.to_owned()).size(12).color(dim));
    }

    let card: Element<'static, Message> = container(card_col.width(Length::Fill).align_x(iced::Alignment::Center))
        .width(Length::Fixed(420.0))
        .padding(24)
        .style(move |_: &Theme| container::Style {
            background: Some(Background::Color(bg)),
            border: Border {
                color: border_2,
                width: 1.0,
                radius: 12.0.into(),
            },
            ..container::Style::default()
        })
        .into();

    let backdrop: Element<'static, Message> = container(text(""))
        .width(Length::Fill)
        .height(Length::Fill)
        .style(move |_: &Theme| container::Style {
            background: Some(Background::Color(backdrop_color)),
            ..container::Style::default()
        })
        .into();

    let centered: Element<'static, Message> = container(card)
        .width(Length::Fill)
        .height(Length::Fill)
        .center_x(Length::Fill)
        .center_y(Length::Fill)
        .into();

    stack![backdrop, centered].into()
}

fn pad_state() -> (Option<u32>, Option<String>) {
    let service = hostinput::sdl::service();

    let buttons = service.shared.lock().unwrap().map(|port| port.state.buttons);
    let name = service.device.lock().unwrap().clone();

    (buttons, name)
}

fn capture_key_event(event: iced::Event, _status: iced::event::Status, _window: window::Id) -> Option<Message> {
    if let iced::Event::Keyboard(iced::keyboard::Event::KeyPressed { physical_key, .. }) = event {
        player::physical_to_code(&physical_key).map(Message::KeyboardCaptured)
    } else {
        None
    }
}

fn about_overlay(palette: &Palette) -> Element<'static, Message> {
    let surface = palette.surface;
    let surface_2 = palette.surface_2;
    let border = palette.border;
    let border_2 = palette.border_2;
    let text_color = palette.text;
    let dim = palette.text_dim;
    let mute = palette.text_mute;
    let link_color = palette.accent;

    let link_button = button(text(REPO_URL).size(12).color(link_color))
        .on_press(Message::OpenUrl(REPO_URL.to_owned()))
        .padding(Padding::from([2, 4]))
        .style(move |_: &Theme, status| {
            let bg = match status {
                button::Status::Hovered | button::Status::Pressed => Color { a: 0.08, ..link_color },
                _ => Color::TRANSPARENT,
            };
            button::Style {
                background: Some(Background::Color(bg)),
                text_color: link_color,
                border: Border {
                    radius: 4.0.into(),
                    ..Border::default()
                },
                ..button::Style::default()
            }
        });

    let content: Element<'static, Message> = column![
        text("Gecko").size(28).color(text_color),
        text("GameCube / Wii emulator").size(13).color(dim),
        link_button,
        container(text(""))
            .width(Length::Fill)
            .height(1)
            .style(move |_: &Theme| container::Style {
                background: Some(Background::Color(border)),
                ..container::Style::default()
            }),
        column![
            text("Author").size(13).color(text_color),
            text("Layle").size(12).color(dim),
        ]
        .spacing(2)
        .align_x(iced::Alignment::Center),
        column![
            text("Acknowledgements").size(13).color(text_color),
            text("zayd").size(12).color(dim),
            text("vxpm").size(12).color(dim),
            text("hazelwiss").size(12).color(dim),
            text("Dolphin team").size(12).color(dim),
        ]
        .spacing(2)
        .align_x(iced::Alignment::Center),
        text(self::version_label()).size(11).color(mute),
        button(text("Close").size(13))
            .on_press(Message::AboutClose)
            .padding(Padding::from([6, 14]))
            .style(move |_: &Theme, status| {
                let button_bg = match status {
                    button::Status::Hovered | button::Status::Pressed => surface_2,
                    _ => surface,
                };
                button::Style {
                    background: Some(Background::Color(button_bg)),
                    text_color,
                    border: Border {
                        color: border_2,
                        width: 1.0,
                        radius: 6.0.into(),
                    },
                    ..button::Style::default()
                }
            }),
    ]
    .spacing(8)
    .align_x(iced::Alignment::Center)
    .into();

    overlay::modal(palette, 320.0, 24.0, Message::AboutClose, content)
}