use super::*;

impl App {
    fn new(options: Options, config_path: PathBuf, config: config::Config) -> Self {
        static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
        let path = std::env::temp_dir()
            .join(format!(
                "tubular-ui-state-{}-{}",
                std::process::id(),
                NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
            ))
            .join("config.toml");
        Self::with_state(
            options,
            config_path,
            config,
            video_state::State::open(&path).unwrap(),
        )
    }
}

#[test]
fn startup_provider_selection_preserves_query_and_handles_boundaries_and_cancel() {
    use std::ops::ControlFlow::{Break, Continue};
    let mut selected = 0;
    assert_eq!(
        provider_selection(&mut selected, Some(Action::SelectorPrevious)),
        Continue(())
    );
    for (action, miruro) in [(Action::SelectorOpen, false), (Action::SelectorNext, true)] {
        if action == Action::SelectorNext {
            assert_eq!(
                provider_selection(&mut selected, Some(action)),
                Continue(())
            );
            assert_eq!(
                provider_selection(&mut selected, Some(action)),
                Continue(())
            );
        }
        let Break(Some(choice)) = provider_selection(&mut selected, Some(Action::SelectorOpen))
        else {
            panic!("Selected provider must open");
        };
        assert_eq!(choice, miruro);
        let mut options = Options::parse_from(["tubular", "initial query"]);
        options.miruro = choice;
        assert_eq!(options.query.as_deref(), Some("initial query"));
        assert_eq!(options.miruro, miruro);
        if !miruro {
            let app = App::new(options, PathBuf::new(), config::Config::default());
            assert_eq!(app.views[0].query, "initial query");
            assert_eq!(app.views[app.view_index].source, ViewSource::Search);
        }
    }
    for action in [Action::SelectorClose, Action::Quit, Action::Interrupt] {
        assert_eq!(provider_selection(&mut selected, Some(action)), Break(None));
    }
    assert_eq!(provider_selection(&mut selected, None), Continue(()));
}

fn app(args: &[&str]) -> App {
    App::new(
        Options::parse_from(args),
        PathBuf::new(),
        config::Config::default(),
    )
}

#[test]
fn playback_checks_follow_ids_across_feed_sort_and_clear_on_replacement() {
    let mut app = app(&["tubular"]);
    app.view_index = 1;
    app.feed_channels = vec!["https://www.youtube.com/@fixture".into()];
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Old","timestamp":100},{"id":"rQ_J9WH6CGk","title":"New","timestamp":200}]}"#,
        true,
    );
    let view = &mut app.views[1];
    view.selection.select(Some(1));
    view.toggle_checked();
    view.selection.select(Some(0));
    view.toggle_checked();
    assert_eq!(
        view.playback_videos()
            .iter()
            .map(|video| video.id.as_str())
            .collect::<Vec<_>>(),
        ["rQ_J9WH6CGk", "jNQXAC9IVRw"],
    );
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"l-GaaivVJCE","title":"Newest","timestamp":300}]}"#,
        false,
    );
    let view = &mut app.views[1];
    assert_eq!(view.selection.selected(), Some(1));
    assert_eq!(
        view.playback_videos()
            .iter()
            .map(|video| video.id.as_str())
            .collect::<Vec<_>>(),
        ["rQ_J9WH6CGk", "jNQXAC9IVRw"],
    );
    view.reset();
    assert!(view.checked.is_empty());
    // Old rows remain during refresh, but checks made there cannot leak into replacement data.
    view.toggle_checked();
    assert!(!view.checked.is_empty());
    view.accept_page(
        youtube::search_results(r#"{"entries":[{"id":"rQ_J9WH6CGk","title":"Replacement"}]}"#)
            .unwrap(),
        false,
    )
    .unwrap();
    assert!(view.checked.is_empty());
    assert_eq!(view.playback_videos()[0].title, "Replacement");
}

#[test]
fn playback_checks_are_local_to_views_and_previews_and_pruned_with_collections() {
    let mut app = app(&["tubular"]);
    let videos = youtube::search_results(
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@creator"}]}"#,
    ).unwrap().videos;
    app.views[0].videos = videos.clone();
    app.views[0].selection.select(Some(0));
    app.views[0].loaded = true;
    app.views[1].loaded = true;
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    app.switch_view(1);
    assert!(app.views[1].checked.is_empty());
    app.switch_view(0);
    assert!(app.views[0].checked.contains(&videos[0].id));
    app.mode = Mode::Insert;
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    assert_eq!(app.views[0].checked.len(), 1);
    app.mode = Mode::Normal;
    for preview in [
        None,
        Some(PreviewMode::Info),
        Some(PreviewMode::Description),
    ] {
        app.preview = preview;
        app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL));
        assert!(app.views[0].checked.is_empty());
        app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
        assert!(app.views[0].checked.contains(&videos[0].id));
    }
    app.preview = None;
    for video in &videos {
        app.video_state
            .save(CollectionKind::WatchLater, video)
            .unwrap();
    }
    app.browse_collection(CollectionKind::WatchLater);
    let index = app.view_index;
    app.views[index].selection.select(Some(0));
    app.views[index].toggle_checked();
    app.views[index].selection.select(Some(1));
    app.views[index].toggle_checked();
    let removed = app.views[index].videos[1].id.clone();
    app.remove_collection();
    assert!(!app.views[index].checked.contains(&removed));
    assert_eq!(app.views[index].checked.len(), 1);
    assert_eq!(app.views[index].playback_videos().len(), 1);
    app.views[index].watch_filter = WatchFilter::Watched;
    app.rebuild_collections();
    assert!(app.views[index].videos.is_empty());
    assert!(app.views[index].checked.is_empty());
    app.views[index].watch_filter = WatchFilter::All;
    app.rebuild_collections();
    app.views[index].toggle_checked();
    // Refresh is a replacement even for locally rebuilt collection views.
    app.load_view();
    assert!(app.views[index].checked.is_empty());
    assert_eq!(app.views[0].checked.len(), 1);
    // An empty category exercises query replacement entirely offline.
    app.config.categories.insert("Empty".into(), Vec::new());
    let mut view = View::new("Empty".into(), ViewSource::Category("Empty".into()));
    view.videos = videos;
    view.selection.select(Some(0));
    view.toggle_checked();
    view.query = "replacement query".into();
    app.views.push(view);
    app.view_index = app.views.len() - 1;
    app.search();
    assert!(app.views[app.view_index].checked.is_empty());
    assert!(app.job.is_none());
}

#[test]
fn playback_checks_render_independently_and_live_hints_use_configured_keys() {
    let mut app = app(&["tubular"]);
    let document = "[keys.video.select]\ntoggle = 'f20'\nclear = 'f21'\n"
        .parse::<toml_edit::DocumentMut>()
        .unwrap();
    app.config.keys = keys::Bindings::from_toml(document.get("keys")).unwrap();
    app.key_hints = KeyHints::new(&app.config.keys);
    for context in [
        Context::Normal,
        Context::Info,
        Context::Description,
        Context::CollectionNormal,
        Context::CollectionInfo,
        Context::CollectionDescription,
    ] {
        for key in ["F20", "F21"] {
            assert!(app.key_hints.footer(context).contains(key));
            assert!(app.key_hints.preview.iter().all(|hint| hint.contains(key)));
            assert!(app.config.keys.help_text().to_string().contains(key));
        }
    }
    app.views[0].videos = youtube::search_results(
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Checked"},{"id":"rQ_J9WH6CGk","title":"Unchecked"}]}"#,
    ).unwrap().videos;
    for (index, video) in app.views[0].videos.iter_mut().enumerate() {
        video.id = format!("offline:{index}");
    }
    app.views[0].selection.select(Some(0));
    app.key(KeyEvent::new(KeyCode::F(20), KeyModifiers::NONE));
    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 24)).unwrap();
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let rendered: String = terminal
        .backend()
        .buffer()
        .content
        .iter()
        .map(|cell| cell.symbol())
        .collect();
    assert!(rendered.contains("1 checked"));
    app.key(KeyEvent::new(KeyCode::F(21), KeyModifiers::NONE));
    assert!(app.views[0].checked.is_empty());
}

#[test]
fn playback_checks_survive_spawn_failure_clear_after_spawn_and_fall_back_to_hover() {
    let mut app = app(&["tubular"]);
    app.views[0].videos = youtube::search_results(
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#,
    ).unwrap().videos;
    app.views[0].selection.select(Some(1));
    assert_eq!(app.views[0].playback_videos()[0].id, "rQ_J9WH6CGk");
    app.views[0].toggle_checked();
    app.views[0].selection.select(Some(0));
    app.options.player = "/nonexistent/tubular-test-player".into();
    app.play();
    assert!(app.player_launch.is_none());
    assert!(app.views[0].checked.contains("rQ_J9WH6CGk"));
    assert_eq!(app.views[0].playback_videos()[0].id, "rQ_J9WH6CGk");
    app.options.player = "/usr/bin/true".into();
    app.play();
    assert!(app.player_launch.is_some());
    assert!(app.views[0].checked.is_empty());
    assert_eq!(app.views[0].playback_videos()[0].id, "jNQXAC9IVRw");
    app.player_launch = None;
    app.play();
    assert!(app.player_launch.is_some());
}

#[test]
fn title_viewport_tracks_selected_two_line_rows_and_resize_without_changing_identity() {
    let mut app = app(&["tubular"]);
    let template =
        youtube::search_results(r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Listing title"}]}"#)
            .unwrap()
            .videos
            .remove(0);
    app.views[0].videos = (0..12)
        .map(|index| {
            let mut video = template.clone();
            // Non-YouTube IDs keep this rendering check entirely offline.
            video.id = format!("offline:{index}");
            video.title = format!("Row {index:02}");
            video
        })
        .collect();
    app.views[0].selection.select(Some(9));
    let now = Instant::now();
    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(80, 24)).unwrap();
    terminal
        .draw(|frame| app.draw_at(frame, Duration::ZERO, now))
        .unwrap();
    assert_eq!(app.views[0].selection.offset(), 3);
    assert_eq!(
        app.views[0].videos[app.views[0].selection.selected().unwrap()].id,
        "offline:9"
    );
    assert!(!app.titles.active());

    terminal.backend_mut().resize(80, 17);
    terminal
        .draw(|frame| {
            app.draw_at(
                frame,
                Duration::from_millis(20),
                now + Duration::from_millis(20),
            )
        })
        .unwrap();
    assert_eq!(app.views[0].selection.offset(), 7);
    assert_eq!(
        app.views[0].videos[app.views[0].selection.selected().unwrap()].id,
        "offline:9"
    );
    let rendered: String = terminal
        .backend()
        .buffer()
        .content
        .iter()
        .map(|cell| cell.symbol())
        .collect();
    assert!(rendered.contains("Row 09"));

    app.views[0].selection.select(Some(0));
    terminal
        .draw(|frame| {
            app.draw_at(
                frame,
                Duration::from_millis(40),
                now + Duration::from_millis(40),
            )
        })
        .unwrap();
    assert_eq!(app.views[0].selection.offset(), 0);
    assert_eq!(
        app.views[0].videos[app.views[0].selection.selected().unwrap()].id,
        "offline:0"
    );
}

#[test]
fn youtube_collections_isolate_mixed_provider_rows_and_removal_ids() {
    let mut app = app(&["tubular"]);
    let youtube = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"YouTube","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@creator"}]}"#,
        ).unwrap().videos.remove(0);
    let mut miruro = youtube.clone();
    miruro.id = "miruro:catalog_ID:1".into();
    miruro.title = "Miruro episode".into();
    miruro.channel = Some("Miruro".into());
    miruro.channel_id = None;
    miruro.uploader_id = None;
    for kind in [
        CollectionKind::WatchLater,
        CollectionKind::Saved,
        CollectionKind::Watching,
    ] {
        app.video_state.save(kind, &youtube).unwrap();
        app.video_state.save(kind, &miruro).unwrap();
        app.browse_collection(kind);
        assert_eq!(app.views[app.view_index].videos.len(), 1);
        assert_eq!(app.views[app.view_index].videos[0].id, youtube.id);
        assert_eq!(app.views[app.view_index].selection.selected(), Some(0));
        app.remove_collection_bulk();
        assert_eq!(
            app.collection_removal.as_ref().unwrap().ids.as_slice(),
            std::slice::from_ref(&youtube.id)
        );
        app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
        assert!(!app.video_state.contains(kind, &youtube.id));
        assert!(app.video_state.contains(kind, &miruro.id));
        assert!(app.views[app.view_index].videos.is_empty());
        app.video_state.save(kind, &youtube).unwrap();
        app.rebuild_collections();
        app.remove_collection();
        assert!(!app.video_state.contains(kind, &youtube.id));
        assert!(app.video_state.contains(kind, &miruro.id));
    }
}

#[test]
fn watching_direct_bindings_respect_modals_and_offline_history() {
    for (label, overrides, binding) in [
        ("default", "", Some(KeyCode::Char('C'))),
        (
            "remapped",
            "[keys]\nview.watching.browse = 'f8'\n",
            Some(KeyCode::F(8)),
        ),
        ("disabled", "[keys]\nview.watching.browse = []\n", None),
    ] {
        let mut app = rename_app(&format!("watching-{label}"), overrides);
        for view in &mut app.views {
            view.loaded = true;
        }
        app.mode = Mode::Insert;
        rename_press(&mut app, KeyCode::Char('C'));
        assert_eq!(app.views[0].query, "C");
        rename_press(&mut app, KeyCode::Esc);
        app.open_browser(BrowserKind::Categories);
        rename_press(&mut app, binding.unwrap_or(KeyCode::Char('C')));
        assert!(app.browser.is_some());
        assert_eq!(app.view_index, 0);
        rename_press(&mut app, KeyCode::Esc);
        rename_press(&mut app, KeyCode::Char('?'));
        rename_press(&mut app, binding.unwrap_or(KeyCode::Char('C')));
        assert!(app.help_popup.is_some());
        assert_eq!(app.view_index, 0);
        rename_press(&mut app, KeyCode::Esc);
        if binding != Some(KeyCode::Char('C')) {
            rename_press(&mut app, KeyCode::Char('C'));
            assert_eq!(app.view_index, 0);
        }
        if let Some(binding) = binding {
            rename_press(&mut app, binding);
            let index = app.view_index;
            assert_eq!(app.views[index].source, ViewSource::Watching);
            assert_eq!(app.temporary_view, Some(ViewSource::Watching));
            assert_eq!(app.key_context(), Context::CollectionNormal);
            assert!(app.browser.is_none());
            app.load_page();
            let config = std::mem::take(&mut app.config);
            app.apply_config(config);
            assert_eq!(app.views[app.view_index].source, ViewSource::Watching);
            rename_press(&mut app, KeyCode::Char('/'));
            rename_press(&mut app, KeyCode::Char('-'));
            assert_eq!(app.view_index, index);
            rename_press(&mut app, KeyCode::Char('+'));
            assert_eq!(app.view_index, 0);
            rename_press(&mut app, binding);
            assert_eq!(app.view_index, index);
            assert!(app.job.is_none());
            assert!(!app.views[index].has_more);
        }
        std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
    }
}

#[test]
fn watching_progress_preserves_selection_and_removal_is_collection_only() {
    use std::io::Write;
    fn report(path: &std::path::Path, id: &str, position: u32) {
        let mut options = std::fs::OpenOptions::new();
        options.append(true).create(true);
        #[cfg(unix)]
        {
            use std::os::unix::fs::OpenOptionsExt;
            options.mode(0o600);
        }
        writeln!(
                options.open(path).unwrap(),
                "{{\"version\":1,\"event\":\"progress\",\"media_url\":\"https://www.youtube.com/watch?v={id}\",\"position_seconds\":{position},\"duration_seconds\":100,\"completion_eligible\":true}}"
            ).unwrap();
    }
    let mut app = rename_app("watching-progress", "");
    for view in &mut app.views {
        view.loaded = true;
    }
    let videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"},{"id":"l-GaaivVJCE","title":"Third","uploader_id":"@third"}]}"#,
        ).unwrap().videos;
    let reports: Vec<_> = videos
        .iter()
        .map(|video| {
            app.video_state.save(CollectionKind::Saved, video).unwrap();
            app.video_state
                .save(CollectionKind::WatchLater, video)
                .unwrap();
            let path = app.video_state.progress_file(video).unwrap();
            video_state::register_identity(&path, &video.id).unwrap();
            report(&path, &video.id, 1);
            path
        })
        .collect();
    app.update();
    rename_press(&mut app, KeyCode::Char('C'));
    assert_eq!(app.views[app.view_index].videos.len(), 3);
    let second = app.views[app.view_index]
        .videos
        .iter()
        .position(|video| video.id == videos[1].id)
        .unwrap();
    app.views[app.view_index].selection.select(Some(second));
    app.preview = Some(PreviewMode::Description);
    report(&reports[0], &videos[0].id, 95);
    app.update();
    let view = &app.views[app.view_index];
    assert_eq!(view.videos.len(), 2);
    assert_eq!(
        view.videos[view.selection.selected().unwrap()].id,
        videos[1].id
    );
    assert_eq!(app.preview, Some(PreviewMode::Description));
    report(&reports[1], &videos[1].id, 95);
    app.update();
    assert_eq!(app.views[app.view_index].videos.len(), 1);
    assert!(app.preview.is_none());
    assert!(app.status.contains("1 videos"));
    rename_press(&mut app, KeyCode::Char('x'));
    assert!(app.video_state.videos(CollectionKind::Watching).is_empty());
    report(&reports[2], &videos[2].id, 2);
    app.update();
    assert!(app.video_state.videos(CollectionKind::Watching).is_empty());
    let fresh = app.video_state.progress_file(&videos[2]).unwrap();
    video_state::register_identity(&fresh, &videos[2].id).unwrap();
    report(&fresh, &videos[2].id, 1);
    app.update();
    rename_press(&mut app, KeyCode::Char('X'));
    assert_eq!(
        app.collection_removal.as_ref().unwrap().ids,
        [videos[2].id.clone()]
    );
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.collection_removal.is_some());
    rename_press(&mut app, KeyCode::Char('y'));
    assert!(app.video_state.videos(CollectionKind::Watching).is_empty());
    assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 3);
    assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 3);
    assert!(app.video_state.is_watched(&videos[0].id));
    assert!(app.video_state.is_watched(&videos[1].id));
    assert!(!app.video_state.is_watched(&videos[2].id));
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn direct_jumps_reuse_cached_views_and_navigation_with_configured_bindings() {
    for (document, search, feed) in [
        ("", KeyCode::Char('/'), KeyCode::Char('F')),
        (
            "[keys]\nview.search = 'f6'\nview.feed = 'f7'\n",
            KeyCode::F(6),
            KeyCode::F(7),
        ),
    ] {
        let mut app = app(&["tubular", "global draft"]);
        if !document.is_empty() {
            let document = document.parse::<toml_edit::DocumentMut>().unwrap();
            app.config.keys = keys::Bindings::from_toml(document.get("keys")).unwrap();
        }
        let videos = youtube::search_results(
                r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"l-GaaivVJCE","title":"Second"}]}"#
            ).unwrap().videos;
        app.views.push(View::new(
            "Temporary".into(),
            ViewSource::Channel("creator".into()),
        ));
        for view in &mut app.views {
            view.loaded = true;
            view.videos = videos.clone();
            view.selection.select(Some(1));
            view.next_start = 61;
        }
        app.view_index = 2;
        app.preview = Some(PreviewMode::Description);
        rename_press(&mut app, feed);
        assert_eq!(app.view_index, 1);
        assert_eq!(app.mode, Mode::Normal);
        assert!(app.preview.is_none());
        rename_press(&mut app, search);
        assert_eq!(app.view_index, 0);
        assert_eq!(app.views[0].query, "global draft");
        rename_press(&mut app, KeyCode::Char('-'));
        assert_eq!(app.view_index, 1);
        rename_press(&mut app, KeyCode::Char('-'));
        assert_eq!(app.view_index, 2);
        rename_press(&mut app, KeyCode::Char('+'));
        assert_eq!(app.view_index, 1);
        rename_press(&mut app, KeyCode::Char('+'));
        assert_eq!(app.view_index, 0);
        for view in &app.views {
            assert_eq!(view.videos[1].id, "l-GaaivVJCE");
            assert_eq!(view.selection.selected(), Some(1));
            assert_eq!(view.next_start, 61);
        }
        assert!(app.job.is_none());
        for source in [
            ViewSource::Channel("creator".into()),
            ViewSource::SavedVideos(None),
            ViewSource::WatchLater(None),
            ViewSource::Watching,
        ] {
            app.views[2].source = source;
            for preview in [
                None,
                Some(PreviewMode::Info),
                Some(PreviewMode::Description),
            ] {
                app.view_index = 2;
                app.preview = preview;
                rename_press(&mut app, search);
                assert_eq!(app.view_index, 0);
                assert_eq!(app.mode, Mode::Normal);
                assert!(app.preview.is_none());
                rename_press(&mut app, feed);
                assert_eq!(app.view_index, 1);
            }
        }
        app.view_index = 0;
        if !document.is_empty() {
            app.view_index = 2;
            rename_press(&mut app, KeyCode::Char('/'));
            rename_press(&mut app, KeyCode::Char('F'));
            assert_eq!(app.view_index, 2, "remapping replaces both defaults");
        }
        let document = "[keys]\nview.search = []\nview.feed = []\n"
            .parse::<toml_edit::DocumentMut>()
            .unwrap();
        app.config.keys = keys::Bindings::from_toml(document.get("keys")).unwrap();
        app.view_index = 2;
        rename_press(&mut app, search);
        rename_press(&mut app, feed);
        rename_press(&mut app, KeyCode::Char('/'));
        rename_press(&mut app, KeyCode::Char('F'));
        assert_eq!(app.view_index, 2);
        assert!(app.job.is_none());
    }
}

#[test]
fn direct_jump_keys_remain_literal_or_inert_in_modals() {
    let mut app = app(&["tubular"]);
    app.views[1].loaded = true;
    app.view_index = 1;
    rename_press(&mut app, KeyCode::Char('i'));
    rename_press(&mut app, KeyCode::Char('/'));
    rename_press(&mut app, KeyCode::Char('F'));
    assert_eq!(app.views[0].query, "/F");
    assert_eq!(app.view_index, 1);
    rename_press(&mut app, KeyCode::Esc);
    for kind in [BrowserKind::Categories, BrowserKind::Channels] {
        app.open_browser(kind);
        rename_press(&mut app, KeyCode::Char('/'));
        rename_press(&mut app, KeyCode::Char('F'));
        assert_eq!(app.view_index, 1);
        rename_press(&mut app, KeyCode::Char('i'));
        rename_press(&mut app, KeyCode::Char('/'));
        rename_press(&mut app, KeyCode::Char('F'));
        assert_eq!(app.browser.as_ref().unwrap().query, "/F");
        rename_press(&mut app, KeyCode::Esc);
        rename_press(&mut app, KeyCode::Esc);
    }
    app.category_dialog = Some(CategoryDialog::new(
        CategoryTarget::Channel {
            handle: "@creator".into(),
            channel: "creator".into(),
        },
        "Creator".into(),
        Default::default(),
    ));
    rename_press(&mut app, KeyCode::Char('/'));
    rename_press(&mut app, KeyCode::Char('F'));
    assert_eq!(app.view_index, 1);
    rename_press(&mut app, KeyCode::Char('i'));
    rename_press(&mut app, KeyCode::Char('/'));
    rename_press(&mut app, KeyCode::Char('F'));
    assert_eq!(app.category_dialog.as_ref().unwrap().query, "/F");
    rename_press(&mut app, KeyCode::Esc);
    rename_press(&mut app, KeyCode::Char('n'));
    rename_press(&mut app, KeyCode::Char('/'));
    rename_press(&mut app, KeyCode::Char('F'));
    assert_eq!(
        app.category_dialog.as_ref().unwrap().name.as_deref(),
        Some("/F")
    );
    rename_press(&mut app, KeyCode::Esc);
    rename_press(&mut app, KeyCode::Esc);
    rename_press(&mut app, KeyCode::Char('?'));
    rename_press(&mut app, KeyCode::Char('/'));
    rename_press(&mut app, KeyCode::Char('F'));
    assert!(app.help_popup.is_some());
    assert_eq!(app.view_index, 1);
    rename_press(&mut app, KeyCode::Esc);
    app.collection_removal = Some(CollectionRemoval {
        kind: CollectionKind::Saved,
        ids: Vec::new(),
        category: None,
        filter: None,
        text: "Confirm removal".into(),
    });
    rename_press(&mut app, KeyCode::Char('/'));
    rename_press(&mut app, KeyCode::Char('F'));
    assert!(app.collection_removal.is_some());
    assert_eq!(app.view_index, 1);
    rename_press(&mut app, KeyCode::Esc);
    let mut group = View::new("Combined".into(), ViewSource::CategoryGroup(vec![]));
    group.loaded = true;
    app.views.push(group);
    let group_index = app.views.len() - 1;
    app.view_index = group_index;
    rename_press(&mut app, KeyCode::Char('P'));
    rename_press(&mut app, KeyCode::Char('/'));
    rename_press(&mut app, KeyCode::Char('F'));
    assert_eq!(app.category_name_input.as_ref().unwrap().name, "/F");
    assert_eq!(app.view_index, group_index);
}

