use super::*;
use ratatui::crossterm::event::KeyModifiers;
use std::{
    collections::BTreeMap,
    fs,
    io::Write,
    sync::atomic::{AtomicU64, Ordering},
};
use tubular::miruro::{Detail, SourceDocument};

struct Directory(PathBuf);
impl Directory {
    fn new() -> Self {
        static NEXT: AtomicU64 = AtomicU64::new(0);
        let directory = std::env::temp_dir().join(format!(
            "tubular-miruro-ui-{}-{}",
            std::process::id(),
            NEXT.fetch_add(1, Ordering::Relaxed)
        ));
        fs::create_dir(&directory).unwrap();
        Self(directory)
    }
    fn browser(&self, query: Option<&str>) -> Browser {
        let path = self.0.join("config.toml");
        fs::write(&path, "").unwrap();
        let options = Options {
            player: self.0.join("missing-player").into_os_string(),
            default_config: false,
            miruro: true,
            query: query.map(str::to_owned),
        };
        Browser::new(
            options,
            path.clone(),
            config::Config::default(),
            State::open(&path).unwrap(),
        )
    }
}
impl Drop for Directory {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.0);
    }
}
fn media(id: &str) -> Media {
    miruro_browser::catalog(vec![serde_json::json!({"id":id, "title":{"english":format!("Series {id}")}, "episode_count":12, "description":"Series synopsis", "episode_counts":{"sub":null}})]).unwrap().remove(0)
}
fn series(media: &Media) -> miruro_browser::Series {
    let mut metadata = media.metadata.clone();
    metadata.as_object_mut().unwrap().remove("episode_count");
    miruro_browser::series(&media.id, Detail { media: metadata, episodes: vec![
            serde_json::json!({"episode_number":3, "absolute_number":49, "title":"Actual episode", "synopsis":"Episode synopsis", "aired_on":"2026-10-02", "duration_seconds":1500}),
            serde_json::json!({"episode_number":7, "absolute_number":53, "title":null, "duration_seconds":null}),
        ] }).unwrap()
}
fn source(video: &Video, token: &str) -> SourceDocument {
    SourceDocument {
        version: 1,
        url: format!("https://vault.keeply.top/master.m3u8?token={token}"),
        headers: BTreeMap::new(),
        identity: Identity::from_key(&video.id).unwrap(),
        title: Some(video.title.clone()),
        subtitles: Vec::new(),
    }
}
fn catalog_results(browser: &mut Browser) {
    browser.accept(
        browser.generation,
        Ok(Response::Catalog(vec![media("first"), media("second")])),
    );
}
fn enter_series(browser: &mut Browser) {
    browser.open();
    let Content::Series { media, .. } = &browser.screen().content else {
        panic!("series screen");
    };
    let result = series(media);
    browser.accept(browser.generation, Ok(Response::Series(result)));
}
fn sources(directory: &Directory) -> Vec<Value> {
    let path = directory.0.join("playback-sessions");
    if !path.exists() {
        return Vec::new();
    }
    fs::read_dir(path)
        .unwrap()
        .map(|entry| {
            serde_json::from_slice(&fs::read(entry.unwrap().path().join("source.json")).unwrap())
                .unwrap()
        })
        .collect()
}

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

    let directory = Directory::new();
    let mut browser = directory.browser(Some("anime"));
    catalog_results(&mut browser);
    enter_series(&mut browser);
    browser
        .screen_mut()
        .overview
        .push_str(&"\nMore synopsis".repeat(40));
    browser.screen_mut().overview.push_str("\nTAIL");
    browser.screen_mut().update_description();
    let selected = browser.screen().selected_video().unwrap().id;
    for (width, height) in [(120, 40), (60, 24), (24, 12)] {
        let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
        browser.key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        assert_eq!(browser.context(), Context::Info);
        browser.key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        assert_eq!(browser.context(), Context::Description);
        terminal
            .draw(|frame| browser.draw(frame, Duration::ZERO))
            .unwrap();
        let popup = crate::preview_area(terminal.backend().buffer().area);
        let popup_text = |terminal: &Terminal<TestBackend>| -> String {
            (popup.y + 1..popup.bottom() - 1)
                .flat_map(|y| {
                    (popup.x + 1..popup.right() - 1)
                        .map(move |x| terminal.backend().buffer()[(x, y)].symbol())
                })
                .collect()
        };
        assert!(popup_text(&terminal).contains("Episode 3"));
        browser.key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
        terminal
            .draw(|frame| browser.draw(frame, Duration::ZERO))
            .unwrap();
        assert_eq!(browser.screen().description_scroll, 1);
        assert_eq!(browser.screen().selected_video().unwrap().id, selected);
        browser.screen_mut().description_scroll = u16::MAX;
        terminal
            .draw(|frame| browser.draw(frame, Duration::ZERO))
            .unwrap();
        assert!(popup_text(&terminal).contains("TAIL"));
        browser.key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE));
        assert_eq!(browser.context(), Context::Info);
        browser.key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        assert!(browser.preview.is_none());
        assert_eq!(browser.screen().selected_video().unwrap().id, selected);
        browser.screen_mut().description_scroll = 0;
    }
    browser.key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
    assert_eq!(
        browser.screen().selected_video().unwrap().id,
        "miruro:first:7"
    );
}

