romm_cli/tui/
app.rs

1//! Application state and TUI event loop.
2//!
3//! The `App` struct owns long-lived state (config, HTTP client, cache,
4//! downloads, and the currently active `AppScreen`). It drives a simple
5//! state machine:
6//! - render the current screen,
7//! - wait for input,
8//! - dispatch the key to a small handler per screen.
9//!
10//! This is intentionally separated from the drawing code in `screens/`
11//! so that alternative frontends can reuse the same \"backend\" services.
12
13use anyhow::Result;
14use crossterm::event::{
15    self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind,
16};
17use crossterm::execute;
18use crossterm::terminal::{
19    disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
20};
21use ratatui::backend::CrosstermBackend;
22use ratatui::style::Color;
23use ratatui::Terminal;
24use std::time::Duration;
25
26use crate::client::RommClient;
27use crate::config::Config;
28use crate::core::cache::{RomCache, RomCacheKey};
29use crate::core::download::DownloadManager;
30use crate::endpoints::{collections::ListCollections, platforms::ListPlatforms, roms::GetRoms};
31use crate::types::RomList;
32
33use super::openapi::{resolve_path_template, EndpointRegistry};
34use super::screens::connected_splash::{self, StartupSplash};
35use super::screens::setup_wizard::SetupWizard;
36use super::screens::{
37    BrowseScreen, DownloadScreen, ExecuteScreen, GameDetailPrevious, GameDetailScreen,
38    LibraryBrowseScreen, MainMenuScreen, ResultDetailScreen, ResultScreen, SearchScreen,
39    SettingsScreen,
40};
41
42// ---------------------------------------------------------------------------
43// Screen enum
44// ---------------------------------------------------------------------------
45
46/// All possible high-level screens in the TUI.
47///
48/// `App` holds exactly one of these at a time and delegates both
49/// rendering and key handling based on the current variant.
50pub enum AppScreen {
51    MainMenu(MainMenuScreen),
52    LibraryBrowse(LibraryBrowseScreen),
53    Search(SearchScreen),
54    Settings(SettingsScreen),
55    Browse(BrowseScreen),
56    Execute(ExecuteScreen),
57    Result(ResultScreen),
58    ResultDetail(ResultDetailScreen),
59    GameDetail(Box<GameDetailScreen>),
60    Download(DownloadScreen),
61    SetupWizard(Box<crate::tui::screens::setup_wizard::SetupWizard>),
62}
63
64// ---------------------------------------------------------------------------
65// App
66// ---------------------------------------------------------------------------
67
68/// Root application object for the TUI.
69///
70/// Owns shared services (`RommClient`, `RomCache`, `DownloadManager`)
71/// as well as the currently active [`AppScreen`].
72pub struct App {
73    pub screen: AppScreen,
74    client: RommClient,
75    config: Config,
76    registry: EndpointRegistry,
77    /// RomM server version from `GET /api/heartbeat` (`SYSTEM.VERSION`), if available.
78    server_version: Option<String>,
79    rom_cache: RomCache,
80    downloads: DownloadManager,
81    /// Screen to restore when closing the Download overlay.
82    screen_before_download: Option<AppScreen>,
83    /// Deferred ROM load: (cache_key, api_request, expected_rom_count).
84    deferred_load_roms: Option<(Option<RomCacheKey>, Option<GetRoms>, u64)>,
85    /// Brief “connected” banner after setup or when the server responds to heartbeat.
86    startup_splash: Option<StartupSplash>,
87    pub global_error: Option<String>,
88}
89
90impl App {
91    /// Construct a new `App` with fresh cache and empty download list.
92    pub fn new(
93        client: RommClient,
94        config: Config,
95        registry: EndpointRegistry,
96        server_version: Option<String>,
97        startup_splash: Option<StartupSplash>,
98    ) -> Self {
99        Self {
100            screen: AppScreen::MainMenu(MainMenuScreen::new()),
101            client,
102            config,
103            registry,
104            server_version,
105            rom_cache: RomCache::load(),
106            downloads: DownloadManager::new(),
107            screen_before_download: None,
108            deferred_load_roms: None,
109            startup_splash,
110            global_error: None,
111        }
112    }
113
114    pub fn set_error(&mut self, err: anyhow::Error) {
115        self.global_error = Some(format!("{:#}", err));
116    }
117
118    // -----------------------------------------------------------------------
119    // Event loop
120    // -----------------------------------------------------------------------
121
122    /// Main TUI event loop.
123    ///
124    /// This method owns the terminal for the lifetime of the app,
125    /// repeatedly drawing the current screen and dispatching key
126    /// events until the user chooses to quit.
127    pub async fn run(&mut self) -> Result<()> {
128        enable_raw_mode()?;
129        let mut stdout = std::io::stdout();
130        execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
131        let backend = CrosstermBackend::new(stdout);
132        let mut terminal = Terminal::new(backend)?;
133
134        loop {
135            if self
136                .startup_splash
137                .as_ref()
138                .is_some_and(|s| s.should_auto_dismiss())
139            {
140                self.startup_splash = None;
141            }
142            // Draw the current screen. `App::render` delegates to the
143            // appropriate screen type based on `self.screen`.
144            terminal.draw(|f| self.render(f))?;
145
146            // Poll with a short timeout so the UI refreshes during downloads
147            // even when the user is not pressing any keys.
148            if event::poll(Duration::from_millis(100))? {
149                if let Event::Key(key) = event::read()? {
150                    if key.kind == KeyEventKind::Press && self.handle_key(key.code).await? {
151                        break;
152                    }
153                }
154            }
155
156            // Process deferred ROM fetch (set during LibraryBrowse ↑/↓).
157            // This avoids borrowing `self` mutably in two places at once:
158            // the screen handler only *records* the intent to load ROMs,
159            // and the actual HTTP call happens here after rendering.
160            if let Some((key, req, expected)) = self.deferred_load_roms.take() {
161                if let Ok(Some(roms)) = self.load_roms_cached(key, req, expected).await {
162                    if let AppScreen::LibraryBrowse(ref mut lib) = self.screen {
163                        lib.set_roms(roms);
164                    }
165                }
166            }
167        }
168
169        disable_raw_mode()?;
170        execute!(
171            terminal.backend_mut(),
172            LeaveAlternateScreen,
173            DisableMouseCapture
174        )?;
175        terminal.show_cursor()?;
176        Ok(())
177    }
178
179    // -----------------------------------------------------------------------
180    // Cache helper
181    // -----------------------------------------------------------------------
182
183    /// Fetch ROMs from the persistent cache if the count still matches,
184    /// otherwise hit the API and update the cache on disk.
185    async fn load_roms_cached(
186        &mut self,
187        key: Option<RomCacheKey>,
188        req: Option<GetRoms>,
189        expected_count: u64,
190    ) -> Result<Option<RomList>> {
191        // Try the disk-backed cache first.
192        if let Some(k) = key {
193            if let Some(cached) = self.rom_cache.get_valid(&k, expected_count) {
194                return Ok(Some(cached.clone()));
195            }
196        }
197        // Cache miss or stale — fetch fresh data from the API.
198        if let Some(r) = req {
199            let mut roms = self.client.call(&r).await?;
200            let total = roms.total;
201            let ceiling = 20000;
202
203            // The RomM API has a default limit (often 500) even if we request more.
204            // Loop until the items list is complete or we hit the ceiling.
205            while (roms.items.len() as u64) < total && (roms.items.len() as u64) < ceiling {
206                let mut next_req = r.clone();
207                next_req.offset = Some(roms.items.len() as u32);
208
209                let next_batch = self.client.call(&next_req).await?;
210                if next_batch.items.is_empty() {
211                    break;
212                }
213                roms.items.extend(next_batch.items);
214            }
215
216            if let Some(k) = key {
217                self.rom_cache.insert(k, roms.clone(), expected_count); // also persists to disk
218            }
219            return Ok(Some(roms));
220        }
221        Ok(None)
222    }
223
224    // -----------------------------------------------------------------------
225    // Key dispatch — one small method per screen
226    // -----------------------------------------------------------------------
227
228    pub async fn handle_key(&mut self, key: KeyCode) -> Result<bool> {
229        if self.global_error.is_some() {
230            if key == KeyCode::Esc || key == KeyCode::Enter {
231                self.global_error = None;
232            }
233            return Ok(false);
234        }
235
236        if self.startup_splash.is_some() {
237            self.startup_splash = None;
238            return Ok(false);
239        }
240
241        // Global shortcut: 'd' toggles Download overlay (not on screens that need free typing / menus).
242        if key == KeyCode::Char('d')
243            && !matches!(
244                &self.screen,
245                AppScreen::Search(_) | AppScreen::Settings(_) | AppScreen::SetupWizard(_)
246            )
247        {
248            self.toggle_download_screen();
249            return Ok(false);
250        }
251
252        match &self.screen {
253            AppScreen::MainMenu(_) => self.handle_main_menu(key).await,
254            AppScreen::LibraryBrowse(_) => self.handle_library_browse(key).await,
255            AppScreen::Search(_) => self.handle_search(key).await,
256            AppScreen::Settings(_) => self.handle_settings(key),
257            AppScreen::Browse(_) => self.handle_browse(key),
258            AppScreen::Execute(_) => self.handle_execute(key).await,
259            AppScreen::Result(_) => self.handle_result(key),
260            AppScreen::ResultDetail(_) => self.handle_result_detail(key),
261            AppScreen::GameDetail(_) => self.handle_game_detail(key),
262            AppScreen::Download(_) => self.handle_download(key),
263            AppScreen::SetupWizard(_) => self.handle_setup_wizard(key).await,
264        }
265    }
266
267    // -- Download overlay ---------------------------------------------------
268
269    fn toggle_download_screen(&mut self) {
270        let current =
271            std::mem::replace(&mut self.screen, AppScreen::MainMenu(MainMenuScreen::new()));
272        match current {
273            AppScreen::Download(_) => {
274                self.screen = self
275                    .screen_before_download
276                    .take()
277                    .unwrap_or_else(|| AppScreen::MainMenu(MainMenuScreen::new()));
278            }
279            other => {
280                self.screen_before_download = Some(other);
281                self.screen = AppScreen::Download(DownloadScreen::new(self.downloads.shared()));
282            }
283        }
284    }
285
286    fn handle_download(&mut self, key: KeyCode) -> Result<bool> {
287        if key == KeyCode::Esc || key == KeyCode::Char('d') {
288            self.screen = self
289                .screen_before_download
290                .take()
291                .unwrap_or_else(|| AppScreen::MainMenu(MainMenuScreen::new()));
292        }
293        Ok(false)
294    }
295
296    // -- Main menu ----------------------------------------------------------
297
298    async fn handle_main_menu(&mut self, key: KeyCode) -> Result<bool> {
299        let menu = match &mut self.screen {
300            AppScreen::MainMenu(m) => m,
301            _ => return Ok(false),
302        };
303        match key {
304            KeyCode::Up | KeyCode::Char('k') => menu.previous(),
305            KeyCode::Down | KeyCode::Char('j') => menu.next(),
306            KeyCode::Enter => match menu.selected {
307                0 => {
308                    let platforms = match self.client.call(&ListPlatforms).await {
309                        Ok(p) => p,
310                        Err(e) => {
311                            self.set_error(e);
312                            return Ok(false);
313                        }
314                    };
315                    let collections = self.client.call(&ListCollections).await.unwrap_or_default();
316                    let mut lib = LibraryBrowseScreen::new(platforms, collections);
317                    if lib.list_len() > 0 {
318                        let key = lib.cache_key();
319                        let expected = lib.expected_rom_count();
320                        let req = lib
321                            .get_roms_request_platform()
322                            .or_else(|| lib.get_roms_request_collection());
323                        if let Ok(Some(roms)) = self.load_roms_cached(key, req, expected).await {
324                            lib.set_roms(roms);
325                        }
326                    }
327                    self.screen = AppScreen::LibraryBrowse(lib);
328                }
329                1 => self.screen = AppScreen::Search(SearchScreen::new()),
330                2 => {
331                    self.screen_before_download = Some(AppScreen::MainMenu(MainMenuScreen::new()));
332                    self.screen = AppScreen::Download(DownloadScreen::new(self.downloads.shared()));
333                }
334                3 => {
335                    self.screen = AppScreen::Settings(SettingsScreen::new(
336                        &self.config,
337                        self.server_version.as_deref(),
338                    ))
339                }
340                4 => self.screen = AppScreen::Browse(BrowseScreen::new(self.registry.clone())),
341                5 => return Ok(true),
342                _ => {}
343            },
344            KeyCode::Esc | KeyCode::Char('q') => return Ok(true),
345            _ => {}
346        }
347        Ok(false)
348    }
349
350    // -- Library browse -----------------------------------------------------
351
352    async fn handle_library_browse(&mut self, key: KeyCode) -> Result<bool> {
353        use super::screens::library_browse::{LibrarySearchMode, LibraryViewMode};
354
355        let lib = match &mut self.screen {
356            AppScreen::LibraryBrowse(l) => l,
357            _ => return Ok(false),
358        };
359
360        // If in search mode, intercept typing keys.
361        if let Some(mode) = lib.search_mode {
362            match key {
363                KeyCode::Esc => lib.clear_search(),
364                KeyCode::Backspace => lib.delete_search_char(),
365                KeyCode::Char(c) => lib.add_search_char(c),
366                KeyCode::Tab if mode == LibrarySearchMode::Jump => lib.jump_to_match(true),
367                KeyCode::Enter => lib.search_mode = None, // Commit search (keep filtered/position)
368                _ => {}
369            }
370            return Ok(false);
371        }
372
373        match key {
374            KeyCode::Up | KeyCode::Char('k') => {
375                if lib.view_mode == LibraryViewMode::List {
376                    lib.list_previous();
377                    if lib.list_len() > 0 {
378                        lib.clear_roms(); // avoid showing previous console's games
379                        let key = lib.cache_key();
380                        let expected = lib.expected_rom_count();
381                        let req = lib
382                            .get_roms_request_platform()
383                            .or_else(|| lib.get_roms_request_collection());
384                        self.deferred_load_roms = Some((key, req, expected));
385                    }
386                } else {
387                    lib.rom_previous();
388                }
389            }
390            KeyCode::Down | KeyCode::Char('j') => {
391                if lib.view_mode == LibraryViewMode::List {
392                    lib.list_next();
393                    if lib.list_len() > 0 {
394                        lib.clear_roms(); // avoid showing previous console's games
395                        let key = lib.cache_key();
396                        let expected = lib.expected_rom_count();
397                        let req = lib
398                            .get_roms_request_platform()
399                            .or_else(|| lib.get_roms_request_collection());
400                        self.deferred_load_roms = Some((key, req, expected));
401                    }
402                } else {
403                    lib.rom_next();
404                }
405            }
406            KeyCode::Left | KeyCode::Char('h') => {
407                if lib.view_mode == LibraryViewMode::Roms {
408                    lib.back_to_list();
409                }
410            }
411            KeyCode::Right | KeyCode::Char('l') => lib.switch_view(),
412            KeyCode::Tab => {
413                if lib.view_mode == LibraryViewMode::List {
414                    lib.switch_view();
415                } else {
416                    lib.switch_view(); // Normal tab also switches panels
417                }
418            }
419            KeyCode::Char('/') if lib.view_mode == LibraryViewMode::Roms => {
420                lib.enter_search(LibrarySearchMode::Filter);
421            }
422            KeyCode::Char('f') if lib.view_mode == LibraryViewMode::Roms => {
423                lib.enter_search(LibrarySearchMode::Jump);
424            }
425            KeyCode::Enter => {
426                if lib.view_mode == LibraryViewMode::List {
427                    lib.switch_view();
428                } else if let Some((primary, others)) = lib.get_selected_group() {
429                    let lib_screen = std::mem::replace(
430                        &mut self.screen,
431                        AppScreen::MainMenu(MainMenuScreen::new()),
432                    );
433                    if let AppScreen::LibraryBrowse(l) = lib_screen {
434                        self.screen = AppScreen::GameDetail(Box::new(GameDetailScreen::new(
435                            primary,
436                            others,
437                            GameDetailPrevious::Library(l),
438                            self.downloads.shared(),
439                        )));
440                    }
441                }
442            }
443            KeyCode::Char('t') => lib.switch_subsection(),
444            KeyCode::Esc => {
445                if lib.view_mode == LibraryViewMode::Roms {
446                    lib.back_to_list();
447                } else {
448                    self.screen = AppScreen::MainMenu(MainMenuScreen::new());
449                }
450            }
451            KeyCode::Char('q') => return Ok(true),
452            _ => {}
453        }
454        Ok(false)
455    }
456
457    // -- Search -------------------------------------------------------------
458
459    async fn handle_search(&mut self, key: KeyCode) -> Result<bool> {
460        let search = match &mut self.screen {
461            AppScreen::Search(s) => s,
462            _ => return Ok(false),
463        };
464        match key {
465            KeyCode::Backspace => search.delete_char(),
466            KeyCode::Left => search.cursor_left(),
467            KeyCode::Right => search.cursor_right(),
468            KeyCode::Up => search.previous(),
469            KeyCode::Down => search.next(),
470            KeyCode::Char(c) => search.add_char(c),
471            KeyCode::Enter => {
472                if search.result_groups.is_some() {
473                    if let Some((primary, others)) = search.get_selected_group() {
474                        let prev = std::mem::replace(
475                            &mut self.screen,
476                            AppScreen::MainMenu(MainMenuScreen::new()),
477                        );
478                        if let AppScreen::Search(s) = prev {
479                            self.screen = AppScreen::GameDetail(Box::new(GameDetailScreen::new(
480                                primary,
481                                others,
482                                GameDetailPrevious::Search(s),
483                                self.downloads.shared(),
484                            )));
485                        }
486                    }
487                } else if !search.query.is_empty() {
488                    let req = GetRoms {
489                        search_term: Some(search.query.clone()),
490                        limit: Some(50),
491                        ..Default::default()
492                    };
493                    if let Ok(roms) = self.client.call(&req).await {
494                        search.set_results(roms);
495                    }
496                }
497            }
498            KeyCode::Esc => {
499                if search.results.is_some() {
500                    search.clear_results();
501                } else {
502                    self.screen = AppScreen::MainMenu(MainMenuScreen::new());
503                }
504            }
505            _ => {}
506        }
507        Ok(false)
508    }
509
510    // -- Settings -----------------------------------------------------------
511
512    fn handle_settings(&mut self, key: KeyCode) -> Result<bool> {
513        let settings = match &mut self.screen {
514            AppScreen::Settings(s) => s,
515            _ => return Ok(false),
516        };
517
518        if settings.editing {
519            match key {
520                KeyCode::Enter => {
521                    settings.save_edit();
522                }
523                KeyCode::Esc => settings.cancel_edit(),
524                KeyCode::Backspace => settings.delete_char(),
525                KeyCode::Left => settings.move_cursor_left(),
526                KeyCode::Right => settings.move_cursor_right(),
527                KeyCode::Char(c) => settings.add_char(c),
528                _ => {}
529            }
530            return Ok(false);
531        }
532
533        match key {
534            KeyCode::Up | KeyCode::Char('k') => settings.previous(),
535            KeyCode::Down | KeyCode::Char('j') => settings.next(),
536            KeyCode::Enter => {
537                if settings.selected_index == 3 {
538                    self.screen =
539                        AppScreen::SetupWizard(Box::new(SetupWizard::new_auth_only(&self.config)));
540                } else {
541                    settings.enter_edit();
542                }
543            }
544            KeyCode::Char('s' | 'S') => {
545                // Save to disk (accept both cases; footer shows "S:")
546                use crate::config::persist_user_config;
547                if let Err(e) = persist_user_config(
548                    &settings.base_url,
549                    &settings.download_dir,
550                    settings.use_https,
551                    self.config.auth.clone(),
552                ) {
553                    settings.message = Some((format!("Error saving: {e}"), Color::Red));
554                } else {
555                    settings.message = Some(("Saved to config.json".to_string(), Color::Green));
556                    // Update app state
557                    self.config.base_url = settings.base_url.clone();
558                    self.config.download_dir = settings.download_dir.clone();
559                    self.config.use_https = settings.use_https;
560                    // Re-create client to pick up new base URL
561                    if let Ok(new_client) = RommClient::new(&self.config, self.client.verbose()) {
562                        self.client = new_client;
563                    }
564                }
565            }
566            KeyCode::Esc => self.screen = AppScreen::MainMenu(MainMenuScreen::new()),
567            KeyCode::Char('q') => return Ok(true),
568            _ => {}
569        }
570        Ok(false)
571    }
572
573    // -- API Browse ---------------------------------------------------------
574
575    fn handle_browse(&mut self, key: KeyCode) -> Result<bool> {
576        use super::screens::browse::ViewMode;
577
578        let browse = match &mut self.screen {
579            AppScreen::Browse(b) => b,
580            _ => return Ok(false),
581        };
582        match key {
583            KeyCode::Up | KeyCode::Char('k') => browse.previous(),
584            KeyCode::Down | KeyCode::Char('j') => browse.next(),
585            KeyCode::Left | KeyCode::Char('h') => {
586                if browse.view_mode == ViewMode::Endpoints {
587                    browse.switch_view();
588                }
589            }
590            KeyCode::Right | KeyCode::Char('l') => {
591                if browse.view_mode == ViewMode::Sections {
592                    browse.switch_view();
593                }
594            }
595            KeyCode::Tab => browse.switch_view(),
596            KeyCode::Enter => {
597                if browse.view_mode == ViewMode::Endpoints {
598                    if let Some(ep) = browse.get_selected_endpoint() {
599                        self.screen = AppScreen::Execute(ExecuteScreen::new(ep.clone()));
600                    }
601                } else {
602                    browse.switch_view();
603                }
604            }
605            KeyCode::Esc => self.screen = AppScreen::MainMenu(MainMenuScreen::new()),
606            _ => {}
607        }
608        Ok(false)
609    }
610
611    // -- Execute endpoint ---------------------------------------------------
612
613    async fn handle_execute(&mut self, key: KeyCode) -> Result<bool> {
614        let execute = match &mut self.screen {
615            AppScreen::Execute(e) => e,
616            _ => return Ok(false),
617        };
618        match key {
619            KeyCode::Tab => execute.next_field(),
620            KeyCode::BackTab => execute.previous_field(),
621            KeyCode::Char(c) => execute.add_char_to_focused(c),
622            KeyCode::Backspace => execute.delete_char_from_focused(),
623            KeyCode::Enter => {
624                let endpoint = execute.endpoint.clone();
625                let query = execute.get_query_params();
626                let body = if endpoint.has_body && !execute.body_text.is_empty() {
627                    Some(serde_json::from_str(&execute.body_text)?)
628                } else {
629                    None
630                };
631                let resolved_path =
632                    match resolve_path_template(&endpoint.path, &execute.get_path_params()) {
633                        Ok(p) => p,
634                        Err(e) => {
635                            self.screen = AppScreen::Result(ResultScreen::new(
636                                serde_json::json!({ "error": format!("{e}") }),
637                                None,
638                                None,
639                            ));
640                            return Ok(false);
641                        }
642                    };
643                match self
644                    .client
645                    .request_json(&endpoint.method, &resolved_path, &query, body)
646                    .await
647                {
648                    Ok(result) => {
649                        self.screen = AppScreen::Result(ResultScreen::new(
650                            result,
651                            Some(&endpoint.method),
652                            Some(resolved_path.as_str()),
653                        ));
654                    }
655                    Err(e) => {
656                        self.screen = AppScreen::Result(ResultScreen::new(
657                            serde_json::json!({ "error": format!("{e}") }),
658                            None,
659                            None,
660                        ));
661                    }
662                }
663            }
664            KeyCode::Esc => {
665                self.screen = AppScreen::Browse(BrowseScreen::new(self.registry.clone()));
666            }
667            _ => {}
668        }
669        Ok(false)
670    }
671
672    // -- Result view --------------------------------------------------------
673
674    fn handle_result(&mut self, key: KeyCode) -> Result<bool> {
675        use super::screens::result::ResultViewMode;
676
677        let result = match &mut self.screen {
678            AppScreen::Result(r) => r,
679            _ => return Ok(false),
680        };
681        match key {
682            KeyCode::Up | KeyCode::Char('k') => {
683                if result.view_mode == ResultViewMode::Json {
684                    result.scroll_up(1);
685                } else {
686                    result.table_previous();
687                }
688            }
689            KeyCode::Down => {
690                if result.view_mode == ResultViewMode::Json {
691                    result.scroll_down(1);
692                } else {
693                    result.table_next();
694                }
695            }
696            KeyCode::Char('j') => {
697                if result.view_mode == ResultViewMode::Json {
698                    result.scroll_down(1);
699                }
700            }
701            KeyCode::PageUp => {
702                if result.view_mode == ResultViewMode::Table {
703                    result.table_page_up();
704                } else {
705                    result.scroll_up(10);
706                }
707            }
708            KeyCode::PageDown => {
709                if result.view_mode == ResultViewMode::Table {
710                    result.table_page_down();
711                } else {
712                    result.scroll_down(10);
713                }
714            }
715            KeyCode::Char('t') => {
716                if result.table_row_count > 0 {
717                    result.switch_view_mode();
718                }
719            }
720            KeyCode::Enter => {
721                if result.view_mode == ResultViewMode::Table && result.table_row_count > 0 {
722                    if let Some(item) = result.get_selected_item_value() {
723                        let prev = std::mem::replace(
724                            &mut self.screen,
725                            AppScreen::MainMenu(MainMenuScreen::new()),
726                        );
727                        if let AppScreen::Result(rs) = prev {
728                            self.screen =
729                                AppScreen::ResultDetail(ResultDetailScreen::new(rs, item));
730                        }
731                    }
732                }
733            }
734            KeyCode::Esc => {
735                result.clear_message();
736                self.screen = AppScreen::Browse(BrowseScreen::new(self.registry.clone()));
737            }
738            KeyCode::Char('q') => return Ok(true),
739            _ => {}
740        }
741        Ok(false)
742    }
743
744    // -- Result detail ------------------------------------------------------
745
746    fn handle_result_detail(&mut self, key: KeyCode) -> Result<bool> {
747        let detail = match &mut self.screen {
748            AppScreen::ResultDetail(d) => d,
749            _ => return Ok(false),
750        };
751        match key {
752            KeyCode::Up | KeyCode::Char('k') => detail.scroll_up(1),
753            KeyCode::Down | KeyCode::Char('j') => detail.scroll_down(1),
754            KeyCode::PageUp => detail.scroll_up(10),
755            KeyCode::PageDown => detail.scroll_down(10),
756            KeyCode::Char('o') => detail.open_image_url(),
757            KeyCode::Esc => {
758                detail.clear_message();
759                let prev =
760                    std::mem::replace(&mut self.screen, AppScreen::MainMenu(MainMenuScreen::new()));
761                if let AppScreen::ResultDetail(d) = prev {
762                    self.screen = AppScreen::Result(d.parent);
763                }
764            }
765            KeyCode::Char('q') => return Ok(true),
766            _ => {}
767        }
768        Ok(false)
769    }
770
771    // -- Game detail --------------------------------------------------------
772
773    fn handle_game_detail(&mut self, key: KeyCode) -> Result<bool> {
774        let detail = match &mut self.screen {
775            AppScreen::GameDetail(d) => d,
776            _ => return Ok(false),
777        };
778
779        // Acknowledge download completion on any key press
780        // (check if there's a completed/errored download for this ROM)
781        if !detail.download_completion_acknowledged {
782            if let Ok(list) = detail.downloads.lock() {
783                let has_completed = list.iter().any(|j| {
784                    j.rom_id == detail.rom.id
785                        && matches!(
786                            j.status,
787                            crate::core::download::DownloadStatus::Done
788                                | crate::core::download::DownloadStatus::Error(_)
789                        )
790                });
791                let is_still_downloading = list.iter().any(|j| {
792                    j.rom_id == detail.rom.id
793                        && matches!(j.status, crate::core::download::DownloadStatus::Downloading)
794                });
795                // Only acknowledge if there's a completion and no active download
796                if has_completed && !is_still_downloading {
797                    detail.download_completion_acknowledged = true;
798                }
799            }
800        }
801
802        match key {
803            KeyCode::Enter => {
804                // Only start a download once per detail view and avoid
805                // stacking multiple concurrent downloads for the same ROM.
806                if !detail.has_started_download {
807                    detail.has_started_download = true;
808                    self.downloads
809                        .start_download(&detail.rom, self.client.clone());
810                }
811            }
812            KeyCode::Char('o') => detail.open_cover(),
813            KeyCode::Char('m') => detail.toggle_technical(),
814            KeyCode::Esc => {
815                detail.clear_message();
816                let prev =
817                    std::mem::replace(&mut self.screen, AppScreen::MainMenu(MainMenuScreen::new()));
818                if let AppScreen::GameDetail(g) = prev {
819                    self.screen = match g.previous {
820                        GameDetailPrevious::Library(l) => AppScreen::LibraryBrowse(l),
821                        GameDetailPrevious::Search(s) => AppScreen::Search(s),
822                    };
823                }
824            }
825            KeyCode::Char('q') => return Ok(true),
826            _ => {}
827        }
828        Ok(false)
829    }
830
831    // -- Setup Wizard -------------------------------------------------------
832
833    async fn handle_setup_wizard(&mut self, key: KeyCode) -> Result<bool> {
834        let wizard = match &mut self.screen {
835            AppScreen::SetupWizard(w) => w,
836            _ => return Ok(false),
837        };
838
839        // Create a dummy event to pass to handle_key
840        let event = crossterm::event::KeyEvent::new(key, crossterm::event::KeyModifiers::empty());
841        if wizard.handle_key(event)? {
842            // Esc pressed
843            self.screen = AppScreen::Settings(SettingsScreen::new(
844                &self.config,
845                self.server_version.as_deref(),
846            ));
847            return Ok(false);
848        }
849
850        if wizard.testing {
851            let result = wizard.try_connect_and_persist(self.client.verbose()).await;
852            wizard.testing = false;
853            match result {
854                Ok(cfg) => {
855                    self.config = cfg;
856                    if let Ok(new_client) = RommClient::new(&self.config, self.client.verbose()) {
857                        self.client = new_client;
858                    }
859                    let mut settings =
860                        SettingsScreen::new(&self.config, self.server_version.as_deref());
861                    settings.message = Some((
862                        "Authentication updated successfully".to_string(),
863                        Color::Green,
864                    ));
865                    self.screen = AppScreen::Settings(settings);
866                }
867                Err(e) => {
868                    wizard.error = Some(format!("{e:#}"));
869                }
870            }
871        }
872        Ok(false)
873    }
874
875    // -----------------------------------------------------------------------
876    // Render
877    // -----------------------------------------------------------------------
878
879    fn render(&mut self, f: &mut ratatui::Frame) {
880        let area = f.size();
881        if let Some(ref splash) = self.startup_splash {
882            connected_splash::render(f, area, splash);
883            return;
884        }
885        match &mut self.screen {
886            AppScreen::MainMenu(menu) => menu.render(f, area),
887            AppScreen::LibraryBrowse(lib) => lib.render(f, area),
888            AppScreen::Search(search) => {
889                search.render(f, area);
890                if let Some((x, y)) = search.cursor_position(area) {
891                    f.set_cursor(x, y);
892                }
893            }
894            AppScreen::Settings(settings) => {
895                settings.render(f, area);
896                if let Some((x, y)) = settings.cursor_position(area) {
897                    f.set_cursor(x, y);
898                }
899            }
900            AppScreen::Browse(browse) => browse.render(f, area),
901            AppScreen::Execute(execute) => {
902                execute.render(f, area);
903                if let Some((x, y)) = execute.cursor_position(area) {
904                    f.set_cursor(x, y);
905                }
906            }
907            AppScreen::Result(result) => result.render(f, area),
908            AppScreen::ResultDetail(detail) => detail.render(f, area),
909            AppScreen::GameDetail(detail) => detail.render(f, area),
910            AppScreen::Download(d) => d.render(f, area),
911            AppScreen::SetupWizard(wizard) => {
912                wizard.render(f, area);
913                if let Some((x, y)) = wizard.cursor_pos(area) {
914                    f.set_cursor(x, y);
915                }
916            }
917        }
918
919        if let Some(ref err) = self.global_error {
920            let popup_area = ratatui::layout::Rect {
921                x: area.width.saturating_sub(60) / 2,
922                y: area.height.saturating_sub(10) / 2,
923                width: 60.min(area.width),
924                height: 10.min(area.height),
925            };
926            f.render_widget(ratatui::widgets::Clear, popup_area);
927            let block = ratatui::widgets::Block::default()
928                .title("Error")
929                .borders(ratatui::widgets::Borders::ALL)
930                .style(ratatui::style::Style::default().fg(ratatui::style::Color::Red));
931            let text = format!("{}\n\nPress Esc to dismiss", err);
932            let paragraph = ratatui::widgets::Paragraph::new(text)
933                .block(block)
934                .wrap(ratatui::widgets::Wrap { trim: true });
935            f.render_widget(paragraph, popup_area);
936        }
937    }
938}
romm_cli/tui/app.rs

romm_cli/tui/
app.rs