#[test]
fn category_and_group_queries_own_drafts_pages_and_errors_without_touching_search() {
    for source in [
        ViewSource::Category("Alpha".into()),
        ViewSource::CategoryGroup(vec!["Alpha".into(), "Beta".into()]),
    ] {
        let mut app = app(&["tubular", "global draft"]);
        app.views[0].submitted_query = "global submitted".into();
        app.views[0].loaded = true;
        app.views[0].next_start = 61;
        app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"l-GaaivVJCE","title":"Global cached result"}]}"#,
        )
        .unwrap()
        .videos;
        app.views[0].selection.select(Some(0));
        app.apply_config(config::Config {
            categories: [("Alpha".into(), vec![]), ("Beta".into(), vec![])].into(),
            ..Default::default()
        });
        app.browse_view("Scoped creators".into(), source.clone());
        let index = app.view_index;
        let output = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached"}]}"#;
        app.views[index].feed_cursor.plan(1).unwrap();
        app.views[index]
            .accept_page(feed_fixture(output).unwrap(), true)
            .unwrap();
        rename_press(&mut app, KeyCode::Char('i'));
        app.paste("  robotics 日本語  ");
        rename_press(&mut app, KeyCode::Enter);
        assert_eq!(app.views[index].submitted_query, "robotics 日本語");
        assert_eq!(app.view_index, index);
        assert_eq!(app.mode, Mode::Normal);
        assert!(app.views[index].videos.is_empty());
        assert_eq!(app.views[index].selection.selected(), None);
        assert_eq!(app.views[index].next_start, 1);
        assert_eq!(app.views[index].feed_cursor.plan(1).unwrap()[0].start, 1);
        app.finish_page(Err("Scoped request failed".into()));
        rename_press(&mut app, KeyCode::Char('i'));
        rename_press(&mut app, KeyCode::Enter);
        assert_eq!(app.view_index, index);
        assert!(app.views[index].page_error.is_some());
        assert!(
            app.job.is_none(),
            "repeated failed query must not retry globally"
        );
        app.views[index]
            .accept_page(feed_fixture(output).unwrap(), true)
            .unwrap();
        let next_start = app.views[index].next_start;
        rename_press(&mut app, KeyCode::Char('i'));
        rename_press(&mut app, KeyCode::Enter);
        assert_eq!(app.views[index].videos[0].id, "jNQXAC9IVRw");
        assert_eq!(app.views[index].next_start, next_start);
        rename_press(&mut app, KeyCode::Char('i'));
        app.paste(" draft");
        rename_press(&mut app, KeyCode::Esc);
        assert_eq!(app.views[index].submitted_query, "robotics 日本語");
        assert!(app.views[index].query.ends_with(" draft"));
        let mut terminal =
            ratatui::Terminal::new(ratatui::backend::TestBackend::new(120, 24)).unwrap();
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        let buffer = terminal.backend().buffer();
        let text: String = buffer.content.iter().map(|cell| cell.symbol()).collect();
        assert!(text.contains("Category search"));
        assert!(!text.contains("YouTube search"));
        rename_press(&mut app, KeyCode::Char('/'));
        rename_press(&mut app, KeyCode::Char('-'));
        assert_eq!(app.views[app.view_index].source, source);
        assert!(app.views[index].query.ends_with(" draft"));
        rename_press(&mut app, KeyCode::Char('i'));
        app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
        rename_press(&mut app, KeyCode::Enter);
        assert_eq!(app.view_index, index);
        assert!(app.views[index].submitted_query.is_empty());
        assert!(app.views[index].videos.is_empty());
        assert_eq!(app.views[index].next_start, 1);
        assert!(app.job.is_none());
        assert_eq!(app.views[0].query, "global draft");
        assert_eq!(app.views[0].submitted_query, "global submitted");
        assert_eq!(app.views[0].next_start, 61);
        assert_eq!(app.views[0].videos[0].id, "l-GaaivVJCE");
        assert_eq!(app.views[0].selection.selected(), Some(0));
    }
}

#[test]
fn other_sources_submit_to_general_search_and_blank_global_query_is_a_noop() {
    let mut app = app(&["tubular", "  cached global  "]);
    app.views[0].submitted_query = "cached global".into();
    app.views[0].loaded = true;
    app.views[0].next_start = 61;
    for source in [
        ViewSource::Feed,
        ViewSource::Channel("creator".into()),
        ViewSource::WatchLater(None),
        ViewSource::SavedVideos(None),
    ] {
        let mut view = View::new("Other".into(), source);
        view.loaded = true;
        app.views.push(view);
        app.view_index = app.views.len() - 1;
        rename_press(&mut app, KeyCode::Char('i'));
        rename_press(&mut app, KeyCode::Enter);
        assert_eq!(app.view_index, 0);
        assert_eq!(app.views[0].next_start, 61);
        assert!(app.job.is_none());
    }
    rename_press(&mut app, KeyCode::Char('i'));
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.views[0].query.is_empty());
    assert_eq!(app.views[0].submitted_query, "cached global");
    assert_eq!(app.views[0].next_start, 61);
    assert!(app.job.is_none());
}

// Unrelated UI fixtures still parse real feed envelopes with a shared-budget plan.
fn feed_fixture(output: &str) -> Result<Page, String> {
    let channels = serde_json::Deserializer::from_str(output)
        .into_iter::<serde_json::Value>()
        .count();
    let requests = youtube::FeedCursor::default().plan(channels).unwrap();
    youtube::feed_results(output, &requests)
}

fn finish_feed_fixture(app: &mut App, output: &str, full: bool) {
    let view = &mut app.views[app.view_index];
    let channels = view
        .source
        .channels(&app.config, &app.feed_channels, &view.group_channels)
        .len();
    view.feed_requests = view.feed_cursor.plan(channels).unwrap();
    let mut envelopes: Vec<_> = serde_json::Deserializer::from_str(output)
        .into_iter::<serde_json::Value>()
        .map(Result::unwrap)
        .collect();
    assert!(envelopes.len() <= view.feed_requests.len());
    envelopes.resize_with(
        view.feed_requests.len(),
        || serde_json::json!({"entries":[]}),
    );
    if full {
        for (envelope, request) in envelopes.iter_mut().zip(&view.feed_requests) {
            let entries = envelope["entries"].as_array_mut().unwrap();
            assert!(entries.len() <= request.count);
            entries.resize(request.count, serde_json::Value::Null);
        }
    }
    let output = envelopes
        .iter()
        .map(ToString::to_string)
        .collect::<Vec<_>>()
        .join("\n");
    app.finish_page(Ok(output));
}

fn choose_combined(app: &mut App, key: KeyEvent) {
    app.key(key);
    while app
        .browser
        .as_ref()
        .unwrap()
        .selection
        .selected()
        .unwrap_or(0)
        != 0
    {
        app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
    }
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
}

fn rename_app(label: &str, keys: &str) -> App {
    let root = std::env::temp_dir().join(format!("tubular-rename-{label}-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&root);
    std::fs::create_dir_all(&root).unwrap();
    let path = root.join("config.toml");
    std::fs::write(&path, format!(
            "[settings]\npinned_categories = ['Alpha']\n[channels]\n'@Alpha' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n[categories]\nAlpha = ['@Alpha']\nOther = []\n{keys}"
        )).unwrap();
    App::new(
        Options::parse_from(["tubular"]),
        path.clone(),
        config::load(&path).unwrap(),
    )
}

fn rename_press(app: &mut App, code: KeyCode) {
    app.key(KeyEvent::new(code, KeyModifiers::NONE));
}

fn rename_to(app: &mut App, name: &str) {
    app.key(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT));
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
    app.paste(name);
    rename_press(app, KeyCode::Enter);
    assert!(app.category_name_input.is_none());
}

fn group_app(label: &str, keys: &str) -> App {
    let mut app = rename_app(&format!("group-{label}"), keys);
    let config_text = |members: &str| {
        format!(
            "# keep this comment\n[settings]\npinned_categories = ['Alpha']\n[channels]\n'@Alpha' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n'@Alias' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n'@Beta' = 'UC4QobU6STFB0P71PMvOGN5A'\n[categories]\n{members}\n{keys}"
        )
    };
    std::fs::write(
        &app.config_path,
        config_text("Alpha = []\nBeta = []\nGamma = []"),
    )
    .unwrap();
    app.apply_config(config::load(&app.config_path).unwrap());
    rename_press(&mut app, KeyCode::Char('c'));
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Down);
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Enter);
    std::fs::write(
        &app.config_path,
        config_text("Alpha = ['@Alpha']\nBeta = ['@Alias', '@Beta']\nGamma = []"),
    )
    .unwrap();
    app.apply_config(config::load(&app.config_path).unwrap());
    app.views[app.view_index].loaded = true;
    app
}

#[test]
fn category_checks_survive_filters_and_enter_uses_zero_one_or_many_choices() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        categories: [
            ("Alpha".into(), vec![]),
            ("Beta".into(), vec![]),
            ("Gamma".into(), vec![]),
        ]
        .into(),
        ..Default::default()
    });
    rename_press(&mut app, KeyCode::Char('c'));
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Char('i'));
    app.paste("beta");
    rename_press(&mut app, KeyCode::Esc);
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Char('i'));
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
    app.paste("no match");
    assert!(app.browser.as_ref().unwrap().matches.is_empty());
    rename_press(&mut app, KeyCode::Enter);
    let combined = app.views[app.view_index].source.clone();
    assert_eq!(
        combined,
        ViewSource::CategoryGroup(vec!["Alpha".into(), "Beta".into()])
    );
    rename_press(&mut app, KeyCode::Char('c'));
    assert_eq!(
        app.browser
            .as_ref()
            .unwrap()
            .checked
            .iter()
            .map(String::as_str)
            .collect::<Vec<_>>(),
        ["Alpha", "Beta"]
    );
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Enter);
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Beta".into())
    );

    rename_press(&mut app, KeyCode::Char('c'));
    rename_press(&mut app, KeyCode::Down);
    rename_press(&mut app, KeyCode::Enter);
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Gamma".into())
    );
    let before = app.views[app.view_index].source.clone();
    let history = app.view_history.clone();
    rename_press(&mut app, KeyCode::Char('c'));
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Esc);
    assert_eq!(app.views[app.view_index].source, before);
    assert_eq!(app.view_history, history);
    rename_press(&mut app, KeyCode::Char('c'));
    assert!(app.browser.as_ref().unwrap().checked.is_empty());
    rename_press(&mut app, KeyCode::Char('i'));
    app.paste("no match");
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.browser.is_some());
    assert_eq!(app.views[app.view_index].source, before);
}

#[test]
fn combined_feed_deduplicates_overlapping_rows_and_restores_pages_through_history() {
    let mut app = group_app("pages", "");
    let group = app.views[app.view_index].source.clone();
    assert_eq!(
        app.views[app.view_index].group_channels,
        [
            "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A",
            "https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA",
        ]
    );
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Shared","timestamp":300},{"id":"l-GaaivVJCE","title":"Old","timestamp":100}]}
{"entries":[{"id":"jNQXAC9IVRw","title":"Shared again","timestamp":300},{"id":"rQ_J9WH6CGk","title":"Middle","timestamp":200}]}"#,
        true,
    );
    assert_eq!(
        app.views[app.view_index]
            .videos
            .iter()
            .map(|video| video.id.as_str())
            .collect::<Vec<_>>(),
        ["jNQXAC9IVRw", "rQ_J9WH6CGk", "l-GaaivVJCE"]
    );
    rename_press(&mut app, KeyCode::Down);
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"l-GaaivVJCE","title":"Duplicate","timestamp":100},{"id":"SLV9AJxnb1U","title":"Last","timestamp":50}]}"#,
        false,
    );
    let next_start = app.views[app.view_index].next_start;
    let names = vec!["Alpha".into(), "Gamma".into()];
    let mut replacement = View::new(group_name(&names), ViewSource::CategoryGroup(names));
    replacement.group_channels = app.config.categories["Alpha"].clone();
    replacement.loaded = true;
    app.views.push(replacement);
    rename_press(&mut app, KeyCode::Char('c'));
    rename_press(&mut app, KeyCode::Down);
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Down);
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Enter);
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::CategoryGroup(vec!["Alpha".into(), "Gamma".into()])
    );
    assert_eq!(
        app.visible_views()
            .filter(|(_, view)| matches!(view.source, ViewSource::CategoryGroup(_)))
            .count(),
        1
    );
    rename_press(&mut app, KeyCode::Char('-'));
    let view = &app.views[app.view_index];
    assert_eq!(view.source, group);
    assert_eq!(view.videos.len(), 4);
    assert_eq!(view.selection.selected(), Some(1));
    assert_eq!(view.next_start, next_start);
    assert!(app.job.is_none());
    rename_press(&mut app, KeyCode::Char('+'));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::CategoryGroup(vec!["Alpha".into(), "Gamma".into()])
    );
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn combined_cache_resets_only_for_changed_resolved_union_and_drops_deleted_members() {
    let mut app = group_app("config", "");
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
        false,
    );
    let group = app.views[app.view_index].source.clone();
    let original = std::fs::read_to_string(&app.config_path).unwrap();
    std::fs::write(
        &app.config_path,
        original
            .replace("Alpha = ['@Alpha']", "Alpha = ['@Beta']")
            .replace("Beta = ['@Alias', '@Beta']", "Beta = ['@Alpha']"),
    )
    .unwrap();
    app.apply_config(config::load(&app.config_path).unwrap());
    let view = &app.views[app.view_index];
    assert_eq!(view.source, group);
    assert_eq!(view.videos.len(), 1);
    assert_eq!(view.next_start, PAGE_SIZE + 1);
    std::fs::write(
        &app.config_path,
        original.replace("Beta = ['@Alias', '@Beta']", "Beta = ['@Alias']"),
    )
    .unwrap();
    app.apply_config(config::load(&app.config_path).unwrap());
    let view = &app.views[app.view_index];
    assert_eq!(view.source, group);
    assert_eq!(view.videos[0].title, "Cached");
    assert!(!view.loaded);
    assert_eq!(view.next_start, 1);
    assert_eq!(view.group_channels.len(), 1);
    app.views[app.view_index].loaded = true;
    app.views[0].loaded = true;
    app.switch_view(0);
    std::fs::write(
        &app.config_path,
        original.replace("Beta = ['@Alias', '@Beta']\n", ""),
    )
    .unwrap();
    app.apply_config(config::load(&app.config_path).unwrap());
    rename_press(&mut app, KeyCode::Char('-'));
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    assert!(!app.views.iter().any(|view| view.source == group));
    assert!(app.temporary_view.is_none());
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn checked_category_rename_preserves_canonical_group_pin_selection_and_history() {
    let mut app = group_app("rename", "");
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
        false,
    );
    app.views[app.view_index].query = "draft astronomy".into();
    app.views[app.view_index].submitted_query = "astronomy".into();
    let old = app.views[app.view_index].source.clone();
    app.view_history.push(old.clone());
    app.forward_history.push(old);
    rename_press(&mut app, KeyCode::Char('c'));
    rename_press(&mut app, KeyCode::Char('i'));
    app.paste("Alpha");
    rename_press(&mut app, KeyCode::Esc);
    let original = std::fs::read_to_string(&app.config_path).unwrap();
    std::fs::write(&app.config_path, format!("{original}Extra = []\n")).unwrap();
    rename_press(&mut app, KeyCode::Char('p'));
    assert_eq!(app.browser.as_ref().unwrap().checked.len(), 2);
    assert!(app.browser.as_ref().unwrap().checked.contains("Alpha"));
    assert!(!app.config.pinned_categories.contains(&"Alpha".into()));
    rename_press(&mut app, KeyCode::Char('p'));
    rename_to(&mut app, "Zeta");
    let renamed = ViewSource::CategoryGroup(vec!["Beta".into(), "Zeta".into()]);
    assert_eq!(app.views[app.view_index].source, renamed);
    assert_eq!(app.temporary_view, Some(renamed.clone()));
    assert!(app.view_history.contains(&renamed));
    assert!(app.forward_history.contains(&renamed));
    assert_eq!(app.views[app.view_index].videos.len(), 1);
    assert_eq!(app.views[app.view_index].query, "draft astronomy");
    assert_eq!(app.views[app.view_index].submitted_query, "astronomy");
    assert_eq!(app.config.pinned_categories, ["Zeta"]);
    let browser = app.browser.as_ref().unwrap();
    assert_eq!(
        browser
            .checked
            .iter()
            .map(String::as_str)
            .collect::<Vec<_>>(),
        ["Beta", "Zeta"]
    );
    assert_eq!(browser.selected_choice().unwrap().0, "Zeta");
    rename_press(&mut app, KeyCode::Enter);
    assert_eq!(app.views[app.view_index].source, renamed);
    assert!(app.job.is_none());
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn saving_combined_view_copies_snapshot_and_preserves_cached_state_without_pinning() {
    let mut app = group_app("save", "");
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","timestamp":200},{"id":"l-GaaivVJCE","title":"Second","timestamp":100}]}"#,
        true,
    );
    rename_press(&mut app, KeyCode::Down);
    let source = app.views[app.view_index].source.clone();
    let channels = app.views[app.view_index].group_channels.clone();
    let next_requests = app.views[app.view_index]
        .feed_cursor
        .plan(channels.len())
        .unwrap();
    app.views[app.view_index].feed_requests = next_requests.clone();
    app.views[app.view_index].prefetch_requested = true;
    app.views[app.view_index].has_more = true;
    app.views[app.view_index].page_error = Some("keep failure".into());
    app.views[app.view_index].query = "draft physics".into();
    app.views[app.view_index].submitted_query = "physics".into();
    let original = std::fs::read_to_string(&app.config_path).unwrap();
    rename_press(&mut app, KeyCode::Char('P'));
    app.paste("Saved union");
    rename_press(&mut app, KeyCode::Esc);
    assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
    assert_eq!(app.views[app.view_index].source, source);
    for invalid in [" ", "Alpha", "Bad\nname"] {
        rename_press(&mut app, KeyCode::Char('P'));
        app.category_name_input.as_mut().unwrap().name = invalid.into();
        rename_press(&mut app, KeyCode::Enter);
        assert!(app.category_name_input.as_ref().unwrap().error.is_some());
        assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
        assert_eq!(app.views[app.view_index].source, source);
        rename_press(&mut app, KeyCode::Esc);
    }
    rename_press(&mut app, KeyCode::Char('P'));
    app.paste("OnDisk");
    let external = format!("{original}OnDisk = []\n");
    std::fs::write(&app.config_path, &external).unwrap();
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.as_ref().unwrap().error.is_some());
    assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), external);
    assert_eq!(app.views[app.view_index].source, source);
    rename_press(&mut app, KeyCode::Esc);
    std::fs::write(&app.config_path, &original).unwrap();
    rename_press(&mut app, KeyCode::Char('P'));
    app.paste("  Saved union  ");
    // External edits do not change the union being saved.
    std::fs::write(
        &app.config_path,
        original.replace("Alpha = ['@Alpha']", "Alpha = []"),
    )
    .unwrap();
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.is_none());
    let view = &app.views[app.view_index];
    assert_eq!(view.source, ViewSource::Category("Saved union".into()));
    assert_eq!(view.query, "draft physics");
    assert_eq!(view.submitted_query, "physics");
    assert_eq!(view.selection.selected(), Some(1));
    assert_eq!(view.videos.len(), 2);
    assert_eq!(view.next_start, PAGE_SIZE + 1);
    assert_eq!(view.feed_requests, next_requests);
    assert_eq!(
        view.feed_cursor.clone().plan(channels.len()).unwrap(),
        next_requests
    );
    assert!(view.prefetch_requested);
    assert!(view.has_more);
    assert_eq!(view.page_error.as_deref(), Some("keep failure"));
    assert!(app.job.is_none());
    assert_eq!(app.config.categories["Saved union"], channels);
    assert_eq!(app.config.categories["Beta"].len(), 2);
    assert!(app.config.categories["Alpha"].is_empty());
    assert_eq!(app.config.pinned_categories, ["Alpha"]);
    assert_eq!(
        app.temporary_view,
        Some(ViewSource::Category("Saved union".into()))
    );
    let disk = std::fs::read_to_string(&app.config_path)
        .unwrap()
        .parse::<toml_edit::DocumentMut>()
        .unwrap();
    assert_eq!(
        disk["categories"]["Saved union"]
            .as_array()
            .unwrap()
            .iter()
            .map(|value| value.as_str().unwrap())
            .collect::<Vec<_>>(),
        ["@Beta", "@Alias"]
    );
    assert!(
        std::fs::read_to_string(&app.config_path)
            .unwrap()
            .starts_with("# keep this comment")
    );
    rename_press(&mut app, KeyCode::Char('-'));
    assert_eq!(app.views[app.view_index].source, source);
    assert_eq!(app.views[app.view_index].group_channels, channels);
    let saved = std::fs::read_to_string(&app.config_path).unwrap();
    std::fs::write(
        &app.config_path,
        saved.replace("Beta = ['@Alias', '@Beta']", "Beta = []"),
    )
    .unwrap();
    app.apply_config(config::load(&app.config_path).unwrap());
    assert!(app.views[app.view_index].group_channels.is_empty());
    assert_eq!(app.views[app.view_index].query, "draft physics");
    assert_eq!(app.views[app.view_index].submitted_query, "physics");
    assert_eq!(app.config.categories["Saved union"], channels);
    app.forward_view();
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Saved union".into())
    );
    assert_eq!(app.views[app.view_index].videos.len(), 2);
    assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
    assert_eq!(app.views[app.view_index].submitted_query, "physics");
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn configurable_group_controls_share_text_editing_and_are_inert_outside_groups() {
    let keys = "[keys]\nselector.toggle = 'f5'\ncategory.save = 'f6'\ninput.submit = 'f7'\ninput.cancel = 'f8'\ninput.delete.line = 'f9'\ninput.delete.word = 'f10'\ninput.delete.character = 'f11'\n";
    let mut app = group_app("remapped", "");
    let doc = keys.parse::<toml_edit::DocumentMut>().unwrap();
    app.config.keys = keys::Bindings::from_toml(doc.get("keys")).unwrap();
    let original = std::fs::read_to_string(&app.config_path).unwrap();
    rename_press(&mut app, KeyCode::Char('c'));
    rename_press(&mut app, KeyCode::Char(' '));
    assert_eq!(app.browser.as_ref().unwrap().checked.len(), 2);
    rename_press(&mut app, KeyCode::F(5));
    assert_eq!(app.browser.as_ref().unwrap().checked.len(), 1);
    rename_press(&mut app, KeyCode::Char('i'));
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::SHIFT));
    app.paste("P R");
    assert_eq!(app.browser.as_ref().unwrap().query, " P R");
    assert_eq!(app.browser.as_ref().unwrap().checked.len(), 1);
    rename_press(&mut app, KeyCode::F(8));
    rename_press(&mut app, KeyCode::Esc);
    for preview in [
        None,
        Some(PreviewMode::Info),
        Some(PreviewMode::Description),
    ] {
        app.preview = preview;
        rename_press(&mut app, KeyCode::Char('P'));
        assert!(app.category_name_input.is_none());
        rename_press(&mut app, KeyCode::F(6));
        assert!(app.category_name_input.is_some());
        rename_press(&mut app, KeyCode::F(9));
        app.paste("日本語 words");
        rename_press(&mut app, KeyCode::F(10));
        rename_press(&mut app, KeyCode::F(11));
        app.key(KeyEvent::new(KeyCode::Char('P'), KeyModifiers::SHIFT));
        app.paste("\nR\t");
        assert_eq!(app.category_name_input.as_ref().unwrap().name, "日本語P R ");
        rename_press(&mut app, KeyCode::Enter);
        assert!(app.category_name_input.is_some());
        rename_press(&mut app, KeyCode::F(8));
        assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
    }
    app.views[0].loaded = true;
    app.switch_view(0);
    rename_press(&mut app, KeyCode::F(6));
    assert!(app.category_name_input.is_none());
    for kind in [
        BrowserKind::Channels,
        BrowserKind::WatchLater,
        BrowserKind::SavedVideos,
    ] {
        app.open_browser(kind);
        rename_press(&mut app, KeyCode::F(5));
        rename_press(&mut app, KeyCode::F(6));
        assert!(app.browser.as_ref().unwrap().checked.is_empty());
        assert!(app.category_name_input.is_none());
        rename_press(&mut app, KeyCode::Esc);
    }
    app.back_view();
    rename_press(&mut app, KeyCode::F(6));
    app.paste("Remapped");
    rename_press(&mut app, KeyCode::F(7));
    assert!(app.category_name_input.is_none());
    assert!(app.config.categories.contains_key("Remapped"));
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn combined_sources_do_not_infer_a_category_for_scoped_actions() {
    let mut app = group_app("scopes", "");
    let source = app.views[app.view_index].source.clone();
    for key in [
        KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT),
        KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT),
        KeyEvent::new(KeyCode::Char('w'), KeyModifiers::ALT),
        KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT),
    ] {
        app.key(key);
        assert_eq!(app.views[app.view_index].source, source);
        assert!(app.category_dialog.is_none());
        assert!(app.category_name_input.is_none());
        assert!(app.browser.is_none());
    }
    for key in ['W', 'V'] {
        rename_press(&mut app, KeyCode::Char(key));
        assert!(app.browser.is_some());
        assert!(app.browser.as_ref().unwrap().checked.is_empty());
        rename_press(&mut app, KeyCode::Esc);
        assert_eq!(app.views[app.view_index].source, source);
    }
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn empty_combined_view_can_be_saved_as_an_empty_category() {
    let mut app = group_app("empty-save", "");
    let original = std::fs::read_to_string(&app.config_path).unwrap();
    std::fs::write(
        &app.config_path,
        original
            .replace("Alpha = ['@Alpha']", "Alpha = []")
            .replace("Beta = ['@Alias', '@Beta']", "Beta = []"),
    )
    .unwrap();
    app.apply_config(config::load(&app.config_path).unwrap());
    rename_press(&mut app, KeyCode::Char('P'));
    app.paste("Empty union");
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.is_none());
    assert!(app.config.categories["Empty union"].is_empty());
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Empty union".into())
    );
    assert!(app.views[app.view_index].loaded);
    assert!(app.views[app.view_index].videos.is_empty());
    assert!(app.job.is_none());
    assert_eq!(app.config.pinned_categories, ["Alpha"]);
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn category_checkboxes_and_dim_pins_remain_distinct_when_highlighted() {
    use ratatui::{Terminal, backend::TestBackend, style::Modifier};
    let mut app = group_app("markers", "");
    rename_press(&mut app, KeyCode::Char('c'));
    let mut terminal = Terminal::new(TestBackend::new(100, 24)).unwrap();
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let buffer = terminal.backend().buffer();
    let row = (0..buffer.area.height)
        .find_map(|y| {
            let text: String = (0..buffer.area.width)
                .map(|x| buffer[(x, y)].symbol())
                .collect();
            text.find("[x] Alpha p")
                .map(|byte| (text[..byte].chars().count() as u16, y))
        })
        .expect("checked and pinned category row");
    assert!(buffer[(row.0 + 10, row.1)].modifier.contains(Modifier::DIM));
    rename_press(&mut app, KeyCode::Char(' '));
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let buffer = terminal.backend().buffer();
    let text: String = (0..buffer.area.width)
        .map(|x| buffer[(x, row.1)].symbol())
        .collect();
    assert!(text.contains("[ ] Alpha p"));
    assert!(buffer[(row.0 + 10, row.1)].modifier.contains(Modifier::DIM));
    assert!(app.config.pinned_categories.contains(&"Alpha".into()));
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn category_rename_preserves_pins_cached_pages_collection_scopes_and_history() {
    let mut app = rename_app("cache", "");
    let videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"l-GaaivVJCE","title":"Second"}]}"#
        ).unwrap().videos;
    for source in [
        ViewSource::WatchLater(Some("Alpha".into())),
        ViewSource::SavedVideos(Some("Alpha".into())),
    ] {
        let mut view = View::new("Alpha collection".into(), source);
        view.videos = videos.clone();
        view.selection.select(Some(1));
        view.loaded = true;
        view.watch_filter = WatchFilter::Watched;
        app.views.push(view);
    }
    app.view_index = 2;
    let view = &mut app.views[2];
    view.query = " draft robotics ".into();
    view.submitted_query = "robotics".into();
    view.videos = videos.clone();
    view.feed_requests = view.feed_cursor.plan(1).unwrap();
    view.prefetch_requested = true;
    view.selection.select(Some(1));
    view.loaded = true;
    view.next_start = 41;
    view.has_more = true;
    view.page_error = Some("keep page failure".into());
    app.temporary_view = Some(ViewSource::SavedVideos(Some("Alpha".into())));
    app.view_history = vec![ViewSource::WatchLater(Some("Alpha".into()))];
    app.forward_history = vec![ViewSource::SavedVideos(Some("Alpha".into()))];
    rename_to(&mut app, "Zeta");
    let view = &app.views[app.view_index];
    assert_eq!(view.source, ViewSource::Category("Zeta".into()));
    assert_eq!(view.name, "Zeta");
    assert_eq!(view.query, " draft robotics ");
    assert_eq!(view.submitted_query, "robotics");
    assert_eq!(view.selection.selected(), Some(1));
    assert_eq!(view.videos.len(), 2);
    assert_eq!(view.feed_requests.len(), 1);
    assert!(view.prefetch_requested);
    assert_eq!(view.next_start, 41);
    assert!(view.loaded && view.has_more);
    assert_eq!(view.page_error.as_deref(), Some("keep page failure"));
    assert_eq!(app.config.pinned_categories, ["Zeta"]);
    assert_eq!(app.views[2].source, ViewSource::Category("Other".into()));
    assert_eq!(
        app.temporary_view,
        Some(ViewSource::SavedVideos(Some("Zeta".into())))
    );
    assert_eq!(
        app.view_history,
        [ViewSource::WatchLater(Some("Zeta".into()))]
    );
    assert_eq!(
        app.forward_history,
        [ViewSource::SavedVideos(Some("Zeta".into()))]
    );
    for view in &app.views {
        if matches!(
            view.source,
            ViewSource::WatchLater(_) | ViewSource::SavedVideos(_)
        ) {
            assert_eq!(view.source.category(), Some("Zeta"));
            assert_eq!(view.selection.selected(), Some(1));
            assert_eq!(view.watch_filter, WatchFilter::Watched);
            assert_eq!(view.videos.len(), 2);
        }
    }
    app.back_view();
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::WatchLater(Some("Zeta".into()))
    );
    app.forward_view();
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Zeta".into())
    );
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn rename_selectors_keep_renamed_match_selected_and_ignore_noncategory_rows() {
    for (label, kind) in [
        ("categories", BrowserKind::Categories),
        ("later", BrowserKind::WatchLater),
        ("saved", BrowserKind::SavedVideos),
        ("channels", BrowserKind::Channels),
    ] {
        let mut app = rename_app(label, "");
        app.open_browser(kind);
        if kind != BrowserKind::Categories {
            rename_press(&mut app, KeyCode::Char('R'));
            assert!(app.category_name_input.is_none());
        }
        if kind == BrowserKind::Channels {
            std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
            continue;
        }
        let browser = app.browser.as_mut().unwrap();
        browser.query = "alp".into();
        browser.refilter();
        rename_press(&mut app, KeyCode::Char('R'));
        rename_press(&mut app, KeyCode::Esc);
        assert_eq!(app.browser.as_ref().unwrap().query, "alp");
        rename_to(&mut app, "Zeta");
        let browser = app.browser.as_ref().unwrap();
        assert!(browser.query.is_empty());
        let selected = browser.matches[browser.selection.selected().unwrap()];
        assert_eq!(browser.choices[selected].1.category(), Some("Zeta"));
        assert!(app.config.pinned_categories.contains(&"Zeta".into()));
        std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
    }
    for (label, source) in [
        (
            "later-current",
            ViewSource::WatchLater(Some("Alpha".into())),
        ),
        (
            "saved-current",
            ViewSource::SavedVideos(Some("Alpha".into())),
        ),
    ] {
        let mut app = rename_app(label, "");
        let mut view = View::new("Alpha collection".into(), source);
        view.loaded = true;
        app.views.push(view);
        app.view_index = app.views.len() - 1;
        rename_to(&mut app, "Zeta");
        assert_eq!(app.views[app.view_index].source.category(), Some("Zeta"));
        std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
    }
}