#[test]
fn catalog_series_back_forward_keep_native_query_selection_and_actual_episodes() {
    let directory = Directory::new();
    let mut browser = directory.browser(Some("apothecary"));
    assert!(matches!(&browser.pending, Some(Request::Search(query)) if query == "apothecary"));
    catalog_results(&mut browser);
    browser.select(Action::VideoNext);
    enter_series(&mut browser);
    assert_eq!(browser.screen().len(), 2); // Neither planned 12 nor absolute 49 creates rows.
    assert!(
        matches!(&browser.screen().content, Content::Series { media, .. } if media.metadata["episode_count"] == 12 && media.metadata["episode_counts"]["sub"].is_null())
    );
    assert_eq!(
        browser.screen().selected_video().unwrap().id,
        "miruro:second:3"
    );
    browser.select(Action::VideoNext);
    browser.save(CollectionKind::Saved);
    browser.history(false);
    assert_eq!(browser.screen().selection.selected(), Some(1));
    assert!(
        matches!(&browser.screen().content, Content::Catalog { query, media, .. } if query == "apothecary" && media.len() == 2)
    );
    assert!(browser.pending.is_none());
    browser.history(true);
    assert_eq!(
        browser.screen().selected_video().unwrap().id,
        "miruro:second:7"
    );
    assert!(browser.pending.is_none());
    assert!(
        browser
            .state
            .contains(CollectionKind::Saved, "miruro:second:7")
    );
}

#[test]
fn latest_intent_and_navigation_reject_stale_catalog_series_and_sources() {
    let directory = Directory::new();
    let mut browser = directory.browser(Some("old"));
    let old = browser.generation;
    browser.edit_search();
    browser.input = Some("latest".into());
    browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(matches!(&browser.pending, Some(Request::Search(query)) if query == "latest"));
    browser.accept(old, Ok(Response::Catalog(vec![media("stale")])));
    assert_eq!(browser.screen().len(), 0);
    catalog_results(&mut browser);
    browser.open();
    let stale = browser.generation;
    let Content::Series { media, .. } = &browser.screen().content else {
        panic!("series");
    };
    let data = series(media);
    browser.history(false);
    browser.accept(stale, Ok(Response::Series(data)));
    assert!(matches!(browser.screen().content, Content::Catalog { .. }));
    browser.history(true);
    let Content::Series { media, .. } = &browser.screen().content else {
        panic!("series");
    };
    let data = series(media);
    browser.accept(browser.generation, Ok(Response::Series(data)));
    let video = browser.screen().selected_video().unwrap();
    browser.open();
    let stale = browser.generation;
    browser.history(false);
    browser.accept(
        stale,
        Ok(Response::Source(
            video.clone(),
            Box::new(source(&video, "stale")),
        )),
    );
    assert!(sources(&directory).is_empty());
    browser.history(true);
    browser.open();
    let stale = browser.generation;
    browser.refresh();
    browser.accept(
        stale,
        Ok(Response::Source(
            video.clone(),
            Box::new(source(&video, "refreshed-away")),
        )),
    );
    assert!(sources(&directory).is_empty());
}