#[test]
fn rename_validation_keeps_prompt_and_disk_unchanged_including_external_edits() {
    let mut app = rename_app("invalid", "");
    app.view_index = 2;
    let original = std::fs::read_to_string(&app.config_path).unwrap();
    for name in ["", "  ", "Other", "bad\nname"] {
        rename_press(&mut app, KeyCode::Char('R'));
        app.category_name_input.as_mut().unwrap().name = name.into();
        rename_press(&mut app, KeyCode::Enter);
        assert!(app.category_name_input.as_ref().unwrap().error.is_some());
        assert_eq!(
            app.views[app.view_index].source,
            ViewSource::Category("Alpha".into())
        );
        assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
        rename_press(&mut app, KeyCode::Esc);
    }
    rename_to(&mut app, "Alpha");
    assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
    for external in [
        original.replace("Alpha = ['@Alpha']", "Alpha = []"),
        original.replace("Alpha = ['@Alpha']", "Removed = ['@Alpha']"),
        original.replace("Other = []", "Other = []\nZeta = []"),
        "not valid toml = [".into(),
    ] {
        std::fs::write(&app.config_path, &external).unwrap();
        rename_press(&mut app, KeyCode::Char('R'));
        app.category_name_input.as_mut().unwrap().name = "Zeta".into();
        rename_press(&mut app, KeyCode::Enter);
        assert!(app.category_name_input.as_ref().unwrap().error.is_some());
        assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), external);
        assert!(app.config.categories.contains_key("Alpha"));
        rename_press(&mut app, KeyCode::Esc);
    }
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn tag_rename_preserves_staging_retargets_bulk_source_and_saves_only_on_tag_submit() {
    for bulk in [false, true] {
        let mut app = rename_app(if bulk { "bulk" } else { "single" }, "");
        app.view_index = 2;
        let channel = app.config.categories["Alpha"][0].clone();
        if bulk {
            app.open_bulk_category_picker();
        } else {
            app.category_dialog = Some(CategoryDialog::new(
                CategoryTarget::Channel {
                    handle: "@Alpha".into(),
                    channel: channel.clone(),
                },
                " @Alpha ".into(),
                [("Alpha".into(), true), ("Other".into(), false)].into(),
            ));
        }
        let dialog = app.category_dialog.as_mut().unwrap();
        dialog.tags.insert("Staged".into(), true);
        dialog.tags.insert("Unchecked".into(), false);
        dialog.tags.insert("Other".into(), true);
        dialog.search_names = dialog.tags.keys().map(|tag| tag.to_lowercase()).collect();
        dialog.query = "Alpha".into();
        dialog.refilter();
        rename_to(&mut app, "Zeta");
        let disk = config::load(&app.config_path).unwrap();
        assert_eq!(disk.categories["Zeta"], std::slice::from_ref(&channel));
        assert!(disk.categories["Other"].is_empty());
        assert!(!disk.categories.contains_key("Staged"));
        let dialog = app.category_dialog.as_ref().unwrap();
        assert!(dialog.tags["Zeta"] && dialog.tags["Other"] && dialog.tags["Staged"]);
        assert!(!dialog.tags["Unchecked"]);
        if let CategoryTarget::Category { name, channels } = &dialog.target {
            assert_eq!(name, "Zeta");
            assert_eq!(channels, std::slice::from_ref(&channel));
        }
        rename_press(&mut app, KeyCode::Esc);
        assert!(app.category_dialog.is_none());
        assert!(config::load(&app.config_path).unwrap().categories["Other"].is_empty());
        // Reopen with staged memberships and rename the bulk source a second time;
        // saving must use the new identity, not the now-missing original key.
        app.category_dialog = Some(CategoryDialog::new(
            if bulk {
                CategoryTarget::Category {
                    name: "Zeta".into(),
                    channels: vec![channel.clone()],
                }
            } else {
                CategoryTarget::Channel {
                    handle: "@Alpha".into(),
                    channel: channel.clone(),
                }
            },
            " target ".into(),
            [
                ("Zeta".into(), true),
                ("Other".into(), true),
                ("Staged".into(), true),
            ]
            .into(),
        ));
        let dialog = app.category_dialog.as_mut().unwrap();
        dialog.query = "Zeta".into();
        dialog.refilter();
        rename_to(&mut app, "Beta");
        rename_press(&mut app, KeyCode::Enter);
        assert!(app.category_dialog.is_none());
        let disk = config::load(&app.config_path).unwrap();
        for tag in ["Beta", "Other", "Staged"] {
            assert_eq!(disk.categories[tag], std::slice::from_ref(&channel));
        }
        assert!(!disk.categories.contains_key("Zeta"));
        std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
    }
}

#[test]
fn new_tag_rename_is_local_and_rejects_staged_and_external_collisions() {
    let mut app = rename_app("new-tag", "");
    let channel = app.config.categories["Alpha"][0].clone();
    app.category_dialog = Some(CategoryDialog::new(
        CategoryTarget::Channel {
            handle: "@Alpha".into(),
            channel,
        },
        " @Alpha ".into(),
        [
            ("Alpha".into(), true),
            ("Other".into(), false),
            ("Staged".into(), false),
        ]
        .into(),
    ));
    let dialog = app.category_dialog.as_mut().unwrap();
    dialog.query = "Staged".into();
    dialog.refilter();
    let original = std::fs::read_to_string(&app.config_path).unwrap();
    rename_press(&mut app, KeyCode::Char('R'));
    app.category_name_input.as_mut().unwrap().name = "Other".into();
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.as_ref().unwrap().error.is_some());
    app.category_name_input.as_mut().unwrap().name = "Alpha".into();
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.as_ref().unwrap().error.is_some());
    std::fs::write(&app.config_path, format!("{original}OnDisk = []\n")).unwrap();
    app.category_name_input.as_mut().unwrap().name = "OnDisk".into();
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.as_ref().unwrap().error.is_some());
    std::fs::write(&app.config_path, format!("{original}Staged = []\n")).unwrap();
    app.category_name_input.as_mut().unwrap().name = "Renamed new".into();
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.as_ref().unwrap().error.is_some());
    std::fs::write(&app.config_path, &original).unwrap();
    app.category_name_input.as_mut().unwrap().name = "Renamed new".into();
    rename_press(&mut app, KeyCode::Enter);
    assert!(app.category_name_input.is_none());
    assert_eq!(std::fs::read_to_string(&app.config_path).unwrap(), original);
    let dialog = app.category_dialog.as_ref().unwrap();
    assert!(!dialog.tags["Renamed new"]);
    assert!(!dialog.tags.contains_key("Staged"));
    rename_press(&mut app, KeyCode::Char(' '));
    rename_press(&mut app, KeyCode::Enter);
    assert!(
        config::load(&app.config_path)
            .unwrap()
            .categories
            .contains_key("Renamed new")
    );
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn unpinned_category_rename_retains_its_temporary_tab_and_cached_rows() {
    let mut app = rename_app("unpinned", "");
    let config = config::set_category_pinned(&app.config_path, "Alpha", false).unwrap();
    app.apply_config(config);
    app.view_index = 2;
    app.views[2].loaded = true;
    app.views[2].next_start = 61;
    app.temporary_view = Some(ViewSource::Category("Alpha".into()));
    rename_to(&mut app, "Zeta");
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Zeta".into())
    );
    assert_eq!(app.views[app.view_index].next_start, 61);
    assert_eq!(
        app.temporary_view,
        Some(ViewSource::Category("Zeta".into()))
    );
    assert!(app.config.pinned_categories.is_empty());
    assert_eq!(
        app.visible_views().last().unwrap().1.source,
        ViewSource::Category("Zeta".into())
    );
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn rename_uses_configured_actions_and_uppercase_r_stays_literal_in_all_inputs() {
    let keys = "[keys]\ncategory.rename = 'f6'\ninput.submit = 'f7'\ninput.cancel = 'f8'\ninput.delete.line = 'f9'\ninput.delete.word = 'f10'\ninput.delete.character = 'f11'\n";
    for entry in ["view", "browser", "tags"] {
        let mut app = rename_app(&format!("remapped-{entry}"), keys);
        app.view_index = 2;
        match entry {
            "browser" => app.open_browser(BrowserKind::Categories),
            "tags" => {
                app.category_dialog = Some(CategoryDialog::new(
                    CategoryTarget::Channel {
                        handle: "@Alpha".into(),
                        channel: app.config.categories["Alpha"][0].clone(),
                    },
                    " target ".into(),
                    [("Alpha".into(), true), ("Other".into(), false)].into(),
                ))
            }
            _ => {}
        }
        app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
        assert!(
            app.category_name_input.is_none(),
            "default action is replaced"
        );
        rename_press(&mut app, KeyCode::F(6));
        assert_eq!(app.key_context(), Context::CategoryNameInput);
        rename_press(&mut app, KeyCode::F(9));
        app.paste("日本語 words");
        rename_press(&mut app, KeyCode::F(10));
        assert_eq!(app.category_name_input.as_ref().unwrap().name, "日本語 ");
        rename_press(&mut app, KeyCode::F(11));
        app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
        app.paste("\n?\t");
        assert_eq!(app.category_name_input.as_ref().unwrap().name, "日本語R ? ");
        assert!(app.help_popup.is_none());
        rename_press(&mut app, KeyCode::F(8));
        assert!(app.category_name_input.is_none());
        assert!(app.config.categories.contains_key("Alpha"));
        rename_press(&mut app, KeyCode::F(6));
        rename_press(&mut app, KeyCode::F(9));
        app.paste("Zeta");
        rename_press(&mut app, KeyCode::Enter);
        assert!(
            app.category_name_input.is_some(),
            "default submit is replaced"
        );
        rename_press(&mut app, KeyCode::F(7));
        assert!(app.category_name_input.is_none());
        assert!(
            config::load(&app.config_path)
                .unwrap()
                .categories
                .contains_key("Zeta")
        );
        std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
    }
    let mut app = rename_app("literal-r", "");
    rename_press(&mut app, KeyCode::Char('i'));
    app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
    assert_eq!(app.views[0].query, "R");
    assert!(app.category_name_input.is_none());
    rename_press(&mut app, KeyCode::Esc);
    app.open_browser(BrowserKind::Categories);
    rename_press(&mut app, KeyCode::Char('i'));
    app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
    assert_eq!(app.browser.as_ref().unwrap().query, "R");
    assert!(app.category_name_input.is_none());
    app.browser = None;
    app.category_dialog = Some(CategoryDialog::new(
        CategoryTarget::Channel {
            handle: "@Alpha".into(),
            channel: app.config.categories["Alpha"][0].clone(),
        },
        " target ".into(),
        [("Alpha".into(), true)].into(),
    ));
    rename_press(&mut app, KeyCode::Char('i'));
    app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
    assert_eq!(app.category_dialog.as_ref().unwrap().query, "R");
    assert!(app.category_name_input.is_none());
    rename_press(&mut app, KeyCode::Esc);
    rename_press(&mut app, KeyCode::Char('n'));
    app.key(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::SHIFT));
    assert_eq!(
        app.category_dialog.as_ref().unwrap().name.as_deref(),
        Some("R")
    );
    assert!(app.category_name_input.is_none());
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn rename_prompt_cursor_scrolls_by_display_width_without_changing_selection() {
    use ratatui::{Terminal, backend::TestBackend};
    let mut app = rename_app("rename-cursor", "");
    app.view_index = 2;
    rename_press(&mut app, KeyCode::Char('R'));
    let mut terminal = Terminal::new(TestBackend::new(24, 16)).unwrap();
    for (text, x) in [
        ("", 3),
        ("日本語", 9),
        ("e\u{301}", 4),
        ("abcdefghijklmnopqrstuvwxyz", 20),
    ] {
        app.category_name_input.as_mut().unwrap().name = text.into();
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        assert_eq!(terminal.get_cursor_position().unwrap(), (x, 4).into());
        assert_eq!(
            app.views[app.view_index].source,
            ViewSource::Category("Alpha".into())
        );
    }
    rename_press(&mut app, KeyCode::Esc);
    assert!(app.category_name_input.is_none());
    std::fs::remove_dir_all(app.config_path.parent().unwrap()).unwrap();
}

#[test]
fn collection_removal_is_inert_in_ordinary_views_and_their_previews() {
    let mut app = app(&["tubular"]);
    app.config.categories.insert("Category".into(), vec![]);
    let videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"}]}"#,
        ).unwrap().videos;
    app.views[0].videos = videos.clone();
    app.views[0].loaded = true;
    for row in 0..2 {
        app.views[0].selection.select(Some(row));
        app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE));
    }
    for source in [
        ViewSource::Search,
        ViewSource::Feed,
        ViewSource::Category("Category".into()),
        ViewSource::Channel(config::normalize_channel("@creator").unwrap()),
    ] {
        let mut view = View::new("Ordinary".into(), source);
        view.videos = videos.clone();
        view.loaded = true;
        view.selection.select(Some(0));
        let index = app.views.len();
        app.views.push(view);
        app.switch_view(index);
        for (preview, context) in [
            (None, Context::Normal),
            (Some(PreviewMode::Info), Context::Info),
            (Some(PreviewMode::Description), Context::Description),
        ] {
            app.preview = preview;
            assert_eq!(app.key_context(), context);
            assert!(app.current_collection().is_none());
            let status = app.status.clone();
            for key in ['x', 'X', 'D'] {
                app.key(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE));
            }
            app.remove_collection();
            app.remove_collection_bulk();
            assert!(app.collection_removal.is_none());
            assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
            assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
            assert_eq!(app.views[index].selection.selected(), Some(0));
            assert_eq!(app.preview, preview);
            assert_eq!(app.status, status);
            app.paste("xX");
            assert!(app.views[0].query.is_empty());
        }
    }
}

#[test]
fn collection_contexts_preserve_modal_priorities_and_cancel_bulk_from_each_preview() {
    let mut app = app(&["tubular"]);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    for row in 0..2 {
        app.views[0].selection.select(Some(row));
        app.save_collection(CollectionKind::WatchLater);
        app.save_collection(CollectionKind::Saved);
    }
    for kind in [CollectionKind::WatchLater, CollectionKind::Saved] {
        app.switch_view(0);
        app.browse_collection(kind);
        for (preview, context, cancel) in [
            (None, Context::CollectionNormal, KeyCode::Char('n')),
            (
                Some(PreviewMode::Info),
                Context::CollectionInfo,
                KeyCode::Esc,
            ),
            (
                Some(PreviewMode::Description),
                Context::CollectionDescription,
                KeyCode::Char('n'),
            ),
        ] {
            app.preview = preview;
            assert_eq!(app.key_context(), context);
            app.key(KeyEvent::new(KeyCode::Char('D'), KeyModifiers::SHIFT));
            assert!(app.collection_removal.is_none());
            app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
            assert_eq!(app.preview, None);
            let removal = app.collection_removal.as_ref().unwrap();
            assert_eq!(removal.ids.len(), 2);
            assert!(removal.category.is_none());
            assert_eq!(
                removal.filter,
                matches!(kind, CollectionKind::WatchLater).then_some(WatchFilter::All)
            );
            let history = app.view_history.clone();
            app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
            app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
            app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
            app.paste("y");
            assert!(app.collection_removal.is_some());
            assert!(app.player_launch.is_none());
            assert_eq!(app.view_history, history);
            assert!(app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)));
            assert!(app.collection_removal.is_some());
            app.key(KeyEvent::new(cancel, KeyModifiers::NONE));
            assert!(app.collection_removal.is_none());
            assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
            assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
        }
        app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::SearchInput);
        app.paste("xX");
        assert_eq!(app.views[0].query, "xX");
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::CollectionNormal);
        app.views[0].query.clear();
        app.key(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::Help);
        app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
        assert!(app.collection_removal.is_none());
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::CollectionNormal);
        app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::SelectorNormal);
        app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::SelectorInput);
        app.paste("xX");
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::CollectionNormal);
        app.category_dialog = Some(CategoryDialog::new(
            CategoryTarget::Channel {
                handle: "@creator".into(),
                channel: config::normalize_channel("@creator").unwrap(),
            },
            "Creator".into(),
            [("Category".into(), false)].into(),
        ));
        assert_eq!(app.key_context(), Context::TagList);
        app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::TagFilter);
        app.paste("xX");
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::TagInput);
        app.paste("xX");
        assert_eq!(
            app.category_dialog.as_ref().unwrap().name.as_deref(),
            Some("xX")
        );
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        assert_eq!(app.key_context(), Context::CollectionNormal);
        assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
        assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
    }
}

#[test]
fn bulk_removal_snapshots_saved_categories_and_watch_filters_independently() {
    let root = std::env::temp_dir().join(format!("tubular-collection-bulk-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&root);
    std::fs::create_dir_all(&root).unwrap();
    std::fs::write(
        root.join("watch-state.toml"),
        "version = 1\nwatched = ['jNQXAC9IVRw']\n",
    )
    .unwrap();
    let category_channels = vec![config::normalize_channel("@creator").unwrap()];
    let config = config::Config {
        categories: [("Category".into(), category_channels.clone())].into(),
        ..Default::default()
    };
    let path = root.join("config.toml");
    let mut app = App::with_state(
        Options::parse_from(["tubular"]),
        path.clone(),
        config,
        video_state::State::open(&path).unwrap(),
    );
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Watched","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Unwatched","uploader_id":"@creator"},{"id":"l-GaaivVJCE","title":"Outside category","uploader_id":"@other"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    for row in 0..3 {
        app.views[0].selection.select(Some(row));
        app.save_collection(CollectionKind::WatchLater);
        app.save_collection(CollectionKind::Saved);
    }
    app.views[2].loaded = true;
    app.switch_view(2);
    app.browse_category_collection(CollectionKind::Saved);
    app.preview = Some(PreviewMode::Description);
    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::NONE));
    let removal = app.collection_removal.as_ref().unwrap();
    assert!(matches!(removal.kind, CollectionKind::Saved));
    assert_eq!(removal.category.as_deref(), Some("Category"));
    assert_eq!(removal.filter, None);
    assert_eq!(removal.ids, ["jNQXAC9IVRw", "rQ_J9WH6CGk"]);
    let prompt = removal.text.clone();
    app.apply_config(config::Config {
        categories: [(
            "Category".into(),
            vec![
                config::normalize_channel("@creator").unwrap(),
                config::normalize_channel("@other").unwrap(),
            ],
        )]
        .into(),
        ..Default::default()
    });
    assert_eq!(app.views[app.view_index].videos.len(), 3);
    assert_eq!(app.collection_removal.as_ref().unwrap().text, prompt);
    app.browse_category_collection(CollectionKind::WatchLater);
    app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
    assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 1);
    assert!(
        app.video_state
            .contains(CollectionKind::Saved, "l-GaaivVJCE")
    );
    assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 3);
    assert!(app.video_state.is_watched("jNQXAC9IVRw"));
    app.apply_config(config::Config {
        categories: [("Category".into(), category_channels)].into(),
        ..Default::default()
    });
    app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].videos.len(), 1);
    app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].watch_filter, WatchFilter::Watched);
    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    let removal = app.collection_removal.as_ref().unwrap();
    assert!(matches!(removal.kind, CollectionKind::WatchLater));
    assert_eq!(removal.filter, Some(WatchFilter::Watched));
    assert_eq!(removal.ids, ["jNQXAC9IVRw"]);
    app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
    assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
    assert!(app.views[app.view_index].videos.is_empty());
    assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 1);
    assert!(app.video_state.is_watched("jNQXAC9IVRw"));
    app.switch_view(0);
    app.browse_collection(CollectionKind::WatchLater);
    app.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].watch_filter,
        WatchFilter::Unwatched
    );
    assert_eq!(app.views[app.view_index].videos.len(), 2);
    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    assert!(app.collection_removal.as_ref().unwrap().category.is_none());
    app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
    assert!(
        app.video_state
            .videos(CollectionKind::WatchLater)
            .is_empty()
    );
    app.browse_collection(CollectionKind::Saved);
    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
    assert!(app.video_state.videos(CollectionKind::Saved).is_empty());
    assert!(app.video_state.is_watched("jNQXAC9IVRw"));
    drop(app);
    let restarted = video_state::State::open(&path).unwrap();
    assert!(restarted.videos(CollectionKind::Saved).is_empty());
    assert!(restarted.videos(CollectionKind::WatchLater).is_empty());
    assert!(restarted.is_watched("jNQXAC9IVRw"));
    std::fs::remove_dir_all(root).unwrap();
}