#[test]
fn manual_watch_status_refreshes_filters_and_preserves_other_providers() {
    let directory = Directory::new();
    let mut browser = directory.browser(Some("anime"));
    catalog_results(&mut browser);
    browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE));
    assert!(browser.state.videos(CollectionKind::Watching).is_empty());
    assert!(!browser.bindings().iter().any(|(action, _)| {
        matches!(
            action,
            Action::WatchStatusWatching | Action::WatchStatusWatched
        )
    }));
    enter_series(&mut browser);
    let episode = browser.screen().selected_video().unwrap();
    let mut youtube = episode.clone();
    youtube.id = "jNQXAC9IVRw".into();
    youtube.channel_id = Some("UC4QobU6STFB0P71PMvOGN5A".into());
    youtube.uploader_id = Some("@jawed".into());
    browser
        .state
        .save(CollectionKind::Watching, &youtube)
        .unwrap();
    browser.save(CollectionKind::WatchLater);
    browser.preview = Some(PreviewMode::Info);
    browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE));
    assert!(
        browser
            .state
            .contains(CollectionKind::Watching, &episode.id)
    );
    assert!(!browser.state.is_watched(&episode.id));
    browser.preview = None;
    browser.collection(CollectionKind::Watching);
    browser.open();
    assert!(browser.pending.is_some());
    browser.key(KeyEvent::new(KeyCode::Char('M'), KeyModifiers::NONE));
    assert!(browser.state.is_watched(&episode.id));
    assert_eq!(browser.screen().len(), 0);
    assert!(browser.pending.is_none());
    browser.collection(CollectionKind::WatchLater);
    browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
    assert_eq!(browser.screen().len(), 0);
    browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
    assert_eq!(browser.screen().len(), 1);
    browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE));
    assert_eq!(browser.screen().len(), 0);
    assert!(!browser.state.is_watched(&episode.id));
    assert!(
        browser
            .state
            .contains(CollectionKind::Watching, &episode.id)
    );
    assert!(
        browser
            .state
            .contains(CollectionKind::Watching, &youtube.id)
    );
    assert!(!browser.state.is_watched(&youtube.id));
    let state = State::open(&browser.config_path).unwrap();
    assert!(state.contains(CollectionKind::Watching, &episode.id));
    assert!(state.contains(CollectionKind::WatchLater, &episode.id));
    let overrides: toml_edit::DocumentMut =
        "[keys.video.status]\nwatched = 'alt+m'\n".parse().unwrap();
    browser.config.keys = crate::keys::Bindings::from_toml(overrides.get("keys")).unwrap();
    browser.collection(CollectionKind::Watching);
    browser.key(KeyEvent::new(KeyCode::Char('M'), KeyModifiers::NONE));
    assert!(!browser.state.is_watched(&episode.id));
    browser.key(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::ALT));
    assert!(browser.state.is_watched(&episode.id));
    assert!(state.contains(CollectionKind::Watching, &youtube.id));
}