#[test]
fn individual_watch_later_removal_keeps_siblings_saved_and_watched() {
    let root = std::env::temp_dir().join(format!(
        "tubular-single-watch-removal-{}",
        std::process::id()
    ));
    let _ = std::fs::remove_dir_all(&root);
    std::fs::create_dir_all(&root).unwrap();
    std::fs::write(
        root.join("watch-state.toml"),
        "version = 1\nwatched = ['jNQXAC9IVRw']\n",
    )
    .unwrap();
    let mut app = App::with_state(
        Options::parse_from(["tubular"]),
        root.join("config.toml"),
        config::Config::default(),
        video_state::State::open(&root.join("config.toml")).unwrap(),
    );
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@creator"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(0));
    app.save_collection(CollectionKind::WatchLater);
    app.save_collection(CollectionKind::Saved);
    app.views[0].selection.select(Some(1));
    app.save_collection(CollectionKind::WatchLater);
    app.browse_collection(CollectionKind::WatchLater);
    app.views[app.view_index].selection.select(Some(0));
    app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
    assert!(
        !app.video_state
            .contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
    );
    assert!(
        app.video_state
            .contains(CollectionKind::WatchLater, "rQ_J9WH6CGk")
    );
    assert!(
        app.video_state
            .contains(CollectionKind::Saved, "jNQXAC9IVRw")
    );
    assert!(app.video_state.is_watched("jNQXAC9IVRw"));
    assert!(app.collection_removal.is_none());
    app.views[app.view_index].selection.select(Some(0));
    app.preview = Some(PreviewMode::Info);
    app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
    assert!(
        app.video_state
            .videos(CollectionKind::WatchLater)
            .is_empty()
    );
    assert_eq!(app.preview, None);
    app.switch_view(0);
    app.views[0].selection.select(Some(1));
    app.save_collection(CollectionKind::WatchLater);
    app.browse_collection(CollectionKind::WatchLater);
    app.preview = Some(PreviewMode::Description);
    app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
    assert!(
        app.video_state
            .videos(CollectionKind::WatchLater)
            .is_empty()
    );
    assert_eq!(app.preview, None);
    drop(app);
    let restarted = video_state::State::open(&root.join("config.toml")).unwrap();
    assert!(restarted.videos(CollectionKind::WatchLater).is_empty());
    assert!(restarted.contains(CollectionKind::Saved, "jNQXAC9IVRw"));
    assert!(restarted.is_watched("jNQXAC9IVRw"));
    std::fs::remove_dir_all(root).unwrap();
}

#[test]
fn manual_status_updates_filtered_lists_and_closes_removed_previews() {
    let mut app = app(&["tubular"]);
    let document = "[keys]\nvideo.status.watching = 'f6'\nvideo.status.watched = 'f7'\n"
        .parse::<toml_edit::DocumentMut>()
        .unwrap();
    app.apply_config(config::Config {
        keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
        ..Default::default()
    });
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    for row in 0..2 {
        app.views[0].selection.select(Some(row));
        app.save_collection(CollectionKind::WatchLater);
    }
    app.browse_collection(CollectionKind::WatchLater);
    app.filter_watch_later();
    app.views[app.view_index].selection.select(Some(0));
    app.preview = Some(PreviewMode::Info);
    app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
    assert!(app.video_state.is_watched("jNQXAC9IVRw"));
    assert_eq!(app.views[app.view_index].videos[0].id, "rQ_J9WH6CGk");
    assert_eq!(app.preview, None);
    app.filter_watch_later();
    assert_eq!(app.views[app.view_index].videos[0].id, "jNQXAC9IVRw");
    app.preview = Some(PreviewMode::Description);
    app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
    assert!(!app.video_state.is_watched("jNQXAC9IVRw"));
    assert!(app.views[app.view_index].videos.is_empty());
    assert_eq!(app.views[app.view_index].selection.selected(), None);
    assert_eq!(app.preview, None);
    assert!(
        app.video_state
            .contains(CollectionKind::Watching, "jNQXAC9IVRw")
    );
    assert!(
        app.video_state
            .contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
    );
    app.browse_collection(CollectionKind::Watching);
    app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
    assert!(app.views[app.view_index].videos.is_empty());
    assert!(app.video_state.is_watched("jNQXAC9IVRw"));
}

#[test]
fn watch_later_tracks_current_tags_filters_and_confirms_only_snapshot_removal() {
    let root = std::env::temp_dir().join(format!(
        "tubular-watch-ui-regression-{}",
        std::process::id()
    ));
    let path = root.join("config.toml");
    let _ = std::fs::remove_dir_all(&root);
    let state = video_state::State::open(&path).unwrap();
    let channel = config::normalize_channel("UC4QobU6STFB0P71PMvOGN5A").unwrap();
    let config = config::Config {
        channels: [("@creator".into(), channel.clone())].into(),
        categories: [("Category".into(), vec![channel.clone()])].into(),
        ..Default::default()
    };
    let mut app = App::with_state(
        Options::parse_from(["tubular"]),
        path.clone(),
        config,
        state,
    );
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Mapped creator","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Other creator","uploader_id":"@other"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(0));
    app.save_collection(CollectionKind::WatchLater);
    app.save_collection(CollectionKind::WatchLater);
    app.views[0].selection.select(Some(1));
    app.save_collection(CollectionKind::WatchLater);
    assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);
    app.views[0].selection.select(None);
    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(120, 24)).unwrap();
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let buffer = terminal.backend().buffer();
    let title = buffer
        .content
        .iter()
        .position(|cell| cell.symbol() == "M" && cell.fg == Color::Magenta);
    assert!(title.is_some(), "saved video titles use a distinct color");
    app.views[0].selection.select(Some(1));

    // An empty loaded category avoids extraction while opening its derived offline list.
    app.views[2].loaded = true;
    app.switch_view(2);
    app.browse_category_collection(CollectionKind::WatchLater);
    let category_source = ViewSource::WatchLater(Some("Category".into()));
    assert_eq!(app.views[app.view_index].source, category_source);
    assert_eq!(app.views[app.view_index].videos.len(), 1);
    app.browse_category_collection(CollectionKind::WatchLater);
    assert_eq!(app.views[app.view_index].source, category_source);
    assert!(app.job.is_none());

    app.filter_watch_later();
    assert_eq!(
        app.views[app.view_index].watch_filter,
        WatchFilter::Unwatched
    );
    assert_eq!(app.views[app.view_index].videos.len(), 1);
    app.filter_watch_later();
    assert_eq!(app.views[app.view_index].watch_filter, WatchFilter::Watched);
    assert!(app.views[app.view_index].videos.is_empty());
    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    assert!(app.collection_removal.is_none());
    app.filter_watch_later();

    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    let history = app.view_history.clone();
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    app.paste("y");
    assert!(app.collection_removal.is_some());
    assert!(app.player_launch.is_none());
    assert_eq!(app.view_history, history);
    app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
    assert!(app.collection_removal.is_none());
    assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 2);

    app.apply_config(config::Config {
        channels: [("@creator".into(), channel.clone())].into(),
        categories: [("Category".into(), vec![])].into(),
        ..Default::default()
    });
    assert_eq!(app.views[app.view_index].source, category_source);
    assert!(app.views[app.view_index].videos.is_empty());
    app.apply_config(config::Config {
        channels: [("@creator".into(), channel.clone())].into(),
        categories: [("Category".into(), vec![channel])].into(),
        ..Default::default()
    });
    assert_eq!(
        app.views[app.view_index].videos.len(),
        1,
        "mapped handles follow canonical membership"
    );
    app.apply_config(config::Config {
        categories: [(
            "Category".into(),
            vec![config::normalize_channel("@creator").unwrap()],
        )]
        .into(),
        ..Default::default()
    });
    assert_eq!(
        app.views[app.view_index].videos.len(),
        1,
        "unmapped handles remain usable"
    );

    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    app.apply_config(config::Config {
        categories: [(
            "Category".into(),
            vec![
                config::normalize_channel("@creator").unwrap(),
                config::normalize_channel("@other").unwrap(),
            ],
        )]
        .into(),
        ..Default::default()
    });
    assert_eq!(app.views[app.view_index].videos.len(), 2);
    assert_eq!(
        app.collection_removal.as_ref().unwrap().ids,
        ["jNQXAC9IVRw"]
    );
    app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
    assert_eq!(app.video_state.videos(CollectionKind::WatchLater).len(), 1);
    assert!(
        app.video_state
            .contains(CollectionKind::WatchLater, "rQ_J9WH6CGk")
    );
    assert_eq!(app.views[app.view_index].videos.len(), 1);

    app.switch_view(0);
    app.browse_collection(CollectionKind::WatchLater);
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::WatchLater(None)
    );
    app.back_view();
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    app.forward_view();
    drop(app);
    let mut restarted = App::with_state(
        Options::parse_from(["tubular"]),
        path.clone(),
        config::Config::default(),
        video_state::State::open(&path).unwrap(),
    );
    restarted.browse_collection(CollectionKind::WatchLater);
    assert!(restarted.job.is_none());
    assert!(restarted.views[restarted.view_index].loaded);
    assert_eq!(
        restarted.views[restarted.view_index].videos[0].title,
        "Other creator"
    );
    restarted.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    restarted.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
    assert!(
        restarted
            .video_state
            .videos(CollectionKind::WatchLater)
            .is_empty()
    );
    drop(restarted);
    assert!(
        video_state::State::open(&path)
            .unwrap()
            .videos(CollectionKind::WatchLater)
            .is_empty()
    );
    std::fs::remove_dir_all(root).unwrap();
}

#[test]
fn saved_views_follow_current_categories_and_restore_offline_history() {
    let root = std::env::temp_dir().join(format!("tubular-saved-ui-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&root);
    std::fs::create_dir_all(&root).unwrap();
    let path = root.join("config.toml");
    std::fs::write(
        root.join("watch-state.toml"),
        "version = 1\nwatched = [\"jNQXAC9IVRw\"]\n",
    )
    .unwrap();
    let channel = config::normalize_channel("UC4QobU6STFB0P71PMvOGN5A").unwrap();
    let other = config::normalize_channel("@other").unwrap();
    let config = config::Config {
        channels: [("@creator".into(), channel.clone())].into(),
        categories: [
            ("Category".into(), vec![channel.clone(), other.clone()]),
            ("Overlap".into(), vec![channel]),
        ]
        .into(),
        ..Default::default()
    };
    let mut app = App::with_state(
        Options::parse_from(["tubular"]),
        path.clone(),
        config,
        video_state::State::open(&path).unwrap(),
    );
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Mapped creator","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Other creator","uploader_id":"@other"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    for row in 0..2 {
        app.views[0].selection.select(Some(row));
        app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));
    }
    app.views[2].loaded = true;
    app.switch_view(2);
    app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT));
    let saved_category = ViewSource::SavedVideos(Some("Category".into()));
    assert_eq!(app.views[app.view_index].source, saved_category);
    assert_eq!(app.views[app.view_index].videos.len(), 2);
    app.views[app.view_index].selection.select(Some(1));
    app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::ALT));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::WatchLater(Some("Category".into()))
    );
    app.filter_watch_later();
    assert_eq!(app.views[app.view_index].videos.len(), 1);
    assert!(app.views[app.view_index].title.contains("Unwatched"));
    app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT));
    assert_eq!(app.views[app.view_index].source, saved_category);
    assert_eq!(
        app.views[app.view_index].videos.len(),
        2,
        "saved lists ignore watch filters"
    );
    assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
    let mut config = config::Config {
        channels: app.config.channels.clone(),
        categories: app.config.categories.clone(),
        ..Default::default()
    };
    config.categories.insert("Category".into(), vec![other]);
    app.apply_config(config);
    assert_eq!(app.views[app.view_index].source, saved_category);
    assert_eq!(app.views[app.view_index].videos[0].id, "rQ_J9WH6CGk");
    assert_eq!(app.views[app.view_index].selection.selected(), Some(0));
    let watch = app
        .views
        .iter()
        .find(|view| matches!(view.source, ViewSource::WatchLater(Some(_))))
        .unwrap();
    assert_eq!(watch.watch_filter, WatchFilter::Unwatched);
    assert!(watch.title.contains("Unwatched"));
    app.switch_view(0);
    app.key(KeyEvent::new(KeyCode::Char('V'), KeyModifiers::SHIFT));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::SavedVideos(None)
    );
    assert_eq!(
        app.views[app.view_index].videos.len(),
        2,
        "overlapping categories do not duplicate videos"
    );
    app.views[app.view_index].selection.select(Some(1));
    app.back_view();
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    app.back_view();
    assert_eq!(app.views[app.view_index].source, saved_category);
    app.forward_view();
    app.forward_view();
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::SavedVideos(None)
    );
    assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
    assert!(app.job.is_none());
    app.views[app.view_index].selection.select(Some(0));
    app.preview = Some(PreviewMode::Info);
    app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
    assert!(
        app.preview.is_none(),
        "removing the selected row dismisses its preview"
    );
    assert_eq!(app.views[app.view_index].videos.len(), 1);
    assert!(
        app.video_state
            .contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
    );
    assert!(app.video_state.is_watched("jNQXAC9IVRw"));
    let config = std::mem::take(&mut app.config);
    drop(app);
    let mut restarted = App::with_state(
        Options::parse_from(["tubular"]),
        path.clone(),
        config,
        video_state::State::open(&path).unwrap(),
    );
    restarted.browse_collection(CollectionKind::Saved);
    let view = &restarted.views[restarted.view_index];
    assert!(view.loaded && !view.has_more);
    assert_eq!(view.videos.len(), 1);
    assert_eq!(view.videos[0].title, "Other creator");
    assert!(restarted.job.is_none());
    assert!(restarted.video_state.is_watched("jNQXAC9IVRw"));
    assert_eq!(
        restarted
            .video_state
            .videos(CollectionKind::WatchLater)
            .len(),
        2
    );
    drop(restarted);
    std::fs::remove_dir_all(root).unwrap();
}

#[test]
fn collection_shortcuts_separate_global_and_category_scopes_in_every_video_context() {
    for custom in [false, true] {
        let root = std::env::temp_dir().join(format!(
            "tubular-collection-scopes-{}-{custom}",
            std::process::id()
        ));
        let _ = std::fs::remove_dir_all(&root);
        std::fs::create_dir_all(&root).unwrap();
        std::fs::write(
            root.join("watch-state.toml"),
            "version = 1\nwatched = ['l-GaaivVJCE']\n",
        )
        .unwrap();
        let path = root.join("config.toml");
        let mut app = App::with_state(
            Options::parse_from(["tubular"]),
            path.clone(),
            config::Config::default(),
            video_state::State::open(&path).unwrap(),
        );
        let bindings = if custom {
            let document = "[keys]\nview.watch_later.browse = 'f5'\nview.saved.browse = 'f6'\nview.watch_later.category = 'f7'\nview.saved.category = 'f8'\n"
                    .parse::<toml_edit::DocumentMut>().unwrap();
            keys::Bindings::from_toml(document.get("keys")).unwrap()
        } else {
            keys::Bindings::default()
        };
        app.apply_config(config::Config {
            categories: [(
                "Category".into(),
                vec![config::normalize_channel("@creator").unwrap()],
            )]
            .into(),
            keys: bindings,
            ..Default::default()
        });
        app.views[0].videos = youtube::search_results(
                r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Category","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Other","uploader_id":"@other"},{"id":"l-GaaivVJCE","title":"Watched category","uploader_id":"@creator"}]}"#,
            ).unwrap().videos;
        for view in &mut app.views {
            view.loaded = true;
        }
        for row in 0..3 {
            app.views[0].selection.select(Some(row));
            app.save_collection(CollectionKind::WatchLater);
            app.save_collection(CollectionKind::Saved);
        }
        let key = |function, character, modifiers| {
            KeyEvent::new(
                if custom {
                    KeyCode::F(function)
                } else {
                    KeyCode::Char(character)
                },
                if custom {
                    KeyModifiers::NONE
                } else {
                    modifiers
                },
            )
        };
        let global_watch = key(5, 'W', KeyModifiers::SHIFT);
        let global_saved = key(6, 'V', KeyModifiers::SHIFT);
        let category_watch = key(7, 'w', KeyModifiers::ALT);
        let category_saved = key(8, 'v', KeyModifiers::ALT);
        for (selector, expected) in [
            (
                global_watch,
                ViewSource::WatchLater(Some("Category".into())),
            ),
            (
                global_saved,
                ViewSource::SavedVideos(Some("Category".into())),
            ),
        ] {
            app.switch_view(0);
            let history = app.view_history.clone();
            app.key(selector);
            let browser = app.browser.as_ref().unwrap();
            assert!(matches!(
                browser.choices[0].1,
                ViewSource::WatchLater(None) | ViewSource::SavedVideos(None)
            ));
            app.key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));
            assert!(app.config.pinned_categories.is_empty());
            app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
            for c in "zzzz".chars() {
                app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
            }
            app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
            assert!(app.browser.as_ref().unwrap().matches.is_empty());
            assert_eq!(app.views[app.view_index].source, ViewSource::Search);
            assert_eq!(app.view_history, history);
            app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
            app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
            assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
            app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
            assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
            for c in "category".chars() {
                app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
            }
            assert_eq!(app.browser.as_ref().unwrap().matches.len(), 1);
            app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
            assert_eq!(app.views[app.view_index].source, expected);
            assert_eq!(app.views[app.view_index].videos.len(), 2);
            assert!(app.browser.is_none());
        }
        // Seed a cached combined view with a different filter.
        choose_combined(&mut app, global_watch);
        assert_eq!(app.views[app.view_index].watch_filter, WatchFilter::All);
        app.switch_view(2);
        app.key(category_watch);
        app.filter_watch_later();
        for preview in [
            None,
            Some(PreviewMode::Info),
            Some(PreviewMode::Description),
        ] {
            app.preview = preview;
            choose_combined(&mut app, global_watch);
            let view = &app.views[app.view_index];
            assert_eq!(view.source, ViewSource::WatchLater(None));
            assert_eq!(view.watch_filter, WatchFilter::Unwatched);
            assert_eq!(
                view.videos
                    .iter()
                    .map(|video| video.id.as_str())
                    .collect::<Vec<_>>(),
                ["jNQXAC9IVRw", "rQ_J9WH6CGk"]
            );
            assert_eq!(app.preview, None);
            let history = app.view_history.clone();
            app.preview = preview;
            choose_combined(&mut app, global_watch);
            assert_eq!(app.preview, None);
            assert_eq!(app.view_history, history);
            app.back_view();
            assert_eq!(
                app.views[app.view_index].source,
                ViewSource::WatchLater(Some("Category".into()))
            );
            assert_eq!(
                app.views[app.view_index].watch_filter,
                WatchFilter::Unwatched
            );
            assert_eq!(app.views[app.view_index].videos.len(), 1);
        }
        for preview in [
            None,
            Some(PreviewMode::Info),
            Some(PreviewMode::Description),
        ] {
            app.preview = preview;
            app.key(category_saved);
            assert_eq!(
                app.views[app.view_index].source,
                ViewSource::SavedVideos(Some("Category".into()))
            );
            assert_eq!(app.preview, None);
            app.preview = preview;
            choose_combined(&mut app, global_saved);
            assert_eq!(
                app.views[app.view_index].source,
                ViewSource::SavedVideos(None)
            );
            assert_eq!(app.views[app.view_index].videos.len(), 3);
            assert_eq!(app.preview, None);
            app.back_view();
            assert_eq!(
                app.views[app.view_index].source,
                ViewSource::SavedVideos(Some("Category".into()))
            );
            app.preview = preview;
            app.key(category_watch);
            assert_eq!(
                app.views[app.view_index].source,
                ViewSource::WatchLater(Some("Category".into()))
            );
            assert_eq!(
                app.views[app.view_index].watch_filter,
                WatchFilter::Unwatched
            );
            assert_eq!(app.preview, None);
        }
        app.switch_view(0);
        choose_combined(&mut app, global_watch);
        assert_eq!(
            app.views[app.view_index].watch_filter,
            WatchFilter::Unwatched
        );
        let mut channel = View::new(
            "Creator".into(),
            ViewSource::Channel(config::normalize_channel("@creator").unwrap()),
        );
        channel.loaded = true;
        app.views.push(channel);
        for index in [0, 1, app.views.len() - 1] {
            app.switch_view(index);
            for key in [category_watch, category_saved] {
                let history = app.view_history.clone();
                app.key(key);
                assert_eq!(app.view_index, index);
                assert_eq!(app.view_history, history);
            }
            for preview in [
                None,
                Some(PreviewMode::Info),
                Some(PreviewMode::Description),
            ] {
                for key in [global_watch, global_saved] {
                    app.preview = preview;
                    choose_combined(&mut app, key);
                    assert!(matches!(
                        app.views[app.view_index].source,
                        ViewSource::WatchLater(None) | ViewSource::SavedVideos(None)
                    ));
                    assert_eq!(app.preview, None);
                    app.back_view();
                    assert_eq!(app.view_index, index);
                }
            }
        }
        for key in [global_watch, global_saved] {
            choose_combined(&mut app, key);
            let source = app.views[app.view_index].source.clone();
            for category_key in [category_watch, category_saved] {
                app.key(category_key);
                assert_eq!(app.views[app.view_index].source, source);
            }
        }
        assert!(app.job.is_none());
        drop(app);
        std::fs::remove_dir_all(root).unwrap();
    }
}

#[test]
fn collection_shortcuts_leave_text_entry_bindings_unchanged() {
    let mut app = app(&["tubular"]);
    let type_keys = |app: &mut App| {
        for character in ['W', 'V', 'w', 'v'] {
            app.key(KeyEvent::new(KeyCode::Char(character), KeyModifiers::NONE));
        }
        for character in ['w', 'v'] {
            app.key(KeyEvent::new(KeyCode::Char(character), KeyModifiers::ALT));
        }
        assert_eq!(app.view_index, 0);
        assert!(app.view_history.is_empty());
    };
    app.mode = Mode::Insert;
    type_keys(&mut app);
    assert_eq!(app.views[0].query, "WVwv");
    app.mode = Mode::Normal;
    for kind in [BrowserKind::Categories, BrowserKind::Channels] {
        app.open_browser(kind);
        app.browser.as_mut().unwrap().mode = Mode::Insert;
        type_keys(&mut app);
        assert_eq!(app.browser.as_ref().unwrap().query, "WVwv");
        app.browser = None;
    }
    app.category_dialog = Some(CategoryDialog::new(
        CategoryTarget::Channel {
            handle: "@creator".into(),
            channel: "creator".into(),
        },
        "Creator".into(),
        BTreeMap::new(),
    ));
    app.category_dialog.as_mut().unwrap().mode = Mode::Insert;
    type_keys(&mut app);
    assert_eq!(app.category_dialog.as_ref().unwrap().query, "WVwv");
    app.category_dialog.as_mut().unwrap().name = Some(String::new());
    type_keys(&mut app);
    assert_eq!(
        app.category_dialog.as_ref().unwrap().name.as_deref(),
        Some("WVwv")
    );
}