#[test]
fn offline_collections_and_filtered_bulk_removal_never_touch_youtube() {
    let directory = Directory::new();
    let mut browser = directory.browser(Some("anime"));
    catalog_results(&mut browser);
    enter_series(&mut browser);
    let episode = browser.screen().selected_video().unwrap();
    let mut youtube = episode.clone();
    youtube.id = "jNQXAC9IVRw".into();
    youtube.title = "YouTube title".into();
    youtube.channel = Some("jawed".into());
    youtube.channel_id = Some("UC4QobU6STFB0P71PMvOGN5A".into());
    youtube.uploader_id = Some("@jawed".into());
    for kind in [
        CollectionKind::Saved,
        CollectionKind::WatchLater,
        CollectionKind::Watching,
    ] {
        browser.state.save(kind, &episode).unwrap();
        browser.state.save(kind, &youtube).unwrap();
    }
    browser.collection(CollectionKind::Saved);
    assert_eq!(browser.screen().len(), 1);
    browser.open();
    assert!(matches!(&browser.pending, Some(Request::Source(video)) if video.id == episode.id));
    browser.remove(true);
    assert_eq!(
        browser.removal.as_ref().unwrap().1.as_slice(),
        std::slice::from_ref(&episode.id)
    );
    browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(browser.state.contains(CollectionKind::Saved, &youtube.id));
    assert!(!browser.state.contains(CollectionKind::Saved, &episode.id));
    assert!(
        browser
            .state
            .contains(CollectionKind::WatchLater, &episode.id)
    );
    let (_, report) = browser
        .state
        .miruro_session(&episode, &source(&episode, "progress"))
        .unwrap();
    let mut output = fs::OpenOptions::new();
    output.write(true).create_new(true);
    #[cfg(unix)]
    {
        use std::os::unix::fs::OpenOptionsExt;
        output.mode(0o600);
    }
    let mut output = output.open(report).unwrap();
    writeln!(output, "{}", serde_json::json!({"version":2,"event":"ended","media_identity":Identity::from_key(&episode.id).unwrap(),"position_seconds":95.0,"duration_seconds":100.0,"completion_eligible":true})).unwrap();
    assert!(browser.state.poll_progress().unwrap());
    browser.rebuild_collections();
    assert!(browser.state.is_watched(&episode.id));
    assert!(
        !browser
            .state
            .contains(CollectionKind::Watching, &episode.id)
    );
    for kind in [CollectionKind::Watching, CollectionKind::WatchLater] {
        browser.collection(kind);
        if matches!(kind, CollectionKind::WatchLater) {
            browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
            assert_eq!(browser.screen().len(), 0);
            browser.key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::NONE));
            assert_eq!(browser.screen().len(), 1);
            browser.remove(true);
            browser.key(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
            assert!(browser.state.is_watched(&episode.id));
        }
        assert!(browser.state.contains(kind, &youtube.id));
    }
    let state = State::open(&browser.config_path).unwrap();
    assert!(state.contains(CollectionKind::Saved, &youtube.id));
    assert!(state.contains(CollectionKind::Watching, &youtube.id));
}

#[test]
fn selected_episode_and_offline_reopen_write_fresh_validated_source_sessions() {
    let directory = Directory::new();
    let mut browser = directory.browser(Some("anime"));
    catalog_results(&mut browser);
    enter_series(&mut browser);
    let first = browser.screen().selected_video().unwrap();
    browser.open();
    let stale = browser.generation;
    browser.select(Action::VideoNext);
    browser.accept(
        stale,
        Ok(Response::Source(
            first.clone(),
            Box::new(source(&first, "not-selected")),
        )),
    );
    assert!(sources(&directory).is_empty());
    let selected = browser.screen().selected_video().unwrap();
    assert_eq!(Identity::from_key(&selected.id).unwrap().episode, 7);
    browser.save(CollectionKind::Saved);
    browser.collection(CollectionKind::Saved);
    browser.open();
    browser.pending = None;
    browser.accept(
        browser.generation,
        Ok(Response::Source(
            selected.clone(),
            Box::new(source(&first, "wrong-identity")),
        )),
    );
    assert!(sources(&directory).is_empty());
    browser.open();
    browser.pending = None;
    let mut invalid = source(&selected, "private-token");
    invalid
        .headers
        .insert("X-Invalid".into(), "private-header\nvalue".into());
    browser.accept(
        browser.generation,
        Ok(Response::Source(selected.clone(), Box::new(invalid))),
    );
    assert!(sources(&directory).is_empty());
    assert!(!browser.status.contains("private-token"));
    assert!(!browser.status.contains("private-header"));
    for token in ["fresh-one", "fresh-two"] {
        browser.open();
        assert!(
            matches!(&browser.pending, Some(Request::Source(video)) if video.id == selected.id && video.title == selected.title)
        );
        browser.pending = None; // Deliver the real source response without a network request.
        browser.accept(
            browser.generation,
            Ok(Response::Source(
                selected.clone(),
                Box::new(source(&selected, token)),
            )),
        );
    }
    let written = sources(&directory);
    assert_eq!(written.len(), 2);
    assert!(
        written
            .iter()
            .all(|source| source["identity"]["episode"] == 7
                && source["identity"]["media_id"] == "first")
    );
    assert!(
        written
            .iter()
            .any(|source| source["url"].as_str().unwrap().ends_with("fresh-one"))
    );
    assert!(
        written
            .iter()
            .any(|source| source["url"].as_str().unwrap().ends_with("fresh-two"))
    );
    assert!(!browser.state.is_watched(&selected.id)); // Spawn failure/CLI completion is not progress.
    assert!(
        !browser
            .state
            .contains(CollectionKind::Watching, &selected.id)
    );
    assert!(browser.screen().error.is_some()); // Native launch errors remain visible.
}