#[test]
fn saved_actions_use_configured_keys_in_each_video_context_and_remove_only_selection() {
    let mut app = app(&["tubular"]);
    let document = "[keys]\nvideo.saved.save = 'f6'\nview.saved.browse = 'f7'\nview.collection.remove.selected = 'f8'\nview.collection.remove.bulk = 'f9'\n"
            .parse::<toml_edit::DocumentMut>().unwrap();
    app.apply_config(config::Config {
        keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
        ..Default::default()
    });
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Second","uploader_id":"@other"},{"id":"l-GaaivVJCE","title":"Missing creator"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(1));
    app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
    app.views[0].selection.select(Some(0));
    app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::NONE));
    for preview in [
        None,
        Some(PreviewMode::Info),
        Some(PreviewMode::Description),
    ] {
        app.preview = preview;
        if !app
            .video_state
            .contains(CollectionKind::Saved, "jNQXAC9IVRw")
        {
            app.key(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE));
            assert!(
                !app.video_state
                    .contains(CollectionKind::Saved, "jNQXAC9IVRw")
            );
        }
        app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
        assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
        let status = app.status.clone();
        app.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
        assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
        assert_eq!(app.preview, preview);
        assert_eq!(app.status, status);
    }
    for preview in [
        None,
        Some(PreviewMode::Info),
        Some(PreviewMode::Description),
    ] {
        app.preview = None;
        app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
        let row = app.views[app.view_index]
            .videos
            .iter()
            .position(|video| video.id == "jNQXAC9IVRw")
            .unwrap();
        app.views[app.view_index].selection.select(Some(row));
        app.preview = preview;
        assert!(matches!(
            app.current_collection(),
            Some(CollectionKind::Saved)
        ));
        app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
        assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
        app.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
        assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 1);
        assert!(
            app.video_state
                .contains(CollectionKind::Saved, "rQ_J9WH6CGk")
        );
        assert!(
            app.video_state
                .contains(CollectionKind::WatchLater, "jNQXAC9IVRw")
        );
        assert_eq!(app.preview, None);
        app.switch_view(0);
        app.views[0].selection.select(Some(0));
        app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
    }
    app.preview = None;
    app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
    app.views[0].selection.select(Some(2));
    app.key(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
    assert!(app.status.contains("channel identity"));
    assert!(
        !app.video_state
            .contains(CollectionKind::Saved, "l-GaaivVJCE")
    );
    app.views[0].selection.select(None);
    let status = app.status.clone();
    app.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
    assert_eq!(app.status, status);
    app.key(KeyEvent::new(KeyCode::F(7), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::SavedVideos(None)
    );
    assert!(app.job.is_none());
    assert!(app.key_hints.footer(Context::Normal).contains("F6/F7"));
    assert!(app.key_hints.saved_videos.contains("F8"));
    app.key(KeyEvent::new(KeyCode::Char('W'), KeyModifiers::SHIFT));
    app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::SHIFT));
    assert!(app.collection_removal.is_none());
    app.key(KeyEvent::new(KeyCode::F(9), KeyModifiers::NONE));
    assert!(app.collection_removal.is_some());
    app.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
    assert!(
        app.video_state
            .videos(CollectionKind::WatchLater)
            .is_empty()
    );
    assert_eq!(app.video_state.videos(CollectionKind::Saved).len(), 2);
    assert!(!app.video_state.is_watched("jNQXAC9IVRw"));
}

#[test]
fn saved_green_precedes_watch_later_magenta_without_changing_creator_or_selection_colors() {
    let mut app = app(&["tubular"]);
    app.config.categories.insert(
        "Tagged".into(),
        vec![config::normalize_channel("@creator").unwrap()],
    );
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Saved title","channel":"Creator","uploader_id":"@creator"},{"id":"rQ_J9WH6CGk","title":"Later title","channel":"Other","uploader_id":"@other"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    for row in 0..2 {
        app.views[0].selection.select(Some(row));
        app.save_collection(CollectionKind::WatchLater);
    }
    app.views[0].selection.select(Some(0));
    app.save_collection(CollectionKind::Saved);
    app.views[0].selection.select(None);
    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(120, 24)).unwrap();
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let buffer = terminal.backend().buffer();
    assert!(
        buffer
            .content
            .iter()
            .any(|cell| cell.symbol() == "S" && cell.fg == Color::Green)
    );
    assert!(
        buffer
            .content
            .iter()
            .any(|cell| cell.symbol() == "L" && cell.fg == Color::Magenta)
    );
    assert!(
        buffer
            .content
            .iter()
            .any(|cell| cell.symbol() == "C" && cell.fg == Color::Cyan)
    );
    app.views[0].selection.select(Some(0));
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    assert!(
        terminal
            .backend()
            .buffer()
            .content
            .iter()
            .any(|cell| cell.symbol() == "S" && cell.fg == Color::Black && cell.bg == Color::Cyan)
    );
    app.browse_collection(CollectionKind::Saved);
    app.key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
    app.switch_view(0);
    app.views[0].selection.select(None);
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    assert!(
        terminal
            .backend()
            .buffer()
            .content
            .iter()
            .any(|cell| cell.symbol() == "S" && cell.fg == Color::Magenta)
    );
}

#[test]
fn paste_targets_only_active_inputs_and_refilters_without_executing_shortcuts() {
    let mut app = app(&["tubular"]);
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    app.paste("Haru 日本語\r\ns\t\x1b[31m");
    assert_eq!(app.views[0].query, "Haru 日本語  s [31m");
    assert_eq!(app.mode, Mode::Insert);
    assert!(app.views[0].submitted_query.is_empty());
    assert!(app.job.is_none(), "paste must not submit a search");
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    app.paste("i\nq");
    assert_eq!(app.views[0].query, "Haru 日本語  s [31m");
    assert_eq!(app.mode, Mode::Normal);

    app.config.categories = [("Alpha".into(), vec![]), ("日本語".into(), vec![])].into();
    app.config.channels = [
        (
            "@Alpha".into(),
            config::normalize_channel("@Alpha").unwrap(),
        ),
        (
            "@日本語".into(),
            config::normalize_channel("@日本語").unwrap(),
        ),
    ]
    .into();
    for kind in [BrowserKind::Categories, BrowserKind::Channels] {
        app.open_browser(kind);
        app.paste("Alpha");
        assert!(app.browser.as_ref().unwrap().query.is_empty());
        app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
        app.paste("日本語");
        let browser = app.browser.as_ref().unwrap();
        assert_eq!(browser.matches, [1]);
        assert_eq!(browser.selection.selected(), Some(0));
        assert!(browser.choices[browser.matches[0]].0.contains("日本語"));
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    }

    app.category_dialog = Some(CategoryDialog::new(
        CategoryTarget::Channel {
            handle: "@a".into(),
            channel: String::new(),
        },
        "Creator".into(),
        [("Alpha".into(), true), ("日本語".into(), false)].into(),
    ));
    app.paste("i\n ");
    assert!(app.category_dialog.as_ref().unwrap().tags["Alpha"]);
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    app.paste("日本語");
    assert_eq!(app.category_dialog.as_ref().unwrap().matches, [1]);
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().tags["日本語"]);
    app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
    app.paste("New\nTag\t?");
    assert_eq!(
        app.category_dialog.as_ref().unwrap().name.as_deref(),
        Some("New Tag ?")
    );
    assert!(
        app.help_popup.is_none(),
        "pasted ? must remain literal text"
    );
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().tags["New Tag ?"]);
    assert!(
        !app.config.categories.contains_key("New Tag ?"),
        "paste must not save tags"
    );
    app.key(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::NONE));
    app.paste("n\nq");
    assert!(app.category_dialog.as_ref().unwrap().name.is_none());
    assert!(
        app.help_popup.is_some(),
        "paste must not close help or operate on its dialog"
    );
}

fn loaded_channel_views(app: &mut App) {
    let videos = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#;
    for (label, identity) in app.config.saved_channels() {
        let mut view = View::new(label, ViewSource::Channel(identity));
        view.videos = feed_fixture(videos).unwrap().videos;
        view.loaded = true;
        view.next_start = 41;
        view.selection.select(Some(1));
        app.views.push(view);
    }
}

fn browse_channel(app: &mut App, filter: &str) {
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    for c in filter.chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
}

#[test]
fn video_channel_colors_follow_category_membership_and_preserve_selection_contrast() {
    use ratatui::{Terminal, backend::TestBackend};

    let mut app = app(&["tubular"]);
    let tagged_id = "UC4QobU6STFB0P71PMvOGN5A";
    let registered_id = "UCaYhcUwRBNscFNUKTjgPFiA";
    app.config.channels.insert(
        "@mapped".into(),
        config::normalize_channel(tagged_id).unwrap(),
    );
    app.config.channels.insert(
        "@registered".into(),
        config::normalize_channel(registered_id).unwrap(),
    );
    app.config.categories.insert(
        "Favorites".into(),
        vec![
            config::normalize_channel(tagged_id).unwrap(),
            config::normalize_channel("@direct").unwrap(),
        ],
    );
    let cases = [
        ("TaggedID", Some(tagged_id), None, true),
        ("TaggedHandle", None, Some("@direct"), true),
        ("MappedHandle", None, Some("@mapped"), true),
        (
            "Registered",
            Some(registered_id),
            Some("@registered"),
            false,
        ),
        ("TaggedID", Some(registered_id), None, false),
        ("Unknown", None, None, false),
    ];
    app.views[0].videos = youtube::search_results(
        &serde_json::json!({
            "entries": cases.iter().map(|(channel, id, handle, _)| serde_json::json!({
                "id": "jNQXAC9IVRw", "title": "Video title", "channel": channel,
                "channel_id": id, "uploader_id": handle, "upload_date": "20261011",
                "duration": 3723.5
            })).collect::<Vec<_>>()
        })
        .to_string(),
    )
    .unwrap()
    .videos;
    app.views[0].selection.select(None);
    let mut terminal = Terminal::new(TestBackend::new(120, 24)).unwrap();
    for cleared in [false, true] {
        if cleared {
            app.config.categories.clear();
        }
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        let buffer = terminal.backend().buffer();
        // One tab row, three search rows, then the results border and two-line entries.
        for (index, (label, _, _, tagged)) in cases.iter().enumerate() {
            let y = 6 + 2 * index as u16;
            let row: String = (0..120).map(|x| buffer[(x, y)].symbol()).collect();
            let x = row.find(label).expect("channel label is visible") as u16;
            assert_eq!(
                buffer[(x, y)].fg,
                if *tagged && !cleared {
                    Color::Cyan
                } else {
                    Color::Reset
                },
                "{label} in row {index}, cleared={cleared}"
            );
            let title: String = (0..120).map(|x| buffer[(x, y - 1)].symbol()).collect();
            assert!(title.contains("Video title"));
            let date_x = row.find("2026-10-11").expect("date follows channel") as u16;
            assert!(row.contains(&format!("{label} · 2026-10-11")));
            assert!(
                row.contains(" · 1:02:03"),
                "duration is visible in metadata"
            );
            assert_eq!(buffer[(3, y - 1)].fg, Color::Reset, "title stays uncolored");
            assert_eq!(buffer[(date_x, y)].fg, Color::Reset, "date stays uncolored");
            assert!(
                buffer[(x, y)]
                    .modifier
                    .contains(ratatui::style::Modifier::DIM)
            );
        }
        if !cleared {
            app.views[0].selection.select(Some(0));
            terminal
                .draw(|frame| app.draw(frame, Duration::ZERO))
                .unwrap();
            let buffer = terminal.backend().buffer();
            let row: String = (0..120).map(|x| buffer[(x, 6)].symbol()).collect();
            let x = row.find("TaggedID").unwrap() as u16;
            assert_eq!(buffer[(x, 6)].fg, Color::Black);
            assert_eq!(buffer[(x, 6)].bg, Color::Cyan);
            app.views[0].selection.select(None);
        }
    }
}

#[test]
fn remapped_preview_and_input_actions_survive_key_only_config_reload() {
    use ratatui::{Terminal, backend::TestBackend};
    let mut app = app(&["tubular"]);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#,
        ).unwrap().videos;
    // Invalid IDs avoid curl; full descriptions exercise the real preview without extraction.
    for (index, id) in ["first", "second"].into_iter().enumerate() {
        app.views[0].videos[index].id = id.into();
        app.remember_description(id.into(), "A long description paragraph.\n\n".repeat(40));
    }
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(0));
    app.views[0].next_start = 41;
    let document = r#"[keys]
video.info.overview = "I"
video.info.hide = "x"
view.collection.remove.selected = []
search.edit = "f2"
input.delete.word = "ctrl+backspace"
input.delete.line = "ctrl+l"
"#
    .parse::<toml_edit::DocumentMut>()
    .unwrap();
    app.apply_config(config::Config {
        keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
        ..Default::default()
    });
    let press = |app: &mut App, code, modifiers| app.key(KeyEvent::new(code, modifiers));
    press(&mut app, KeyCode::Char('d'), KeyModifiers::NONE);
    assert_eq!(app.preview, Some(PreviewMode::Description));
    let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    press(&mut app, KeyCode::Char('j'), KeyModifiers::CONTROL);
    assert_eq!(app.description_scroll, 1);
    press(&mut app, KeyCode::Char('I'), KeyModifiers::SHIFT);
    assert_eq!(app.preview, Some(PreviewMode::Info));
    press(&mut app, KeyCode::Char('x'), KeyModifiers::NONE);
    assert_eq!(app.preview, None);
    assert!(app.description_job.is_none());
    let remap = "[keys]\nvideo.select.next = 'n'\n"
        .parse::<toml_edit::DocumentMut>()
        .unwrap();
    app.apply_config(config::Config {
        keys: keys::Bindings::from_toml(remap.get("keys")).unwrap(),
        ..Default::default()
    });
    assert_eq!(app.views[0].next_start, 41);
    assert_eq!(app.views[0].videos[0].title, "First");
    press(&mut app, KeyCode::Char('j'), KeyModifiers::NONE);
    assert_eq!(app.views[0].selection.selected(), Some(0));
    press(&mut app, KeyCode::Char('n'), KeyModifiers::NONE);
    assert_eq!(app.views[0].selection.selected(), Some(1));
    app.apply_config(config::Config {
        keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
        ..Default::default()
    });
    press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
    assert_eq!(app.mode, Mode::Normal);
    press(&mut app, KeyCode::F(2), KeyModifiers::NONE);
    for character in "red blue I d?".chars() {
        press(&mut app, KeyCode::Char(character), KeyModifiers::NONE);
    }
    assert_eq!(app.views[0].query, "red blue I d?");
    assert_eq!(app.preview, None);
    press(&mut app, KeyCode::Backspace, KeyModifiers::CONTROL);
    assert_eq!(app.views[0].query, "red blue I ");
    press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
    assert_eq!(app.views[0].query, "red blue I ");
    press(&mut app, KeyCode::Char('l'), KeyModifiers::CONTROL);
    assert_eq!(app.views[0].query, "");
    press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
    assert_eq!(app.mode, Mode::Normal);
}

#[test]
fn remapped_selector_and_tag_keys_keep_input_and_modal_navigation_separate() {
    let mut app = app(&["tubular"]);
    let document = r#"[keys]
selector.select.next = "l"
selector.edit = "f3"
selector.close = "z"
input.submit = "ctrl+e"
input.cancel = "ctrl+b"
tags.new = "f4"
tags.cancel = "z"
"#
    .parse::<toml_edit::DocumentMut>()
    .unwrap();
    app.apply_config(config::Config {
        channels: [
            ("@Alpha".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        keys: keys::Bindings::from_toml(document.get("keys")).unwrap(),
        ..Default::default()
    });
    loaded_channel_views(&mut app);
    let press = |app: &mut App, code, modifiers| app.key(KeyEvent::new(code, modifiers));
    app.open_browser(BrowserKind::Channels);
    press(&mut app, KeyCode::Char('j'), KeyModifiers::NONE);
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
    press(&mut app, KeyCode::Char('l'), KeyModifiers::NONE);
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
    press(&mut app, KeyCode::F(3), KeyModifiers::NONE);
    press(&mut app, KeyCode::Char('l'), KeyModifiers::NONE);
    assert_eq!(app.browser.as_ref().unwrap().query, "l");
    assert_eq!(app.browser.as_ref().unwrap().matches, [0]);
    press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
    press(&mut app, KeyCode::Char('j'), KeyModifiers::CONTROL);
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
    press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
    assert!(app.browser.is_some());
    press(&mut app, KeyCode::Char('e'), KeyModifiers::CONTROL);
    assert!(app.browser.is_none());
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    assert_eq!(app.views[app.view_index].next_start, 41);
    let history = app.view_history.clone();
    app.category_dialog = Some(CategoryDialog {
        name: None,
        ..CategoryDialog::new(
            CategoryTarget::Channel {
                handle: "@Beta".into(),
                channel: "beta".into(),
            },
            "@Beta".into(),
            BTreeMap::new(),
        )
    });
    press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
    assert_eq!(app.view_history, history);
    assert!(app.category_dialog.is_some());
    press(&mut app, KeyCode::F(4), KeyModifiers::NONE);
    for character in "lI?".chars() {
        press(&mut app, KeyCode::Char(character), KeyModifiers::NONE);
    }
    press(&mut app, KeyCode::Char('e'), KeyModifiers::CONTROL);
    assert_eq!(
        app.category_dialog.as_ref().unwrap().tags.get("lI?"),
        Some(&true)
    );
    press(&mut app, KeyCode::Char('z'), KeyModifiers::NONE);
    assert!(app.category_dialog.is_none());
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
}

#[test]
fn help_scrolls_without_navigating_and_closes_to_the_same_preview() {
    use ratatui::{Terminal, backend::TestBackend};
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        channels: [
            ("@Alpha".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        ..Default::default()
    });
    loaded_channel_views(&mut app);
    browse_channel(&mut app, "Alpha");
    browse_channel(&mut app, "Beta");
    let history = app.view_history.clone();
    let selected = app.views[app.view_index].selection.selected();
    let press = |app: &mut App, code| app.key(KeyEvent::new(code, KeyModifiers::NONE));
    app.views[app.view_index].has_more = true;
    app.views[app.view_index].prefetch_requested = true;
    assert!(app.can_prefetch());
    press(&mut app, KeyCode::Char('?'));
    assert!(!app.can_prefetch());
    app.preview = Some(PreviewMode::Info);
    let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    press(&mut app, KeyCode::Char('j'));
    assert_eq!(app.help_popup.as_ref().unwrap().scroll, 1);
    for code in [
        KeyCode::Enter,
        KeyCode::Tab,
        KeyCode::Char('-'),
        KeyCode::Char('+'),
    ] {
        press(&mut app, code);
    }
    assert_eq!(app.view_history, history);
    assert!(app.forward_history.is_empty());
    assert!(app.player_launch.is_none());
    assert_eq!(app.views[app.view_index].selection.selected(), selected);
    for _ in 0..100 {
        press(&mut app, KeyCode::PageDown);
    }
    let help = app.help_popup.as_ref().unwrap();
    assert_eq!(help.scroll, help.max_scroll);
    let previous_max = help.max_scroll;
    app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
    assert_eq!(app.help_popup.as_ref().unwrap().scroll, previous_max - 1);
    let mut larger = Terminal::new(TestBackend::new(120, 40)).unwrap();
    larger
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let help = app.help_popup.as_ref().unwrap();
    assert_eq!(help.scroll, help.max_scroll);
    for _ in 0..100 {
        press(&mut app, KeyCode::PageUp);
    }
    assert_eq!(app.help_popup.as_ref().unwrap().scroll, 0);
    press(&mut app, KeyCode::Esc);
    assert!(app.help_popup.is_none());
    assert_eq!(app.preview, Some(PreviewMode::Info));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    press(&mut app, KeyCode::Char('-'));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("alpha".into())
    );
    press(&mut app, KeyCode::Char('+'));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
}

#[test]
fn help_preserves_selector_state_and_question_mark_is_literal_in_every_input() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        channels: [("@Alpha".into(), "alpha".into())].into(),
        ..Default::default()
    });
    let press = |app: &mut App, code| app.key(KeyEvent::new(code, KeyModifiers::NONE));
    app.open_browser(BrowserKind::Channels);
    press(&mut app, KeyCode::Char('?'));
    assert!(app.help_popup.is_some());
    press(&mut app, KeyCode::Char('?'));
    assert!(app.help_popup.is_none());
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
    press(&mut app, KeyCode::Char('i'));
    press(&mut app, KeyCode::Char('?'));
    assert!(app.help_popup.is_none());
    assert_eq!(app.browser.as_ref().unwrap().query, "?");
    assert!(app.browser.as_ref().unwrap().matches.is_empty());
    press(&mut app, KeyCode::Esc);
    press(&mut app, KeyCode::Esc);
    press(&mut app, KeyCode::Char('i'));
    press(&mut app, KeyCode::Char('?'));
    assert!(app.help_popup.is_none());
    assert_eq!(app.views[0].query, "?");
    press(&mut app, KeyCode::Esc);
    app.category_dialog = Some(CategoryDialog {
        name: Some(String::new()),
        ..CategoryDialog::new(
            CategoryTarget::Channel {
                handle: "@Alpha".into(),
                channel: "alpha".into(),
            },
            "@Alpha".into(),
            BTreeMap::new(),
        )
    });
    press(&mut app, KeyCode::Char('?'));
    assert!(app.help_popup.is_none());
    assert_eq!(
        app.category_dialog.as_ref().unwrap().name.as_deref(),
        Some("?")
    );
    press(&mut app, KeyCode::Esc);
    press(&mut app, KeyCode::Char('?'));
    assert!(app.help_popup.is_some());
    press(&mut app, KeyCode::Esc);
    assert!(app.category_dialog.is_some());
    assert!(app.help_popup.is_none());
}

#[test]
fn plus_restores_forward_views_and_new_navigation_discards_the_forward_branch() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        channels: [
            ("@Alpha".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        ..Default::default()
    });
    loaded_channel_views(&mut app);
    for view in &mut app.views {
        view.loaded = true;
    }
    browse_channel(&mut app, "Alpha");
    browse_channel(&mut app, "Beta");
    let press = |app: &mut App, c| {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    };
    press(&mut app, '-');
    press(&mut app, '-');
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    press(&mut app, '+');
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("alpha".into())
    );
    assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
    assert_eq!(app.views[app.view_index].next_start, 41);
    app.switch_view(app.view_index); // Refocusing does not discard forward history.
    press(&mut app, '+');
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    press(&mut app, '+'); // End of history is a no-op.
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    press(&mut app, '-');
    app.switch_view(1);
    press(&mut app, '+');
    assert_eq!(app.views[app.view_index].source, ViewSource::Feed);
    app.mode = Mode::Insert;
    press(&mut app, '+');
    assert_eq!(app.views[0].query, "+");
    assert_eq!(app.views[app.view_index].source, ViewSource::Feed);
    assert!(app.job.is_none());
}

#[test]
fn forward_navigation_skips_unsubscribed_views() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        channels: [
            ("@Alpha".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        ..Default::default()
    });
    loaded_channel_views(&mut app);
    app.views[0].loaded = true;
    browse_channel(&mut app, "Alpha");
    browse_channel(&mut app, "Beta");
    app.back_view();
    app.back_view();
    app.apply_config(config::Config {
        channels: [("@Beta".into(), "beta".into())].into(),
        ..Default::default()
    });
    app.key(KeyEvent::new(KeyCode::Char('+'), KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    assert_eq!(app.temporary_view, Some(ViewSource::Channel("beta".into())));
    assert!(app.job.is_none());
}

#[test]
fn minus_restores_view_history_without_consuming_modal_escape() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        categories: [("Category".into(), Vec::new())].into(),
        channels: [
            ("@Alpha".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        ..Default::default()
    });
    loaded_channel_views(&mut app);
    for view in &mut app.views {
        view.loaded = true;
    }
    app.switch_view(2);
    browse_channel(&mut app, "Alpha");
    browse_channel(&mut app, "Beta");
    app.switch_view(app.view_index); // Refocusing must not add a history entry.
    app.preview = Some(PreviewMode::Info);
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert!(app.preview.is_none());
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    app.mode = Mode::Insert;
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(app.views[0].query, "-");
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    app.open_browser(BrowserKind::Channels);
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert!(app.browser.is_none());
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("beta".into())
    );
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("alpha".into())
    );
    assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
    assert_eq!(app.views[app.view_index].next_start, 41);
    assert_eq!(
        app.temporary_view,
        Some(ViewSource::Channel("alpha".into()))
    );
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Category".into())
    );
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    assert!(app.job.is_none());
}

#[test]
fn back_history_uses_source_identity_after_config_reorders_or_removes_views() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        categories: [("Earlier".into(), Vec::new()), ("Keep".into(), Vec::new())].into(),
        channels: [("@Alpha".into(), "alpha".into())].into(),
        ..Default::default()
    });
    loaded_channel_views(&mut app);
    for view in &mut app.views {
        view.loaded = true;
    }
    app.switch_view(3); // Keep initially follows Earlier.
    browse_channel(&mut app, "Alpha");
    app.apply_config(config::Config {
        categories: [("Keep".into(), Vec::new())].into(),
        channels: [("@Alpha".into(), "alpha".into())].into(),
        ..Default::default()
    });
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Keep".into())
    );
    browse_channel(&mut app, "Alpha");
    app.apply_config(config::Config {
        channels: [("@Alpha".into(), "alpha".into())].into(),
        ..Default::default()
    });
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    assert!(app.job.is_none());
}

#[test]
fn video_channel_shortcut_reuses_saved_views_and_requires_valid_identity() {
    let mut app = app(&["tubular"]);
    let identity = "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A";
    app.apply_config(config::Config {
        channels: [("@Saved".into(), identity.into())].into(),
        ..Default::default()
    });
    loaded_channel_views(&mut app);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Search result","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@Saved"}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(0));
    app.preview = Some(PreviewMode::Description);
    let press = |app: &mut App| {
        app.key(KeyEvent::new(KeyCode::Char('U'), KeyModifiers::SHIFT));
    };
    press(&mut app);
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel(identity.into())
    );
    assert_eq!(app.views[app.view_index].selection.selected(), Some(1));
    assert_eq!(app.views[app.view_index].next_start, 41);
    assert_eq!(app.views[app.view_index].videos[1].title, "Second");
    assert!(app.preview.is_none());
    assert!(app.job.is_none());
    let count = app.views.len();
    press(&mut app);
    assert_eq!(app.views.len(), count);
    app.switch_view(0);
    app.views[0].videos[0].channel_id = None;
    press(&mut app); // A handle-only row resolves through the saved mapping.
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel(identity.into())
    );
    app.switch_view(0);
    app.views[0].videos[0].uploader_id = Some("@invalid/handle".into());
    press(&mut app);
    assert_eq!(app.view_index, 0);
    assert_eq!(app.views.len(), count);
    assert!(app.job.is_none());
    app.views[0].videos[0].uploader_id = None;
    press(&mut app);
    assert_eq!(app.view_index, 0);
    app.mode = Mode::Insert;
    press(&mut app);
    assert_eq!(app.views[0].query, "U");
    assert_eq!(app.view_index, 0);
}

#[test]
fn unsaved_video_channels_survive_config_changes_without_subscribing() {
    let mut app = app(&["tubular"]);
    let identity = "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A";
    let mut channel = View::new("@Unsaved".into(), ViewSource::Channel(identity.into()));
    channel.loaded = true;
    app.views.push(channel);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Search result","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@Unsaved"}]}"#,
        ).unwrap().videos;
    app.views[0].selection.select(Some(0));
    app.views[0].loaded = true;
    app.key(KeyEvent::new(KeyCode::Char('U'), KeyModifiers::SHIFT));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel(identity.into())
    );
    assert!(app.config.subscriptions().is_empty());
    app.apply_config(config::Config {
        categories: [("Unrelated".into(), Vec::new())].into(),
        ..Default::default()
    });
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel(identity.into())
    );
    assert!(app.views[app.view_index].loaded);
    assert_eq!(
        app.temporary_view,
        Some(ViewSource::Channel(identity.into()))
    );
    app.apply_config(config::Config {
        channels: [("@Registered".into(), identity.into())].into(),
        ..Default::default()
    });
    assert_eq!(app.views[app.view_index].name, "@Registered");
    assert!(app.views[app.view_index].loaded);
    app.apply_config(config::Config::default());
    assert_eq!(app.view_index, 0);
    assert!(
        app.views
            .iter()
            .all(|view| view.source != ViewSource::Channel(identity.into()))
    );
}

#[test]
fn channels_filter_in_both_modes_without_pinning_or_running_modal_shortcuts() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        channels: [
            ("@jazz".into(), "jazz identity".into()),
            ("@jokes".into(), "jokes identity".into()),
        ]
        .into(),
        ..config::Config::default()
    });
    loaded_channel_views(&mut app);
    app.views[0].query = "untouched".into();
    app.views[0].loaded = true;
    app.views[0].has_more = true;
    app.preview = Some(PreviewMode::Info);
    assert!(!app.can_prefetch());
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
    assert!(app.preview.is_none());
    assert!(!app.can_prefetch());
    app.key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));
    assert!(app.config.pinned_categories.is_empty());
    assert!(app.browser.as_ref().unwrap().error.is_none());
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
    app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    for c in "jkp".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    assert_eq!(app.browser.as_ref().unwrap().query, "jkp");
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), None);
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    assert_eq!(app.view_index, 0);
    assert!(app.browser.is_some());
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
    app.key(KeyEvent::new(KeyCode::Char('J'), KeyModifiers::NONE));
    for (code, modifiers, row) in [
        (KeyCode::Char('j'), KeyModifiers::CONTROL, 1),
        (KeyCode::Char('k'), KeyModifiers::CONTROL, 0),
        (KeyCode::Down, KeyModifiers::NONE, 1),
        (KeyCode::Up, KeyModifiers::NONE, 0),
    ] {
        app.key(KeyEvent::new(code, modifiers));
        assert_eq!(
            app.browser.as_ref().unwrap().selection.selected(),
            Some(row)
        );
    }
    assert_eq!(app.browser.as_ref().unwrap().query, "J");
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(app.browser.as_ref().unwrap().mode, Mode::Normal);
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Channel("jazz identity".into())
    );
    assert_eq!(
        app.views[app.view_index].source.channels(
            &app.config,
            &app.feed_channels,
            &app.views[app.view_index].group_channels
        ),
        ["jazz identity"]
    );
    assert_eq!(app.views[0].query, "untouched");
    assert!(app.browser.is_none());
    assert!(app.job.is_none());
}

#[test]
fn channel_and_category_share_temporary_tab_and_cached_history() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: [
            ("@Alpha".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        categories: [
            ("@Alpha".into(), vec!["beta".into()]),
            ("Temporary".into(), vec![]),
        ]
        .into(),
        pinned_categories: vec!["@Alpha".into()],
    });
    loaded_channel_views(&mut app);
    app.views[2].loaded = true;
    app.switch_view(3);
    browse_channel(&mut app, "Alpha");
    let alpha_source = ViewSource::Channel("alpha".into());
    assert_eq!(app.views[app.view_index].source, alpha_source);
    assert_eq!(
        app.views[app.view_index].source.channels(
            &app.config,
            &app.feed_channels,
            &app.views[app.view_index].group_channels
        ),
        ["alpha"]
    );
    app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
    assert!(app.category_dialog.is_none());
    assert_eq!(app.views[app.view_index].source, alpha_source);
    browse_channel(&mut app, "Beta");
    let visible: Vec<_> = app
        .visible_views()
        .map(|(_, view)| view.source.clone())
        .collect();
    assert_eq!(
        visible,
        [
            ViewSource::Search,
            ViewSource::Feed,
            ViewSource::Category("@Alpha".into()),
            ViewSource::Channel("beta".into())
        ]
    );
    assert!(app.views.iter().any(|view| view.source == alpha_source));
    browse_channel(&mut app, "Alpha");
    let view = &app.views[app.view_index];
    assert_eq!(view.source, alpha_source);
    assert_eq!(view.selection.selected(), Some(1));
    assert_eq!(view.next_start, 41);
    assert_eq!(view.videos.len(), 2);
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(
        app.views[app.view_index].source,
        ViewSource::Category("Temporary".into())
    );
    assert!(
        !app.visible_views()
            .any(|(_, view)| matches!(view.source, ViewSource::Channel(_)))
    );
    browse_channel(&mut app, "Alpha");
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
    assert_eq!(app.views[app.view_index].source, alpha_source);
    assert!(app.job.is_none());
}

#[test]
fn channel_refresh_matches_identities_relabels_caches_and_removes_unsubscribed_views() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        channels: [
            ("@Alpha".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        categories: [("@Alpha".into(), vec!["beta".into()])].into(),
        ..config::Config::default()
    });
    loaded_channel_views(&mut app);
    browse_channel(&mut app, "Alpha");
    app.views[app.view_index].has_more = true;
    app.views[app.view_index].feed_requests =
        app.views[app.view_index].feed_cursor.plan(1).unwrap();
    app.views[app.view_index].prefetch_requested = true;
    app.views[app.view_index].page_error = Some("kept".into());
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: [
            ("@Renamed".into(), "alpha".into()),
            ("@Beta".into(), "beta".into()),
        ]
        .into(),
        categories: [
            ("New tag".into(), vec!["alpha".into()]),
            ("@Alpha".into(), vec![]),
        ]
        .into(),
        pinned_categories: vec!["@Alpha".into()],
    });
    let view = &app.views[app.view_index];
    assert_eq!(view.source, ViewSource::Channel("alpha".into()));
    assert_eq!(view.name, "@Renamed");
    assert_eq!(view.title, " @Renamed ");
    assert!(view.loaded && view.has_more);
    assert_eq!(view.next_start, 41);
    assert_eq!(view.selection.selected(), Some(1));
    assert_eq!(view.feed_requests.len(), 1);
    assert!(view.prefetch_requested);
    assert_eq!(view.page_error.as_deref(), Some("kept"));
    let beta = app
        .views
        .iter()
        .find(|view| view.source == ViewSource::Channel("beta".into()))
        .unwrap();
    assert_eq!(beta.next_start, 41);
    assert_eq!(beta.selection.selected(), Some(1));
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: [("@Beta".into(), "beta".into())].into(),
        categories: [("@Alpha".into(), vec!["beta".into()])].into(),
        pinned_categories: vec!["@Alpha".into()],
    });
    assert_eq!(app.views[app.view_index].source, ViewSource::Search);
    assert!(app.temporary_view.is_none());
    assert!(
        !app.views
            .iter()
            .any(|view| view.source == ViewSource::Channel("alpha".into()))
    );
    browse_channel(&mut app, "Beta");
    assert_eq!(app.views[app.view_index].next_start, 41);
    app.apply_config(config::Config::default());
    assert_eq!(app.view_index, 0);
    assert_eq!(app.views.len(), 2);
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
    for code in [KeyCode::Down, KeyCode::Enter, KeyCode::Char('p')] {
        app.key(KeyEvent::new(code, KeyModifiers::NONE));
    }
    assert!(app.browser.as_ref().unwrap().choices.is_empty());
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), None);
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert!(app.browser.is_none());
    assert!(app.job.is_none());
}

#[test]
fn channel_labels_cannot_alias_builtin_or_category_sources() {
    let mut app = app(&["tubular"]);
    // Raw fixture identities exercise equal labels without invoking an extractor.
    app.apply_config(config::Config {
        categories: [
            ("Feed".into(), vec!["Feed".into(), "Search".into()]),
            ("Search".into(), vec![]),
        ]
        .into(),
        pinned_categories: vec!["Feed".into(), "Search".into()],
        ..config::Config::default()
    });
    loaded_channel_views(&mut app);
    for label in ["Feed", "Search"] {
        browse_channel(&mut app, label);
        assert_eq!(
            app.views[app.view_index].source,
            ViewSource::Channel(label.into())
        );
        assert_eq!(
            app.views[app.view_index].source.channels(
                &app.config,
                &app.feed_channels,
                &app.views[app.view_index].group_channels
            ),
            [label]
        );
        assert_eq!(
            app.visible_views()
                .filter(|(_, view)| view.name == label)
                .count(),
            3
        );
        app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
        assert!(app.category_dialog.is_none());
    }
    assert!(app.job.is_none());
}

#[test]
fn channel_selector_renders_plain_labels_modes_empty_states_and_filter_cursor() {
    use ratatui::{Terminal, backend::TestBackend};
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        channels: [("@Alpha".into(), "alpha".into())].into(),
        ..config::Config::default()
    });
    let mut terminal = Terminal::new(TestBackend::new(180, 40)).unwrap();
    let text = |terminal: &Terminal<TestBackend>| -> String {
        terminal
            .backend()
            .buffer()
            .content
            .iter()
            .map(|cell| cell.symbol())
            .collect()
    };
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let rendered = text(&terminal);
    assert!(rendered.contains("@Alpha"));
    assert!(!rendered.contains("[p]") && !rendered.contains("[ ]"));
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('z'), KeyModifiers::NONE));
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let popup = preview_area(Rect::new(0, 0, 180, 40));
    assert_eq!(
        terminal.get_cursor_position().unwrap(),
        (popup.x + 3, popup.y + 2).into()
    );
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    app.apply_config(config::Config::default());
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    assert!(app.job.is_none());
}
#[test]
fn filtered_tagging_saves_visible_changes_without_losing_hidden_memberships() {
    use ratatui::{Terminal, backend::TestBackend};

    for bulk in [false, true] {
        let path = std::env::temp_dir().join(format!(
            "tubular-filtered-tags-{}-{bulk}.toml",
            std::process::id()
        ));
        let original = "[channels]\n'@a' = 'UC4QobU6STFB0P71PMvOGN5A'\n'@b' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n[categories]\nAlpha = ['@a', '@b']\nGamma = []\nZebra = ['@a', '@b']\n";
        std::fs::write(&path, original).unwrap();
        let mut app = App::new(
            Options::parse_from(["tubular"]),
            path.clone(),
            config::load(&path).unwrap(),
        );
        app.views[0].videos = youtube::search_results(
                r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Creator video","channel":"Creator","channel_id":"UC4QobU6STFB0P71PMvOGN5A","uploader_id":"@a"}]}"#
            ).unwrap().videos;
        app.views[0].selection.select(Some(0));
        if bulk {
            app.view_index = app
                .views
                .iter()
                .position(|view| view.name == "Alpha")
                .unwrap();
        }
        app.views[app.view_index].loaded = true;
        let press = |app: &mut App, code, modifiers| {
            app.key(KeyEvent::new(code, modifiers));
        };
        press(
            &mut app,
            KeyCode::Char(if bulk { 'S' } else { 's' }),
            KeyModifiers::NONE,
        );
        press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
        for c in "missing".chars() {
            press(&mut app, KeyCode::Char(c), KeyModifiers::NONE);
        }
        let mut terminal = Terminal::new(TestBackend::new(120, 30)).unwrap();
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        let text: String = terminal
            .backend()
            .buffer()
            .content
            .iter()
            .map(|cell| cell.symbol())
            .collect();
        assert!(text.contains("No matching tags."));
        press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
        press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
        press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
        press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
        for c in "GA".chars() {
            press(&mut app, KeyCode::Char(c), KeyModifiers::SHIFT);
        }
        press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
        assert!(app.category_dialog.is_some(), "filter Enter must not save");
        assert_eq!(std::fs::read_to_string(&path).unwrap(), original);
        press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        let text: String = terminal
            .backend()
            .buffer()
            .content
            .iter()
            .map(|cell| cell.symbol())
            .collect();
        assert!(text.contains("[x] Gamma"));
        assert!(!text.contains("[x] Alpha") && !text.contains("[x] Zebra"));
        press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
        assert!(app.category_dialog.is_none());
        let saved = config::load(&path).unwrap();
        let a = config::normalize_channel("UC4QobU6STFB0P71PMvOGN5A").unwrap();
        let b = config::normalize_channel("UCaYhcUwRBNscFNUKTjgPFiA").unwrap();
        assert_eq!(saved.categories["Alpha"], [a.clone(), b.clone()]);
        assert_eq!(saved.categories["Zebra"], [a.clone(), b.clone()]);
        assert_eq!(
            saved.categories["Gamma"],
            if bulk { vec![a, b] } else { vec![a] }
        );
        std::fs::remove_file(path).unwrap();
    }
}

#[test]
fn tag_filter_preserves_selection_and_stages_new_tags_outside_the_filter() {
    let mut app = app(&["tubular"]);
    app.category_dialog = Some(CategoryDialog::new(
        CategoryTarget::Channel {
            handle: "@a".into(),
            channel: String::new(),
        },
        "Creator".into(),
        [
            ("Alpha".into(), false),
            ("Gamma".into(), true),
            ("Zebra".into(), false),
        ]
        .into(),
    ));
    let press = |app: &mut App, code, modifiers| {
        app.key(KeyEvent::new(code, modifiers));
    };
    press(&mut app, KeyCode::Char('j'), KeyModifiers::NONE);
    press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
    press(&mut app, KeyCode::Char('a'), KeyModifiers::NONE);
    press(&mut app, KeyCode::Char('j'), KeyModifiers::CONTROL);
    press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
    press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
    assert!(app.category_dialog.as_ref().unwrap().tags["Zebra"]);
    assert!(!app.category_dialog.as_ref().unwrap().tags["Alpha"]);
    press(&mut app, KeyCode::Char('i'), KeyModifiers::NONE);
    press(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL);
    for c in "gamma".chars() {
        press(&mut app, KeyCode::Char(c), KeyModifiers::NONE);
    }
    press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
    press(&mut app, KeyCode::Char('n'), KeyModifiers::NONE);
    for c in "New".chars() {
        press(&mut app, KeyCode::Char(c), KeyModifiers::NONE);
    }
    press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
    let dialog = app.category_dialog.as_ref().unwrap();
    assert!(dialog.tags["New"]);
    assert!(dialog.query.is_empty(), "new tag must be visible");
    press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
    assert!(
        !app.category_dialog.as_ref().unwrap().tags["New"],
        "new tag is selected"
    );
    press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
    assert!(app.category_dialog.is_none());
    assert!(
        app.config.categories.is_empty(),
        "cancel discards staged changes"
    );
}

#[test]
fn bulk_picker_uses_all_saved_channels_and_commits_or_cancels_the_whole_group() {
    let path =
        std::env::temp_dir().join(format!("tubular-bulk-picker-{}.toml", std::process::id()));
    let original = "[settings]\npinned_categories = ['Source']\n[channels]\n'@a' = 'UC4QobU6STFB0P71PMvOGN5A'\n'@b' = 'UCaYhcUwRBNscFNUKTjgPFiA'\n'@other' = 'UCBR8-60-B28hp2BmDPdntcQ'\n[categories]\nEmpty = []\nMixed = ['@a', '@other']\nShared = ['@a', '@b', '@other']\nSource = ['@a', '@b']\n";
    std::fs::write(&path, original).unwrap();
    let mut app = App::new(
        Options::parse_from(["tubular"]),
        path.clone(),
        config::load(&path).unwrap(),
    );
    loaded_channel_views(&mut app);
    app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
    assert!(app.category_dialog.is_none());
    app.view_index = app
        .views
        .iter()
        .position(|view| view.name == "Source")
        .unwrap();
    app.views[app.view_index].loaded = true;
    app.views[1].loaded = true;
    app.views[1].next_start = 41;
    let subscriptions = app.feed_channels.clone();
    app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
    let dialog = app.category_dialog.as_ref().unwrap();
    assert!(dialog.tags["Shared"] && dialog.tags["Source"]);
    assert!(!dialog.tags["Mixed"] && !dialog.tags["Empty"]);
    assert!(
        matches!(&dialog.target, CategoryTarget::Category { channels, .. } if channels.len() == 2)
    );
    assert!(app.views[app.view_index].videos.is_empty());
    app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
    for c in "Staged".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(std::fs::read_to_string(&path).unwrap(), original);
    assert!(!app.config.categories.contains_key("Staged"));
    app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.category_dialog.is_none());
    let saved = config::load(&path).unwrap();
    assert!(saved.categories["Source"].is_empty());
    assert_eq!(
        saved.categories["Mixed"],
        ["https://www.youtube.com/channel/UCBR8-60-B28hp2BmDPdntcQ"]
    );
    assert_eq!(saved.categories["Shared"].len(), 3);
    assert_eq!(saved.pinned_categories, ["Source"]);
    assert_eq!(app.feed_channels, subscriptions);
    assert!(app.views[1].loaded);
    assert_eq!(app.views[1].next_start, 41);
    browse_channel(&mut app, "@a");
    let channel_source = app.views[app.view_index].source.clone();
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    let channel = &app.views[app.view_index];
    assert_eq!(channel.source, channel_source);
    assert!(channel.loaded);
    assert_eq!(channel.videos.len(), 2);
    assert_eq!(channel.selection.selected(), Some(1));
    assert_eq!(channel.next_start, 41);
    assert!(app.job.is_none());
    app.key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::SHIFT));
    assert!(app.category_dialog.is_none());
    std::fs::remove_file(path).unwrap();
}

#[test]
fn filtering_preserves_selected_categories_and_browses_the_filtered_row() {
    let mut app = app(&["tubular"]);
    app.views[0].query = "main search untouched".into();
    app.apply_config(config::Config {
        categories: [
            ("Alpha".into(), vec![]),
            ("Japanese immersion".into(), vec![]),
            ("Japanese news".into(), vec![]),
        ]
        .into(),
        ..config::Config::default()
    });
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    for c in "JAPANESE".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
    for c in " news".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(app.browser.as_ref().unwrap().mode, Mode::Normal);
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].name, "Japanese news");
    assert_eq!(app.views[0].query, "main search untouched");
    assert!(app.browser.is_none());
}

#[test]
fn insert_filter_types_jk_handles_empty_matches_and_navigates_without_editing() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        categories: [
            ("Alpha".into(), vec![]),
            ("Jazz".into(), vec![]),
            ("Jokes".into(), vec![]),
            ("日本語だけで".into(), vec![]),
        ]
        .into(),
        ..config::Config::default()
    });
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    for c in "jk".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    assert!(app.browser.as_ref().unwrap().selection.selected().is_none());
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.browser.is_some());
    assert_eq!(app.view_index, 0);
    app.key(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
    for (code, modifiers, row) in [
        (KeyCode::Char('j'), KeyModifiers::CONTROL, 1),
        (KeyCode::Char('k'), KeyModifiers::CONTROL, 0),
        (KeyCode::Down, KeyModifiers::NONE, 1),
        (KeyCode::Up, KeyModifiers::NONE, 0),
    ] {
        app.key(KeyEvent::new(code, modifiers));
        assert_eq!(
            app.browser.as_ref().unwrap().selection.selected(),
            Some(row)
        );
    }
    assert_eq!(app.browser.as_ref().unwrap().query, "j");
    app.key(KeyEvent::new(KeyCode::Char('w'), KeyModifiers::CONTROL));
    for c in "日本".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].name, "日本語だけで");
    assert_eq!(app.mode, Mode::Normal);
}

#[test]
fn category_browser_replaces_the_temporary_tab_and_cycles_only_visible_views() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        categories: [
            ("Alpha".into(), vec![]),
            ("Beta".into(), vec![]),
            ("Gamma".into(), vec![]),
        ]
        .into(),
        ..config::Config::default()
    });
    let visible = |app: &App| {
        app.visible_views()
            .map(|(_, view)| view.name.clone())
            .collect::<Vec<_>>()
    };
    assert_eq!(visible(&app), ["Search", "Feed"]);
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    assert_eq!(app.view_index, 0);
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(app.views[app.view_index].name, "Beta");
    assert_eq!(visible(&app), ["Search", "Feed", "Beta"]);
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(visible(&app), ["Search", "Feed", "Gamma"]);
    app.apply_config(config::Config {
        categories: app.config.categories.clone(),
        pinned_categories: vec!["Beta".into()],
        ..config::Config::default()
    });
    assert_eq!(visible(&app), ["Search", "Feed", "Beta", "Gamma"]);
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    assert_eq!(app.view_index, 0);
    app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
    assert_eq!(app.views[app.view_index].name, "Gamma");
    app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
    assert_eq!(app.views[app.view_index].name, "Beta");
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(visible(&app), ["Search", "Feed", "Beta"]);
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(visible(&app), ["Search", "Feed", "Beta"]);
    assert!(app.browser.is_none());
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    assert!(app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)));
}

#[test]
fn categories_named_search_or_feed_are_distinct_from_permanent_views() {
    let mut app = app(&["tubular"]);
    app.apply_config(config::Config {
        categories: [
            ("Alpha".into(), vec![]),
            ("Feed".into(), vec![]),
            ("Search".into(), vec![]),
        ]
        .into(),
        ..config::Config::default()
    });
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(0));
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(app.view_index, 3);
    assert_eq!(app.views[app.view_index].name, "Feed");
    app.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
    assert_eq!(app.browser.as_ref().unwrap().selection.selected(), Some(1));
}

#[test]
fn descriptions_are_shared_across_views_and_evict_least_recently_used_entries() {
    let mut app = app(&["tubular"]);
    let output = r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Shared video"}]}"#;
    for view in &mut app.views {
        view.videos = youtube::search_results(output).unwrap().videos;
        view.selection.select(Some(0));
        view.loaded = true;
    }
    app.remember_description("jNQXAC9IVRw".into(), "Shared full description".into());
    for index in 1..DESCRIPTION_CACHE_SIZE {
        app.remember_description(format!("video{index:06}"), format!("Description {index}"));
    }
    app.switch_view(1);
    app.load_description(); // A hit in Feed promotes the Search video's description.
    assert!(app.description_job.is_none());
    app.remember_description("new00000000".into(), "New description".into());
    assert_eq!(
        cached_description(&app.descriptions, "jNQXAC9IVRw"),
        Some("Shared full description")
    );
    assert_eq!(cached_description(&app.descriptions, "video000001"), None);
    assert_eq!(
        cached_description(&app.descriptions, "video000002"),
        Some("Description 2")
    );
    // Updating an existing entry, including a known empty description, must not evict another.
    app.remember_description("jNQXAC9IVRw".into(), String::new());
    app.load_description();
    assert!(app.description_job.is_none());
    assert_eq!(
        cached_description(&app.descriptions, "jNQXAC9IVRw"),
        Some("")
    );
    assert_eq!(
        cached_description(&app.descriptions, "video000002"),
        Some("Description 2")
    );
}

#[test]
fn thumbnail_ellipsis_marks_only_hidden_content_and_preserves_wide_characters() {
    use ratatui::{Terminal, backend::TestBackend, style::Modifier};

    let mut app = app(&["tubular"]);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Heading","channel":"Creator","upload_date":"20050423"}]}"#,
        ).unwrap().videos;
    app.views[0].selection.select(Some(0));
    app.preview = Some(PreviewMode::Info);
    for (last_line, hidden) in [
        ("line", false),
        ("line", true),
        ("abcdefghijklmnopqrs", true),
        ("a界界界界界界界界界", true),
        ("", true),
    ] {
        app.remember_description(
            "jNQXAC9IVRw".into(),
            format!(
                "{}{last_line}{}",
                "line\n".repeat(6),
                if hidden { "\nhidden content" } else { "" },
            ),
        );
        let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        let buffer = terminal.backend().buffer();
        let popup = preview_area(buffer.area);
        let text_x = (popup.x + 1..popup.right() - 1)
            .find(|&x| {
                let cell = &buffer[(x, popup.y + 1)];
                cell.symbol() == "H" && cell.modifier.contains(Modifier::BOLD)
            })
            .expect("title is visible");
        let row: String = (text_x..popup.right() - 3)
            .map(|x| buffer[(x, popup.bottom() - 2)].symbol())
            .collect();
        if hidden {
            assert!(row.trim_end().ends_with('…'), "{row}");
            if last_line.starts_with("a界") {
                assert!(row.starts_with("a界"));
                for x in text_x..popup.right() - 3 {
                    if buffer[(x, popup.bottom() - 2)].symbol() == "界" {
                        assert_eq!(buffer[(x + 1, popup.bottom() - 2)].symbol(), " ");
                    }
                }
            }
        } else {
            assert_eq!(row.trim_end(), "line");
        }
    }
}