#[test]
fn configured_modal_keys_and_inputs_do_not_leak_to_main_actions() {
    let directory = Directory::new();
    let mut browser = directory.browser(Some("anime"));
    catalog_results(&mut browser);
    let overrides: toml_edit::DocumentMut =
        "[keys]\nchannel.tags = 'f2'\ntags.new = 'f3'\ntags.save = 'f4'\ninput.submit = 'f5'\n"
            .parse()
            .unwrap();
    browser.config.keys = crate::keys::Bindings::from_toml(overrides.get("keys")).unwrap();
    browser.key(KeyEvent::new(KeyCode::F(2), KeyModifiers::NONE));
    assert_eq!(browser.context(), Context::TagList);
    browser.key(KeyEvent::new(KeyCode::F(3), KeyModifiers::NONE));
    assert_eq!(browser.context(), Context::TagInput);
    browser.paste("Safe");
    browser.key(KeyEvent::new(KeyCode::Char('\u{7}'), KeyModifiers::NONE));
    browser.key(KeyEvent::new(KeyCode::F(5), KeyModifiers::NONE));
    assert_eq!(browser.context(), Context::TagList);
    browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(browser.state.shows().is_empty());
    assert_eq!(browser.index, 0);
    browser.key(KeyEvent::new(KeyCode::F(4), KeyModifiers::NONE));
    assert_eq!(
        browser.state.shows()[0].tags,
        BTreeSet::from(["Safe".into()])
    );
    assert!(browser.modal.is_none());
}

#[test]
fn checked_show_categories_survive_hover_and_filter_changes() {
    let directory = Directory::new();
    let mut browser = directory.browser(None);
    for (id, tag) in [("first", "Drama"), ("second", "Favorites")] {
        browser
            .state
            .save_show(&media(id), &[tag.into()].into())
            .unwrap();
    }
    for filter in [None, Some("no matching category")] {
        browser.category_picker();
        for code in [KeyCode::Char('j'), KeyCode::Char(' '), KeyCode::Char('k')] {
            browser.key(KeyEvent::new(code, KeyModifiers::NONE));
        }
        if let Some(filter) = filter {
            browser.key(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));
            browser.paste(filter);
        }
        browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
        let Content::Library { shows, .. } = &browser.screen().content else {
            panic!("Checked categories must open even without a hovered match");
        };
        assert_eq!(
            shows
                .iter()
                .map(|show| show.media.id.as_str())
                .collect::<Vec<_>>(),
            ["first"]
        );
    }
}