#[test]
fn thumbnail_text_has_contrast_a_right_gutter_and_a_clipped_excerpt() {
    use ratatui::{Terminal, backend::TestBackend, style::Modifier};

    let mut app = app(&["tubular"]);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First second third fourth fifth","channel":"Creator","upload_date":"20050423"}]}"#,
        ).unwrap().videos;
    app.remember_description(
        "jNQXAC9IVRw".into(),
        format!("{}CLIPPED SENTINEL", "Excerpt line\n".repeat(30)),
    );
    app.views[0].selection.select(Some(0));
    app.preview = Some(PreviewMode::Info);
    for (width, height) in [(80, 24), (120, 40), (20, 10)] {
        let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        let buffer = terminal.backend().buffer();
        let popup = preview_area(Rect::new(0, 0, width, height));
        let mut excerpt_rows = Vec::new();
        for y in popup.y + 1..popup.bottom() - 1 {
            for x in popup.right() - 3..popup.right() - 1 {
                assert_eq!(buffer.cell((x, y)).unwrap().symbol(), " ");
            }
            let row: String = (popup.x + popup.width / 2..popup.right() - 3)
                .map(|x| buffer.cell((x, y)).unwrap().symbol())
                .collect();
            assert!(!row.contains("CLIPPED SENTINEL"));
            if row.contains("Excerpt line") {
                excerpt_rows.push(y);
            }
        }
        if width == 20 {
            assert!(excerpt_rows.is_empty()); // Heading takes all available height.
            continue;
        }
        let text_x = (popup.x + 1..popup.right() - 1)
            .find(|&x| {
                let cell = &buffer[(x, popup.y + 1)];
                cell.symbol() == "F" && cell.modifier.contains(Modifier::BOLD)
            })
            .expect("title is visible");
        let title = &buffer[(text_x, popup.y + 1)];
        assert!(title.modifier.contains(Modifier::BOLD));
        assert!(!title.modifier.contains(Modifier::DIM));
        let excerpt_y = *excerpt_rows
            .last()
            .expect("description fills remaining space");
        assert_eq!(excerpt_y, popup.bottom() - 2);
        let excerpt = &buffer[(text_x, excerpt_y)];
        assert!(!excerpt.modifier.contains(Modifier::DIM));
        assert!(!excerpt.modifier.contains(Modifier::BOLD));
    }
}

#[test]
fn view_tabs_wrap_whole_labels_and_keep_the_selected_row_visible() {
    use ratatui::{Terminal, backend::TestBackend};

    let mut app = app(&["tubular"]);
    app.views = ["Search", "Feed", "Language immersion", "日本語だけ", "中文"]
        .into_iter()
        .enumerate()
        .map(|(index, name)| {
            View::new(
                name.into(),
                match index {
                    0 => ViewSource::Search,
                    1 => ViewSource::Feed,
                    _ => ViewSource::Category(name.into()),
                },
            )
        })
        .collect();
    app.config.pinned_categories = app
        .views
        .iter()
        .skip(2)
        .map(|view| view.name.clone())
        .collect();
    app.view_index = 4;
    app.mode = Mode::Insert;
    for (width, height) in [(30, 20), (56, 20), (55, 20), (9, 20), (30, 12)] {
        let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        let tab_height = terminal.get_cursor_position().unwrap().y - 1;
        let buffer = terminal.backend().buffer();
        let locate = |symbol: &str| {
            (0..tab_height)
                .flat_map(|y| (0..width).map(move |x| (x, y)))
                .find(|&position| buffer.cell(position).unwrap().symbol() == symbol)
        };
        let chinese = locate("中").expect("selected category remains visible");
        assert_eq!(buffer.cell(chinese).unwrap().fg, Color::Cyan);
        assert_eq!(
            buffer.cell((chinese.0 + 2, chinese.1)).unwrap().symbol(),
            "文"
        );
        if width >= 16 {
            let japanese = locate("日").expect("neighboring category remains visible");
            for (offset, character) in "日本語だけ".chars().enumerate() {
                assert_eq!(
                    buffer
                        .cell((japanese.0 + offset as u16 * 2, japanese.1))
                        .unwrap()
                        .symbol(),
                    character.to_string(),
                    "category label must not split across rows"
                );
            }
            assert_ne!(buffer.cell(japanese).unwrap().fg, Color::Cyan);
        }
        if width >= 24 {
            assert!(
                (0..tab_height).any(|y| {
                    (0..width)
                        .map(|x| buffer.cell((x, y)).unwrap().symbol())
                        .collect::<String>()
                        .contains("Language immersion")
                }),
                "whole category label must fit after wrapping"
            );
        }
    }
}

#[test]
fn search_pages_preserve_relevance_and_selection() {
    let mut view = View::new("Search".into(), ViewSource::Search);
    let mut first = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First","timestamp":100},{"id":"rQ_J9WH6CGk","title":"Second","timestamp":200}]}"#,
        )
        .unwrap();
    first.has_more = true;
    view.accept_page(first, false).unwrap();
    view.selection.select(Some(1));
    let mut next = youtube::search_results(
            r#"{"entries":[{"id":"rQ_J9WH6CGk","title":"Duplicate"},{"id":"l-GaaivVJCE","title":"Relevant","timestamp":50},{"id":"l-GaaivVJCE","title":"Repeated"},{"id":"aaaaaaaaaaa","title":"Later","timestamp":300}]}"#,
        )
        .unwrap();
    next.has_more = true;
    view.accept_page(next, false).unwrap();
    assert_eq!(
        view.videos
            .iter()
            .map(|video| video.id.as_str())
            .collect::<Vec<_>>(),
        ["jNQXAC9IVRw", "rQ_J9WH6CGk", "l-GaaivVJCE", "aaaaaaaaaaa"]
    );
    assert_eq!(view.videos[1].title, "Second");
    assert_eq!(view.selection.selected(), Some(1));
    assert_eq!(view.next_start, PAGE_SIZE * 2 + 1);
    assert!(view.has_more);
}

#[test]
fn many_channel_feed_consumes_only_sixty_requested_rows() {
    let mut app = app(&["tubular"]);
    app.view_index = 1;
    app.feed_channels = (0..75)
        .map(|index| format!("https://www.youtube.com/@creator{index}"))
        .collect();
    let view = &mut app.views[1];
    view.feed_requests = view.feed_cursor.plan(app.feed_channels.len()).unwrap();
    assert_eq!(
        view.feed_requests
            .iter()
            .map(|request| request.count)
            .sum::<usize>(),
        PAGE_SIZE
    );
    assert_eq!(view.feed_requests.len(), PAGE_SIZE);
    let output = view
        .feed_requests
        .iter()
        .map(|request| {
            serde_json::json!({"entries":[{
                "id":format!("channel{:04}", request.channel),
                "title":"Upload",
                "timestamp":request.channel,
            }]})
            .to_string()
        })
        .collect::<Vec<_>>()
        .join("\n");
    app.finish_page(Ok(output));
    assert_eq!(app.views[1].videos.len(), PAGE_SIZE);
    assert!(app.views[1].has_more);
    assert!(!app.can_prefetch());
    let next = app.views[1]
        .feed_cursor
        .plan(app.feed_channels.len())
        .unwrap();
    assert!(
        next.iter()
            .any(|request| request.channel >= PAGE_SIZE && request.start == 1)
    );
    assert_eq!(
        next.iter().map(|request| request.count).sum::<usize>(),
        PAGE_SIZE
    );
    app.views[1].feed_requests = next.clone();
    app.views[1].prefetch_requested = true;
    app.finish_page(Ok(r#"{"entries":[]}"#.into()));
    assert!(app.views[1].page_error.is_some());
    assert_eq!(app.views[1].videos.len(), PAGE_SIZE);
    assert_eq!(app.views[1].next_start, PAGE_SIZE + 1);
    assert_eq!(
        app.views[1]
            .feed_cursor
            .plan(app.feed_channels.len())
            .unwrap(),
        next
    );
    assert!(app.views[1].prefetch_requested);
}

#[test]
fn refresh_keeps_rows_until_a_valid_replacement_arrives() {
    let mut app = app(&["tubular"]);
    app.view_index = 1;
    // Duplicate URLs fail request creation before any extractor is spawned.
    app.feed_channels = vec!["fixture".into(), "fixture".into()];
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Old"},{"id":"rQ_J9WH6CGk","title":"Selected"}]}
{"entries":[]}"#,
        false,
    );
    app.views[1].selection.select(Some(1));
    app.load_view();
    assert_eq!(app.views[1].videos[1].title, "Selected");
    assert_eq!(app.views[1].selection.selected(), Some(1));
    assert!(app.views[1].page_error.is_some());
    assert_eq!(app.views[1].next_start, 1);

    app.finish_page(Ok("not JSON".into()));
    assert_eq!(app.views[1].videos[1].title, "Selected");
    assert_eq!(app.views[1].selection.selected(), Some(1));

    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Updated"}]}
{"entries":[]}"#,
        true,
    );
    assert_eq!(app.views[1].videos.len(), 1);
    assert_eq!(app.views[1].videos[0].title, "Updated");
    assert_eq!(app.views[1].selection.selected(), Some(0));
    assert_eq!(app.views[1].next_start, PAGE_SIZE + 1);
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"rQ_J9WH6CGk","title":"Next page"}]}
{"entries":[]}"#,
        false,
    );
    assert_eq!(app.views[1].videos[0].title, "Updated");
    assert_eq!(app.views[1].videos[1].title, "Next page");

    app.load_view();
    assert_eq!(app.views[1].videos[0].title, "Updated");
    finish_feed_fixture(&mut app, "{\"entries\":[]}\n{\"entries\":[]}", false);
    assert!(app.views[1].videos.is_empty());
    assert_eq!(app.views[1].selection.selected(), None);
}

#[test]
fn loaded_feed_rows_are_visible_sorted_and_keep_selection_and_description_identity() {
    let mut app = app(&["tubular"]);
    app.view_index = 1;
    app.feed_channels = vec![
        "https://www.youtube.com/@one".into(),
        "https://www.youtube.com/@two".into(),
    ];
    // Keep both channels active despite a short visible page.
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Old","timestamp":100},{"id":"rQ_J9WH6CGk","title":"Undated"}]}
{"entries":[{"id":"l-GaaivVJCE","title":"Middle","timestamp":200}]}"#,
        true,
    );
    assert_eq!(
        app.views[1]
            .videos
            .iter()
            .map(|video| video.id.as_str())
            .collect::<Vec<_>>(),
        ["l-GaaivVJCE", "jNQXAC9IVRw", "rQ_J9WH6CGk"]
    );
    app.views[1].selection.select(Some(1));
    let description_id = app.views[1].videos[1].id.clone();
    app.preview = Some(PreviewMode::Info);
    app.remember_description("l-GaaivVJCE".into(), "Keep cached preview".into());
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Duplicate","timestamp":100},{"id":"SLV9AJxnb1U","title":"Newer","timestamp":300}]}
{"entries":[]}"#,
        false,
    );
    assert_eq!(
        app.views[1]
            .videos
            .iter()
            .map(|video| video.id.as_str())
            .collect::<Vec<_>>(),
        ["SLV9AJxnb1U", "l-GaaivVJCE", "jNQXAC9IVRw", "rQ_J9WH6CGk"]
    );
    assert_eq!(app.views[1].selection.selected(), Some(2));
    assert_eq!(app.views[1].videos[2].title, "Old");
    app.finish_description(
        description_id,
        Ok(r#"{"id":"jNQXAC9IVRw","description":"Selected upload description"}"#.into()),
    );
    assert_eq!(
        cached_description(&app.descriptions, "jNQXAC9IVRw"),
        Some("Selected upload description")
    );
    assert_eq!(
        cached_description(&app.descriptions, "l-GaaivVJCE"),
        Some("Keep cached preview")
    );
    assert_eq!(cached_description(&app.descriptions, "SLV9AJxnb1U"), None);
    assert_eq!(app.preview, Some(PreviewMode::Info));
    assert!(!app.views[1].has_more);
}

#[test]
fn short_undated_or_invalid_feed_pages_require_new_forward_navigation() {
    for visible in [0, 1, 19] {
        let mut app = app(&["tubular"]);
        app.view_index = 1;
        app.feed_channels
            .push("https://www.youtube.com/@jawed".into());
        let mut entries: Vec<_> = (0..visible)
            .map(|index| {
                serde_json::json!({
                    "id":format!("unknown{index:04}"), "title":"Undated",
                })
            })
            .collect();
        entries.resize(PAGE_SIZE - 1, serde_json::Value::Null);
        entries.push(serde_json::json!({"id":"bad", "title":"Invalid ID"}));
        finish_feed_fixture(
            &mut app,
            &serde_json::json!({"entries":entries}).to_string(),
            false,
        );
        assert_eq!(app.views[1].videos.len(), visible);
        assert!(app.views[1].has_more);
        assert!(!app.can_prefetch());
        app.update();
        assert!(app.job.is_none());
        app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
        assert!(app.can_prefetch());
        assert_eq!(
            app.views[1].selection.selected(),
            if visible == 0 {
                None
            } else {
                Some((visible - 1).min(1))
            }
        );
        finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
        assert!(app.views[1].has_more);
        assert!(!app.can_prefetch());
        app.key(KeyEvent::new(KeyCode::Char('G'), KeyModifiers::SHIFT));
        assert!(app.views[1].prefetch_requested);
        let next = app.views[1].feed_cursor.plan(1).unwrap();
        app.finish_page(Err("Continuation failed".into()));
        assert_eq!(app.views[1].feed_cursor.plan(1).unwrap(), next);
        assert!(!app.can_prefetch());
        app.views[1].reset();
        assert!(app.views[1].feed_requests.is_empty());
        assert!(!app.views[1].prefetch_requested);
        assert_eq!(app.views[1].feed_cursor.plan(1).unwrap()[0].start, 1);
    }
}

#[test]
fn feed_cursors_and_staged_requests_survive_cancellation_and_history_independently() {
    let mut app = app(&["tubular"]);
    app.feed_channels
        .push("https://www.youtube.com/@one".into());
    app.config
        .categories
        .insert("Two".into(), vec!["https://www.youtube.com/@two".into()]);
    app.views
        .push(View::new("Two".into(), ViewSource::Category("Two".into())));
    let category = app.views.len() - 1;
    app.views[0].loaded = true;
    for index in [1, category] {
        app.view_index = index;
        finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
    }
    app.view_index = 1;
    app.views[1].prefetch_requested = true;
    app.views[1].feed_requests = app.views[1].feed_cursor.plan(1).unwrap();
    let cancelled = app.views[1].feed_requests.clone();
    app.switch_view(category);
    finish_feed_fixture(&mut app, r#"{"entries":[]}"#, true);
    assert_eq!(
        app.views[category].feed_cursor.plan(1).unwrap()[0].start,
        PAGE_SIZE * 2 + 1
    );
    app.back_view();
    assert_eq!(app.view_index, 1);
    assert_eq!(app.views[1].feed_requests, cancelled);
    assert_eq!(app.views[1].feed_cursor.plan(1).unwrap(), cancelled);
    assert!(app.views[1].prefetch_requested);
    app.forward_view();
    assert_eq!(app.view_index, category);
    assert!(!app.views[category].prefetch_requested);
    assert_eq!(
        app.views[category].feed_cursor.plan(1).unwrap()[0].start,
        PAGE_SIZE * 2 + 1
    );
}

#[test]
fn category_membership_reordering_keeps_cursor_request_intent_and_cache() {
    let mut app = App::new(
        Options::parse_from(["tubular"]),
        PathBuf::new(),
        config::Config {
            categories: [(
                "Creators".into(),
                vec![
                    "https://www.youtube.com/@two".into(),
                    "https://www.youtube.com/@one".into(),
                ],
            )]
            .into(),
            ..Default::default()
        },
    );
    app.view_index = 2;
    finish_feed_fixture(
        &mut app,
        r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Cached","timestamp":100}]}"#,
        true,
    );
    app.views[2].query = " draft robotics ".into();
    app.views[2].submitted_query = "robotics".into();
    app.remember_description("jNQXAC9IVRw".into(), "Retained".into());
    app.views[2].feed_requests = app.views[2].feed_cursor.plan(2).unwrap();
    app.views[2].prefetch_requested = true;
    let requests = app.views[2].feed_requests.clone();
    let mut categories = app.config.categories.clone();
    categories.get_mut("Creators").unwrap().reverse();
    app.apply_config(config::Config {
        categories,
        ..Default::default()
    });
    assert_eq!(app.views[2].feed_requests, requests);
    assert_eq!(app.views[2].feed_cursor.plan(2).unwrap(), requests);
    assert!(app.views[2].prefetch_requested);
    assert_eq!(app.views[2].videos[0].id, "jNQXAC9IVRw");
    assert_eq!(app.views[2].selection.selected(), Some(0));
    assert_eq!(app.views[2].query, " draft robotics ");
    assert_eq!(app.views[2].submitted_query, "robotics");
    assert_eq!(
        cached_description(&app.descriptions, "jNQXAC9IVRw"),
        Some("Retained")
    );
    let mut categories = app.config.categories.clone();
    categories
        .get_mut("Creators")
        .unwrap()
        .push("https://www.youtube.com/@three".into());
    app.apply_config(config::Config {
        categories,
        ..Default::default()
    });
    assert!(!app.views[2].loaded);
    assert_eq!(app.views[2].videos[0].id, "jNQXAC9IVRw");
    assert!(app.views[2].feed_requests.is_empty());
    assert!(!app.views[2].prefetch_requested);
    assert_eq!(app.views[2].next_start, 1);
    assert_eq!(app.views[2].query, " draft robotics ");
    assert_eq!(app.views[2].submitted_query, "robotics");
    assert!(
        app.views[2]
            .feed_cursor
            .plan(3)
            .unwrap()
            .iter()
            .all(|request| request.start == 1)
    );
}

#[test]
fn page_failures_and_view_switches_preserve_the_successful_cursor_until_reset() {
    let mut app = app(&["tubular", "rust"]);
    app.views[0].submitted_query = "rust".into();
    app.finish_page(Err("First request failed".into()));
    assert_eq!(app.views[0].next_start, 1);
    assert!(!app.views[0].loaded);
    assert!(app.views[0].page_error.is_some());
    app.switch_view(0);
    app.update();
    assert!(app.job.is_none());
    app.views[0].reset();
    let entries: Vec<_> = (0..PAGE_SIZE)
        .map(|index| {
            serde_json::json!({
                "id": format!("search{index:05}"),
                "title": "Result",
            })
        })
        .collect();
    app.finish_page(Ok(serde_json::json!({"entries": entries}).to_string()));
    assert_eq!(app.views[0].next_start, PAGE_SIZE + 1);
    app.views[0].selection.select(Some(17));
    app.remember_description(app.views[0].videos[17].id.clone(), "Cached.".into());
    app.switch_view(1);
    app.switch_view(0);
    assert_eq!(app.views[0].next_start, PAGE_SIZE + 1);
    assert_eq!(app.views[0].selection.selected(), Some(17));
    app.finish_page(Ok("not JSON".into()));
    app.update();
    assert!(app.job.is_none());
    assert_eq!(app.views[0].videos.len(), PAGE_SIZE);
    assert_eq!(
        cached_description(&app.descriptions, &app.views[0].videos[17].id),
        Some("Cached.")
    );
    assert_eq!(app.views[0].next_start, PAGE_SIZE + 1);
    assert!(!app.views[0].needs_page());
    let view = &mut app.views[0];
    view.feed_requests = view.feed_cursor.plan(1).unwrap();
    view.prefetch_requested = true;
    view.reset();
    assert!(view.feed_requests.is_empty());
    assert!(!view.feed_cursor.has_more());
    assert!(!view.prefetch_requested);
    assert_eq!(view.next_start, 1);
    assert!(!view.loaded);
    assert!(!view.has_more);
    assert!(view.page_error.is_none());
}

#[test]
fn prefetch_only_runs_near_the_end_in_an_unobstructed_normal_view() {
    let mut app = app(&["tubular"]);
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    let mut page =
        youtube::search_results(r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Result"}]}"#).unwrap();
    page.has_more = true;
    app.views[0].accept_page(page, false).unwrap();
    assert!(!app.can_prefetch());
    app.mode = Mode::Normal;
    assert!(!app.can_prefetch());
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    assert!(app.can_prefetch());
    app.preview = Some(PreviewMode::Description);
    assert!(!app.can_prefetch());
    app.preview = Some(PreviewMode::Info);
    assert!(!app.can_prefetch());
    app.preview = None;
    app.category_dialog = Some(CategoryDialog {
        name: None,
        ..CategoryDialog::new(
            CategoryTarget::Channel {
                channel: String::new(),
                handle: String::new(),
            },
            String::new(),
            BTreeMap::new(),
        )
    });
    assert!(!app.can_prefetch());
    app.category_dialog = None;
    let entries: Vec<_> = (0..PAGE_SIZE)
        .map(|index| {
            serde_json::json!({
                "id": format!("search{index:05}"),
                "title": "Next result",
            })
        })
        .collect();
    app.views[0].reset();
    app.views[0]
        .accept_page(
            youtube::search_results(&serde_json::json!({"entries": entries}).to_string()).unwrap(),
            false,
        )
        .unwrap();
    assert_eq!(app.views[0].selection.selected(), Some(0));
    assert!(!app.can_prefetch());
    let threshold = app.views[0].videos.len() - PAGE_SIZE / 3;
    app.views[0].selection.select(Some(threshold - 1));
    assert!(!app.can_prefetch());
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    assert!(app.can_prefetch());
    assert!(app.job.is_none());
    assert_eq!(app.views[0].selection.selected(), Some(threshold));
    app.views[0].loaded = false;
    assert!(!app.can_prefetch());
    app.views[0].loaded = true;
    app.views[0].has_more = false;
    assert!(!app.can_prefetch());
    app.views[0].has_more = true;
    app.help_popup = Some(HelpPopup::default());
    assert!(!app.can_prefetch());
    app.help_popup = None;
    app.views[0].selection.select(None);
    assert!(!app.can_prefetch());
    app.views[0].selection.select(Some(threshold));
    app.views[0].page_error = Some("Stop retrying".into());
    assert!(!app.can_prefetch());
    app.views[0].page_error = None;
    app.views[0].videos.clear();
    app.views[0].selection.select(None);
    assert!(app.can_prefetch());
}

#[test]
fn input_cursor_tracks_display_width_and_stays_inside_scrolled_fields() {
    use ratatui::{Terminal, backend::TestBackend};

    let mut app = app(&["tubular"]);
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    let mut terminal = Terminal::new(TestBackend::new(24, 20)).unwrap();
    for (text, x) in [
        ("", 1),
        ("ab", 3),
        ("日本語", 7),
        ("e\u{301}", 2),
        ("abcdefghijklmnopqrstuvwxyz", 22),
    ] {
        app.views[0].query = text.into();
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        assert_eq!(terminal.get_cursor_position().unwrap(), (x, 2).into());
    }
    app.category_dialog = Some(CategoryDialog {
        name: Some(String::new()),
        ..CategoryDialog::new(
            CategoryTarget::Channel {
                channel: String::new(),
                handle: String::new(),
            },
            String::new(),
            BTreeMap::new(),
        )
    });
    for (text, x) in [("", 3), ("日本語", 9), ("abcdefghijklmnopqrstuvwxyz", 20)] {
        app.category_dialog.as_mut().unwrap().name = Some(text.into());
        terminal
            .draw(|frame| app.draw(frame, Duration::ZERO))
            .unwrap();
        assert_eq!(terminal.get_cursor_position().unwrap(), (x, 7).into());
    }
}

#[test]
fn deletion_shortcuts_edit_search_and_tag_names_without_submitting() {
    for tag_input in [false, true] {
        for (input, code, modifiers, expected) in [
            (
                "first 日本語  ",
                KeyCode::Backspace,
                KeyModifiers::ALT,
                "first ",
            ),
            (
                "first\u{3000}cafe\u{301}  ",
                KeyCode::Char('w'),
                KeyModifiers::CONTROL,
                "first\u{3000}",
            ),
            ("word", KeyCode::Backspace, KeyModifiers::ALT, ""),
            (" \u{3000} ", KeyCode::Backspace, KeyModifiers::ALT, ""),
            ("", KeyCode::Backspace, KeyModifiers::ALT, ""),
            ("first 日本語", KeyCode::Backspace, KeyModifiers::SUPER, ""),
            (
                "first 日本語",
                KeyCode::Backspace,
                KeyModifiers::SUPER | KeyModifiers::ALT,
                "",
            ),
            (
                "first 日本語",
                KeyCode::Char('u'),
                KeyModifiers::CONTROL,
                "",
            ),
            (
                "first 日本語",
                KeyCode::Backspace,
                KeyModifiers::NONE,
                "first 日本",
            ),
        ] {
            let mut app = app(&["tubular"]);
            if tag_input {
                app.mode = Mode::Normal;
                app.category_dialog = Some(CategoryDialog {
                    name: Some(input.into()),
                    ..CategoryDialog::new(
                        CategoryTarget::Channel {
                            channel: "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A"
                                .into(),
                            handle: "@jawed".into(),
                        },
                        "jawed".into(),
                        BTreeMap::new(),
                    )
                });
            } else {
                app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
                app.views[0].query = input.into();
            }
            app.key(KeyEvent::new(code, modifiers));
            let edited = app
                .category_dialog
                .as_ref()
                .and_then(|dialog| dialog.name.as_deref())
                .unwrap_or(&app.views[0].query);
            assert_eq!(
                edited, expected,
                "{tag_input}: {input:?} {code:?} {modifiers:?}"
            );
            assert!(app.job.is_none());
            assert_eq!(
                app.mode,
                if tag_input {
                    Mode::Normal
                } else {
                    Mode::Insert
                }
            );
        }
    }
    let mut app = app(&["tubular"]);
    app.views[0].query = "keep this query".into();
    app.mode = Mode::Normal;
    for (code, modifiers) in [
        (KeyCode::Backspace, KeyModifiers::ALT),
        (KeyCode::Backspace, KeyModifiers::SUPER),
        (KeyCode::Char('w'), KeyModifiers::CONTROL),
    ] {
        app.key(KeyEvent::new(code, modifiers));
        assert_eq!(app.views[0].query, "keep this query");
    }
}

#[test]
fn modal_keys_edit_or_navigate_without_submitting_on_escape() {
    let mut app = app(&["tubular"]);
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    app.views[0].videos = vec![
        Video {
            id: "jNQXAC9IVRw".into(),
            title: "Me at the zoo".into(),
            channel: None,
            channel_id: None,
            uploader_id: None,
            timestamp: None,
            duration: None,
            publication_date: None,
            availability: None,
        },
        Video {
            id: "rQ_J9WH6CGk".into(),
            title: "Rust course".into(),
            channel: None,
            channel_id: None,
            uploader_id: None,
            timestamp: None,
            duration: None,
            publication_date: None,
            availability: None,
        },
    ];
    app.views[0].selection.select(Some(0));

    for c in ['j', 'k', 'q'] {
        assert!(!app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE)));
    }
    app.update();
    assert_eq!(app.views[0].query, "jkq");
    assert_eq!(app.views[0].selection.selected(), Some(0));
    assert!(app.job.is_none());

    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(app.mode, Mode::Normal);
    assert!(app.job.is_none());
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    assert_eq!(app.views[0].selection.selected(), Some(1));
    app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::NONE));
    assert_eq!(app.views[0].selection.selected(), Some(0));
    app.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
    assert_eq!(app.mode, Mode::Insert);
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(app.mode, Mode::Normal);
    assert!(app.views[0].query.is_empty());
    assert!(app.job.is_none());
}