#[test]
fn saved_shows_stage_cancel_reopen_and_remove_without_touching_episodes() {
    let directory = Directory::new();
    let mut browser = directory.browser(Some("anime"));
    catalog_results(&mut browser);
    let key = |browser: &mut Browser, code| {
        browser.key(KeyEvent::new(code, KeyModifiers::NONE));
    };
    key(&mut browser, KeyCode::Char('s'));
    key(&mut browser, KeyCode::Char('n'));
    browser.paste("Drama");
    key(&mut browser, KeyCode::Enter);
    key(&mut browser, KeyCode::Esc);
    assert!(browser.state.shows().is_empty());
    key(&mut browser, KeyCode::Char('s'));
    key(&mut browser, KeyCode::Enter);
    assert!(browser.state.shows()[0].tags.is_empty());
    enter_series(&mut browser);
    browser.select(Action::VideoNext);
    browser.save(CollectionKind::Saved);
    let episode = browser.screen().selected_video().unwrap().id;
    key(&mut browser, KeyCode::Char('s'));
    for tag in ["Drama", "Favorites"] {
        key(&mut browser, KeyCode::Char('n'));
        browser.paste(tag);
        key(&mut browser, KeyCode::Enter);
    }
    key(&mut browser, KeyCode::Enter);
    assert_eq!(browser.state.shows()[0].media.id, "first");
    browser
        .state
        .save_show(&media("second"), &BTreeSet::from(["Drama".into()]))
        .unwrap();
    assert_eq!(
        library_shows(
            &browser.state,
            &BTreeSet::from(["Drama".into(), "Favorites".into()])
        )
        .len(),
        2
    );
    browser.state = State::open(&browser.config_path).unwrap();
    key(&mut browser, KeyCode::Char('c'));
    key(&mut browser, KeyCode::Char('i'));
    browser.paste("Favorites");
    key(&mut browser, KeyCode::Enter);
    assert_eq!(browser.screen().len(), 1);
    browser.open();
    assert!(
        matches!(&browser.pending, Some(Request::Episodes { media_id, .. }) if media_id == "first")
    );
    browser.history(false);
    browser.library(BTreeSet::new());
    key(&mut browser, KeyCode::Char('x'));
    assert_eq!(browser.screen().len(), 1);
    browser.history(false);
    assert_eq!(browser.screen().len(), 0);
    assert!(browser.state.contains(CollectionKind::Saved, &episode));
    assert_eq!(
        State::open(&browser.config_path).unwrap().shows()[0]
            .media
            .id,
        "second"
    );
}

#[test]
fn empty_errors_and_query_controls_do_not_create_results_or_commands() {
    let directory = Directory::new();
    let mut browser = directory.browser(None);
    assert!(browser.pending.is_none());
    browser.open();
    assert_eq!(browser.index, 0);
    browser.edit_search();
    browser.paste("Anime\nquery\t\u{1b}[31m");
    browser.key(KeyEvent::new(KeyCode::Char('\u{7}'), KeyModifiers::NONE));
    assert!(
        browser
            .input
            .as_ref()
            .unwrap()
            .chars()
            .all(|ch| !ch.is_control())
    );
    browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    let old = browser.generation;
    browser.accept(old, Err(io::Error::other("Catalog request failed")));
    assert!(browser.screen().error.is_some());
    assert_eq!(browser.screen().len(), 0);
    browser.search();
    browser.accept(browser.generation, Ok(Response::Catalog(Vec::new())));
    assert!(browser.screen().error.is_none());
    assert!(matches!(
        browser.screen().content,
        Content::Catalog { searched: true, .. }
    ));
    browser.edit_search();
    browser.input = Some("  ".into());
    browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    assert!(browser.pending.is_none());
    assert!(matches!(
        browser.screen().content,
        Content::Catalog {
            searched: false,
            ..
        }
    ));
    browser.accept(old, Ok(Response::Catalog(vec![media("stale")])));
    assert_eq!(browser.screen().len(), 0);
    assert!(browser.screen().rows.is_empty());
    fs::write(
        &browser.config_path,
        "[keys]\nsearch.edit = 'f8'\napp.quit = 'f9'\n",
    )
    .unwrap();
    browser.config = config::load(&browser.config_path).unwrap();
    browser.key(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
    assert!(browser.input.is_some());
    browser.input = Some("safe".into());
    browser.key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
    let metadata = miruro_browser::catalog(vec![serde_json::json!({
        "id":"safe", "title":{"english":"薬屋 Café\u{1b}[31m"},
        "description":"<p>First\u{1b}[31m</p><p>Second<br/>Third</p>"
    })])
    .unwrap();
    browser.accept(browser.generation, Ok(Response::Catalog(metadata)));
    assert!(
        browser
            .screen()
            .rows
            .iter()
            .all(|row| row.title.chars().all(|ch| !ch.is_control()))
    );
    assert!(
        browser
            .screen()
            .description
            .chars()
            .all(|ch| !ch.is_control() || ch == '\n')
    );
    assert!(!browser.key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE)));
    assert!(browser.key(KeyEvent::new(KeyCode::F(9), KeyModifiers::NONE)));
}