#[test]
fn category_dialog_is_modal_and_views_keep_independent_selections() {
    let mut app = app(&["tubular", "rust"]);
    let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"Rust video","channel":"Rust","channel_id":"UCaYhcUwRBNscFNUKTjgPFiA","uploader_id":"@RustVideos"},{"id":"rQ_J9WH6CGk","title":"Another video"}]}"#;
    app.views[0].videos = youtube::search_results(videos).unwrap().videos;
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(1));
    // The selected channel is unavailable; do not save a guessed display-name identity.
    app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
    assert!(app.category_dialog.is_none());
    app.views[0].selection.select(Some(0));
    app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().error.is_some());
    for c in ['j', 'k', 'q', 'i', 't', 'd', ' '] {
        assert!(!app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE)));
    }
    assert_eq!(
        app.category_dialog.as_ref().unwrap().name.as_deref(),
        Some("jkqitd ")
    );
    assert_eq!(app.views[0].query, "rust");
    assert_eq!(app.views[0].selection.selected(), Some(0));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().name.is_none());
    app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('A'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().name.is_none());
    assert!(app.category_dialog.as_ref().unwrap().tags["A"]);
    assert!(app.config.categories.is_empty());
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    assert!(!app.category_dialog.as_ref().unwrap().tags["A"]);
    app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert!(!app.category_dialog.as_ref().unwrap().tags["A"]);
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert!(app.category_dialog.is_none());
    assert_eq!(app.mode, Mode::Normal);
    assert!(app.config.categories.is_empty());

    let rust = vec!["https://www.youtube.com/@RustVideos".into()];
    app.apply_config(config::Config {
        keys: Default::default(),
        categories: [("Rust".into(), rust.clone())].into(),
        channels: BTreeMap::new(),
        pinned_categories: vec!["Rust".into()],
    });
    app.views[0].selection.select(Some(1));
    app.views[1].videos = feed_fixture(videos).unwrap().videos;
    app.views[1].loaded = true;
    app.views[1].selection.select(Some(0));
    app.views[2].videos = feed_fixture(videos).unwrap().videos;
    app.views[2].loaded = true;
    app.views[2].selection.select(Some(0));
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    assert_eq!(app.view_index, 1);
    assert_eq!(app.views[1].name, "Feed");
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    assert_eq!(app.view_index, 2);
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    assert_eq!(app.views[2].selection.selected(), Some(1));
    assert_eq!(app.views[1].selection.selected(), Some(0));
    app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
    assert_eq!(app.view_index, 1);
    assert_eq!(app.views[1].selection.selected(), Some(0));
    app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
    assert_eq!(app.view_index, 0);
    assert_eq!(app.views[0].selection.selected(), Some(1));
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    app.apply_config(config::Config {
        keys: Default::default(),
        categories: [
            (
                "Books".into(),
                vec!["https://www.youtube.com/@example".into()],
            ),
            ("Rust".into(), rust),
        ]
        .into(),
        channels: BTreeMap::new(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 3);
    assert_eq!(app.views[3].name, "Rust");
    assert_eq!(app.views[3].selection.selected(), Some(1));
    assert!(app.views[3].loaded);
    app.apply_config(config::Config {
        keys: Default::default(),
        categories: [("Rust".into(), vec![])].into(),
        channels: BTreeMap::new(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.views[app.view_index].name, "Rust");
    assert!(!app.views[app.view_index].loaded);
    assert!(app.job.is_none());
    app.load_page();
    assert!(app.views[app.view_index].videos.is_empty());
    assert!(app.views[app.view_index].selection.selected().is_none());
    assert!(app.views[app.view_index].loaded);
}

#[test]
fn feed_cache_tracks_subscriptions_not_tag_memberships() {
    let registered = "https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA";
    let direct = "https://www.youtube.com/channel/UC4QobU6STFB0P71PMvOGN5A";
    let added = "https://www.youtube.com/channel/UCBR8-60-B28hp2BmDPdntcQ";
    let mut app = App::new(
        Options::parse_from(["tubular", "rust"]),
        PathBuf::new(),
        config::Config {
            keys: Default::default(),
            channels: [("@RustVideos".into(), registered.into())].into(),
            categories: [
                ("Direct".into(), vec![direct.into()]),
                ("Tagged".into(), vec![registered.into()]),
            ]
            .into(),
            pinned_categories: Vec::new(),
        },
    );
    let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"New","timestamp":200},{"id":"rQ_J9WH6CGk","title":"Old","timestamp":100}]}"#;
    assert_eq!(app.feed_channels, vec![direct, registered]);
    app.views[1].videos = feed_fixture(videos).unwrap().videos;
    app.views[1].selection.select(Some(1));
    app.views[1].loaded = true;
    app.views[1].next_start = 41;
    app.views[1].has_more = true;
    app.views[1].feed_requests = app.views[1].feed_cursor.plan(2).unwrap();
    app.views[1].prefetch_requested = true;
    app.views[1].page_error = Some("Retained page error".into());
    app.remember_description(
        app.views[1].videos[1].id.clone(),
        "Retained description".into(),
    );
    app.views[3].videos = feed_fixture(videos).unwrap().videos;
    app.views[3].selection.select(Some(0));
    app.views[3].loaded = true;
    app.views[3].next_start = 61;
    app.views[3].has_more = true;
    app.views[3].feed_requests = app.views[3].feed_cursor.plan(1).unwrap();
    app.views[3].prefetch_requested = true;
    app.views[3].page_error = Some("Tag page failed".into());
    app.switch_view(1);

    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [
            ("Direct".into(), vec![direct.into()]),
            ("Renamed".into(), vec![registered.into()]),
            ("Tagged".into(), vec![]),
        ]
        .into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 1);
    assert!(app.views[1].loaded);
    assert_eq!(app.views[1].videos[1].id, "rQ_J9WH6CGk");
    assert_eq!(app.views[1].selection.selected(), Some(1));
    assert_eq!(app.views[1].next_start, 41);
    assert!(app.views[1].has_more);
    assert_eq!(app.views[1].feed_requests.len(), 2);
    assert!(app.views[1].prefetch_requested);
    assert_eq!(
        app.views[1].page_error.as_deref(),
        Some("Retained page error")
    );
    assert_eq!(
        cached_description(&app.descriptions, &app.views[1].videos[1].id),
        Some("Retained description")
    );
    assert!(!app.views[4].loaded);
    assert_eq!(app.views[4].next_start, 1);
    assert!(!app.views[4].has_more);
    assert!(app.views[4].feed_requests.is_empty());
    assert!(!app.views[4].prefetch_requested);
    assert!(app.views[4].page_error.is_none());

    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [
            ("Direct".into(), vec![direct.into()]),
            ("Renamed".into(), vec![]),
            ("Tagged".into(), vec![]),
        ]
        .into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.feed_channels, vec![direct, registered]);
    assert!(app.views[1].loaded);
    assert_eq!(app.views[1].videos.len(), 2);
    assert_eq!(app.views[1].selection.selected(), Some(1));
    assert_eq!(app.views[1].next_start, 41);
    assert!(app.views[1].has_more);
    assert_eq!(app.views[1].feed_requests.len(), 2);
    assert!(app.views[1].prefetch_requested);
    assert!(app.views[1].page_error.is_some());

    let mut channels = app.config.channels.clone();
    channels.insert("@YouTube".into(), added.into());
    app.apply_config(config::Config {
        keys: Default::default(),
        channels,
        categories: app.config.categories.clone(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.feed_channels, vec![direct, added, registered]);
    assert!(!app.views[1].loaded);
    assert_eq!(app.views[1].next_start, 1);
    assert!(!app.views[1].has_more);
    assert!(app.views[1].feed_requests.is_empty());
    assert!(!app.views[1].prefetch_requested);
    assert!(app.views[1].page_error.is_none());
    assert_eq!(app.view_index, 1);
    assert!(app.job.is_none());

    app.views[1].videos = feed_fixture(videos).unwrap().videos;
    app.views[1].selection.select(Some(1));
    app.views[1].loaded = true;
    let mut channels = app.config.channels.clone();
    channels.remove("@YouTube");
    app.apply_config(config::Config {
        keys: Default::default(),
        channels,
        categories: app.config.categories.clone(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.feed_channels, vec![direct, registered]);
    assert!(!app.views[1].loaded);
    assert_eq!(app.view_index, 1);
    assert!(app.job.is_none());
}

#[test]
fn builtins_and_same_named_tags_keep_distinct_identities() {
    let mut app = app(&["tubular", "rust"]);
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: [(
            "@RustVideos".into(),
            "https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA".into(),
        )]
        .into(),
        categories: [("Feed".into(), vec![]), ("Search".into(), vec![])].into(),
        pinned_categories: Vec::new(),
    });
    let videos = r#"{"entries":[{"id":"l-GaaivVJCE","title":"First"},{"id":"rQ_J9WH6CGk","title":"Second"}]}"#;
    for (index, view) in app.views.iter_mut().enumerate() {
        view.videos = feed_fixture(videos).unwrap().videos;
        view.loaded = true;
        view.selection.select(Some(usize::from(index % 2 == 0)));
    }
    app.switch_view(1);
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [
            ("Alpha".into(), vec![]),
            ("Feed".into(), vec![]),
            ("Search".into(), vec![]),
        ]
        .into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 1);
    assert_eq!(app.views[1].selection.selected(), Some(0));
    assert_eq!(app.views[3].name, "Feed");
    assert_eq!(app.views[3].selection.selected(), Some(1));
    assert_eq!(app.views[0].selection.selected(), Some(1));
    assert_eq!(app.views[4].selection.selected(), Some(0));

    app.switch_view(0);
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [("Feed".into(), vec![]), ("Search".into(), vec![])].into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 0);
    app.switch_view(2);
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [
            ("Alpha".into(), vec![]),
            ("Feed".into(), vec![]),
            ("Search".into(), vec![]),
        ]
        .into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 3);
    assert_eq!(app.views[3].selection.selected(), Some(1));

    app.switch_view(4);
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [
            ("Alpha".into(), vec![]),
            ("Beta".into(), vec![]),
            ("Feed".into(), vec![]),
            ("Search".into(), vec![]),
        ]
        .into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 5);
    assert_eq!(app.views[5].selection.selected(), Some(0));
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [
            ("Alpha".into(), vec![]),
            ("Beta".into(), vec![]),
            ("Feed".into(), vec![]),
        ]
        .into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 0);
    assert_eq!(app.views[0].selection.selected(), Some(1));
    app.switch_view(4);
    app.apply_config(config::Config {
        keys: Default::default(),
        channels: app.config.channels.clone(),
        categories: [("Alpha".into(), vec![]), ("Beta".into(), vec![])].into(),
        pinned_categories: Vec::new(),
    });
    assert_eq!(app.view_index, 0);
    assert_eq!(app.views[1].name, "Feed");
    assert_eq!(app.views[1].selection.selected(), Some(0));
    assert!(app.job.is_none());
}

#[test]
fn empty_feed_is_informative_and_navigation_wraps_without_extraction() {
    let mut app = app(&["tubular"]);
    assert_eq!(app.views.len(), 2);
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::CONTROL));
    assert_eq!(app.view_index, 1);
    assert!(app.views[1].loaded);
    assert!(app.views[1].videos.is_empty());
    assert_eq!(app.views[1].selection.selected(), None);
    assert!(app.job.is_none());
    app.key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
    assert_eq!(app.view_index, 0);
    app.key(KeyEvent::new(KeyCode::BackTab, KeyModifiers::SHIFT));
    assert_eq!(app.views[app.view_index].source, ViewSource::Feed);
    assert!(app.job.is_none());
}

#[test]
fn channel_tags_stage_memberships_and_commit_only_from_the_list() {
    let path = std::env::temp_dir().join(format!(
        "tubular-tag-editor-test-{}.toml",
        std::process::id()
    ));
    struct TestFile(PathBuf);
    impl Drop for TestFile {
        fn drop(&mut self) {
            let _ = std::fs::remove_file(&self.0);
        }
    }
    std::fs::OpenOptions::new()
        .write(true)
        .create_new(true)
        .open(&path)
        .unwrap();
    let _file = TestFile(path.clone());
    let original = "[categories]\nAlias = [\"@RustVideos\"]\nCanonical = [\"UCaYhcUwRBNscFNUKTjgPFiA\"]\nEmpty = []\n";
    std::fs::write(&path, original).unwrap();
    let mut app = app(&["tubular", "rust"]);
    app.config_path = path.clone();
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"l-GaaivVJCE","title":"Rust video","channel_id":"UCaYhcUwRBNscFNUKTjgPFiA","uploader_id":"@RustVideos"}]}"#,
        )
        .unwrap().videos;
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(0));
    app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
    assert_eq!(
        app.category_dialog.as_ref().unwrap().tags,
        [
            ("Alias".into(), true),
            ("Canonical".into(), true),
            ("Empty".into(), false),
        ]
        .into()
    );
    app.key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().tags["Alias"]);
    app.key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
    for c in "Empty".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().error.is_some());
    app.key(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
    for c in "  Added  ".chars() {
        app.key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
    }
    app.key(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert_eq!(
        app.category_dialog.as_ref().unwrap().selection.selected(),
        Some(0)
    );
    assert!(app.category_dialog.as_ref().unwrap().tags["Added"]);
    assert_eq!(std::fs::read_to_string(&path).unwrap(), original);
    app.category_dialog.as_mut().unwrap().error = Some("Previous save failed".into());
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    assert!(app.category_dialog.as_ref().unwrap().error.is_none());
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.category_dialog.is_none());
    let saved = config::load(&path).unwrap();
    let canonical = vec!["https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA".to_owned()];
    assert!(saved.categories["Alias"].is_empty());
    assert!(saved.categories["Added"].is_empty());
    assert_eq!(saved.categories["Canonical"], canonical);
    assert_eq!(saved.categories["Empty"], canonical);
    let committed = std::fs::read_to_string(&path).unwrap();
    app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(std::fs::read_to_string(&path).unwrap(), committed);
    std::fs::write(&path, "[categories]\n").unwrap();
    app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
    assert!(
        app.category_dialog
            .as_ref()
            .unwrap()
            .selection
            .selected()
            .is_none()
    );
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(app.category_dialog.is_none());
    assert!(config::load(&path).unwrap().categories.is_empty());
}

#[test]
fn preview_cycles_without_reloading_and_selection_resets_scrolling() {
    use ratatui::{Terminal, backend::TestBackend};

    let mut app = app(&["tubular"]);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"First"},{"id":"9bZkp7q19f0","title":"Second"}]}"#,
        ).unwrap().videos;
    // Invalid fixture IDs keep thumbnail failure deterministic without invoking curl.
    app.views[0].videos[0].id = "first".into();
    app.views[0].videos[1].id = "second".into();
    app.remember_description("first".into(), "First paragraph\n\n".repeat(40));
    app.remember_description("second".into(), "Second paragraph\n\n".repeat(40));
    app.views[0].selection.select(Some(0));
    app.views[0].loaded = true;
    let mut terminal = Terminal::new(TestBackend::new(120, 40)).unwrap();
    let press = |app: &mut App, code| {
        app.key(KeyEvent::new(code, KeyModifiers::NONE));
    };
    press(&mut app, KeyCode::Char('t'));
    assert_eq!(app.preview, None);
    press(&mut app, KeyCode::Char('d'));
    assert_eq!(app.preview, Some(PreviewMode::Info));
    assert!(app.description_job.is_none());
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let info = terminal.backend().buffer().clone();
    press(&mut app, KeyCode::Char('d'));
    assert_eq!(app.preview, Some(PreviewMode::Description));
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    press(&mut app, KeyCode::PageDown);
    assert!(app.description_scroll > 0);
    let scroll = app.description_scroll;
    press(&mut app, KeyCode::Char('d'));
    assert_eq!(app.preview, Some(PreviewMode::Info));
    assert_eq!(app.description_scroll, scroll);
    assert!(app.description_job.is_none());
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    // Includes the failed thumbnail text: cancellation would remove that image state.
    assert_eq!(terminal.backend().buffer(), &info);
    press(&mut app, KeyCode::Char('d'));
    press(&mut app, KeyCode::Char('j'));
    assert_eq!(app.preview, Some(PreviewMode::Description));
    assert_eq!(app.views[0].selection.selected(), Some(1));
    assert_eq!(app.description_scroll, 0);
    assert_eq!(app.description_viewport, None);
    assert!(app.description_error.is_none());
    assert!(app.description_job.is_none());
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let buffer = terminal.backend().buffer();
    let popup = preview_area(buffer.area);
    let title = &buffer[(popup.x + 2, popup.y + 2)];
    assert_eq!(title.symbol(), "S");
    assert!(title.modifier.contains(ratatui::style::Modifier::BOLD));
    press(&mut app, KeyCode::Down);
    assert_eq!(app.description_scroll, 1);
    assert_eq!(app.views[0].selection.selected(), Some(1));
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
    assert_eq!(app.description_scroll, 2);
    assert_eq!(app.views[0].selection.selected(), Some(1));
    app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
    assert_eq!(app.description_scroll, 1);
    app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
    app.key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
    assert_eq!(app.description_scroll, 0);
    app.description_scroll = app.description_max_scroll;
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
    assert_eq!(app.description_scroll, app.description_max_scroll);
    assert_eq!(app.views[0].selection.selected(), Some(1));
    press(&mut app, KeyCode::Char('d'));
    press(&mut app, KeyCode::Up);
    assert_eq!(app.views[0].selection.selected(), Some(0));
    assert_eq!(app.description_scroll, 0);
    press(&mut app, KeyCode::Esc);
    assert_eq!(app.preview, None);
    assert_eq!(
        cached_description(&app.descriptions, "first"),
        Some("First paragraph\n\n".repeat(40).as_str())
    );
    press(&mut app, KeyCode::Char('i'));
    press(&mut app, KeyCode::Char('t'));
    press(&mut app, KeyCode::Char('d'));
    assert_eq!(app.views[0].query, "td");
    assert_eq!(app.preview, None);
}

#[test]
fn full_description_scrolls_padded_metadata_and_body_together() {
    use ratatui::{Terminal, backend::TestBackend, style::Modifier};

    let mut app = app(&["tubular"]);
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"jNQXAC9IVRw","title":"Selected video","channel":"Creator","upload_date":"20050423"}]}"#,
        ).unwrap().videos;
    app.views[0].selection.select(Some(0));
    app.preview = Some(PreviewMode::Description);
    app.remember_description(
        "jNQXAC9IVRw".into(),
        (0..100).map(|i| format!("Body line {i:03}\n")).collect(),
    );
    let mut terminal = Terminal::new(TestBackend::new(80, 24)).unwrap();
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let before = terminal.backend().buffer().clone();
    let popup = preview_area(before.area);
    let x = popup.x + 2;
    let title_y = popup.y + 2;
    let body_y = (title_y..popup.bottom() - 1)
        .find(|&y| before[(x, y)].symbol() == "B")
        .expect("description is visible below metadata");
    for x in popup.x + 1..popup.right() - 1 {
        assert_eq!(before[(x, popup.y + 1)].symbol(), " ");
    }
    assert!(before[(x, title_y)].modifier.contains(Modifier::BOLD));
    assert!(before[(x, title_y + 2)].modifier.contains(Modifier::DIM));
    assert!(!before[(x, body_y)].modifier.contains(Modifier::DIM));
    assert_eq!(
        app.description_viewport,
        Some((popup.width - 4, popup.height - 2))
    );
    app.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL));
    terminal
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let after = terminal.backend().buffer();
    assert_eq!(after[(x, title_y - 1)].symbol(), "S");
    assert!(after[(x, title_y - 1)].modifier.contains(Modifier::BOLD));
    assert_eq!(after[(x, title_y + 1)].symbol(), "C");
    assert!(after[(x, title_y + 1)].modifier.contains(Modifier::DIM));
    let row = |buffer: &ratatui::buffer::Buffer, y| -> String {
        (x..popup.right() - 2)
            .map(|x| buffer[(x, y)].symbol())
            .collect()
    };
    assert_eq!(row(&before, body_y).trim_end(), "Body line 000");
    assert_eq!(row(after, body_y).trim_end(), "Body line 001");
    for y in popup.y + 1..popup.bottom() - 1 {
        assert_eq!(after[(popup.x + 1, y)].symbol(), " ");
        assert_eq!(after[(popup.right() - 2, y)].symbol(), " ");
    }
    // A wrapped title cannot prevent reaching the description in a small pane.
    let mut narrow = Terminal::new(TestBackend::new(12, 8)).unwrap();
    narrow
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    assert!(app.description_max_scroll > 0);
    app.description_scroll = app.description_max_scroll;
    narrow
        .draw(|frame| app.draw(frame, Duration::ZERO))
        .unwrap();
    let narrow_popup = preview_area(narrow.backend().buffer().area);
    let narrow_buffer = narrow.backend().buffer();
    let tail: String = (narrow_popup.y + 1..narrow_popup.bottom() - 1)
        .flat_map(|y| {
            (narrow_popup.x + 2..narrow_popup.right() - 2)
                .map(move |x| narrow_buffer[(x, y)].symbol())
        })
        .collect();
    assert!(tail.contains("099"), "{tail}");
}

#[test]
fn search_without_a_handle_can_tag_a_registered_channel() {
    let path = std::env::temp_dir().join(format!(
        "tubular-missing-handle-{}.toml",
        std::process::id()
    ));
    let original =
        "[channels]\n'@ch.1676' = 'UChAQQ9at2MDlXjvQX3vL3Yw'\n[categories]\nJapanese = []\n";
    std::fs::write(&path, original).unwrap();
    let mut app = App::new(
        Options::parse_from(["tubular"]),
        path.clone(),
        config::load(&path).unwrap(),
    );
    app.views[0].videos = youtube::search_results(
            r#"{"entries":[{"id":"nwxkg84mADI","title":"Hokkaido Vlog","channel":"敷嶋てとらch.","channel_id":"UChAQQ9at2MDlXjvQX3vL3Yw","uploader_id":null}]}"#,
        ).unwrap().videos;
    app.views[0].loaded = true;
    app.views[0].selection.select(Some(0));
    app.key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
    assert!(app.category_dialog.is_some(), "{}", app.status);
    app.key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
    app.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    let saved = config::load(&path).unwrap();
    assert_eq!(
        saved.categories["Japanese"],
        ["https://www.youtube.com/channel/UChAQQ9at2MDlXjvQX3vL3Yw"]
    );
    std::fs::remove_file(path).unwrap();
}

#[test]
fn escape_discards_checks_without_consuming_view_history() {
    let mut app = app(&["tubular"]);
    app.views[0].loaded = true;
    app.views[1].loaded = true;
    app.switch_view(1);
    app.views[1].checked.insert("jNQXAC9IVRw".into());
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert!(app.views[1].checked.is_empty());
    assert_eq!(app.view_index, 1);
    app.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
    assert_eq!(app.view_index, 1);
    app.key(KeyEvent::new(KeyCode::Char('-'), KeyModifiers::NONE));
    assert_eq!(app.view_index, 0);
}