Skip to content

LG webOS TV launcher: a fast, remote-first home screen with live video wallpapers, widgets, Jellyfin, Moonlight game streaming and Home Assistant. Native Rust + OpenGL ES.

122 KB
Raw Blame
use crate::{
    model::{App, Input, InputMode, Preferences, demo_inventory},
    platform::{normalize_apps, normalize_inputs},
    state::{Direction, Effect, Overlay, Page, State, Target},
    storage, view,
};
use serde_json::json;
use std::{collections::BTreeMap, path::PathBuf};

fn ready() -> State {
    let mut state = State::new(Preferences::default());
    state.set_inventory(demo_inventory(), None);
    state
}

fn scene(state: &State) -> view::Scene {
    let assets = view::Assets {
        root: PathBuf::new(),
        version: "test".into(),
        metrics: BTreeMap::new(),
        catalog_metrics: BTreeMap::new(),
        active_heading: std::cell::Cell::new(crate::typography::HeadingFont::default()),
        active_text: std::cell::Cell::new(crate::typography::TextFont::default()),
        heading_pct: std::cell::Cell::new(state.preferences.heading_size_pct),
        text_pct: std::cell::Cell::new(state.preferences.text_size_pct),
        artwork: crate::app_artwork::Service::new(false),
    };
    let navigation = view::navigation_for(&assets, state.preferences.language, false);
    view::scene_with_pill(
        state,
        &assets,
        navigation.items[state.page_index()].x,
        navigation.items[state.page_index()].w,
        time::OffsetDateTime::UNIX_EPOCH,
    )
}

fn controls(state: &State) -> Vec<crate::state::Control> {
    scene(state).controls
}

#[test]
fn remote_routes_from_header_and_back_through_settings() {
    let mut state = ready();
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::App("netflix".into()));
    state.direction(Direction::Up, &controls(&state));
    assert_eq!(state.focus, Target::Nav(0));
    state.open(2);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Sidebar(0));
    state.activate();
    assert_eq!(state.focus, Target::Setting(0));
    assert!(state.back().is_empty());
    assert_eq!(state.focus, Target::Sidebar(0));
    state.back();
    assert_eq!(state.focus, Target::Nav(2));
    state.back();
    assert_eq!(state.page, Page::Home);
    assert_eq!(state.back(), vec![Effect::Quit]);
}

#[test]
fn hiding_restores_nearest_app_and_hidden_filter_can_restore_it() {
    let mut state = ready();
    state.open(1);
    state.focus = Target::App("netflix".into());
    state.options();
    state.focus = Target::Option(1);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.hidden.contains(&"netflix".into()));
    assert_eq!(state.focus, Target::App("youtube.leanback.v4".into()));
    state.filter = 5;
    assert_eq!(state.apps().len(), 1);
    state.focus = Target::App("netflix".into());
    state.options();
    state.focus = Target::Option(1);
    state.activate();
    assert!(state.preferences.hidden.is_empty());
    assert_eq!(state.focus, Target::App("netflix".into()));
    assert_eq!(state.filter, 0);
}

#[test]
fn reorder_persists_order_and_keeps_selected_identity() {
    let mut state = ready();
    state.focus = Target::App("netflix".into());
    state.hold();
    assert_eq!(
        state.direction(Direction::Right, &controls(&state)),
        vec![Effect::Save]
    );
    assert_eq!(
        &state.preferences.favorites(&state.inventory.apps)[..2],
        &["youtube.leanback.v4", "netflix"]
    );
    assert_eq!(state.focus, Target::App("netflix".into()));
    assert!(state.back().is_empty());
    assert!(state.moving.is_none());
}

#[test]
fn keyboard_is_modal_and_back_preserves_then_clears_search() {
    let mut state = ready();
    state.open(1);
    state.focus = Target::Search;
    state.activate();
    assert!(
        controls(&state)
            .iter()
            .all(|c| matches!(c.target, Target::Key(_) | Target::CloseDialog))
    );
    state.text("netflix");
    state.delete();
    state.text("x");
    state.back();
    assert_eq!(state.query, "netflix");
    assert_eq!(state.focus, Target::Search);
    assert_eq!(state.apps().len(), 1);
    state.back();
    assert!(state.query.is_empty());
    assert_eq!(state.focus, Target::Nav(1));
    assert_eq!(state.page, Page::Apps);
}

#[test]
fn partial_refresh_preserves_valid_inputs_and_never_invents_tv_apps() {
    let mut state = ready();
    state.set_inventory(
        crate::model::Inventory::default(),
        Some("Inputs unavailable".into()),
    );
    assert!(state.inventory.apps.is_empty());
    assert_eq!(state.inventory.inputs.len(), 3);
    assert_eq!(state.first_content(), Target::Browse);
}

#[test]
fn inventory_filters_system_apps_duplicates_and_unsafe_identifiers() {
    let apps = normalize_apps(&json!([
        {"id":"netflix","title":" Netflix\n"}, {"id":"netflix","title":"Duplicate"},
        {"id":"bad;command","title":"Bad"}, {"id":"com.webos.app.hidden","title":"Internal"},
        {"id":"com.webos.app.livetv","visible":false,"title":"Live TV"},
        {"id":"com.luma.launcher.native","visible":true},
        {"id":"com.webos.app.hdmi1","visible":true},
        {"id":"hidden","visible":"false"}
    ]))
    .unwrap();
    assert_eq!(apps.len(), 2);
    assert_eq!(
        apps.iter().find(|a| a.id == "netflix").unwrap().title,
        "Netflix"
    );
    assert!(normalize_apps(&json!({"apps":[]})).is_err());
    let inputs = normalize_inputs(&json!([
        {"appId":"com.webos.app.hdmi1","id":"HDMI_1","port":1,"connected":true},
        {"appId":"com.webos.app.hdmi2","id":"HDMI_4"},
        {"appId":"com.webos.app.hdmi3"}, {"appId":"com.webos.app.hdmi3"},
        {"appId":"com.webos.app.hdmi4","label":"Console"}
    ]))
    .unwrap();
    assert_eq!(inputs.len(), 2);
    assert_eq!(inputs[1].connected, None);
}

#[test]
fn inventory_visibility_cases_match_the_launcher_filters() {
    let cases: Vec<serde_json::Value> =
        serde_json::from_str(include_str!("../tests/fixtures/app-visibility.json")).unwrap();
    let inventory: Vec<_> = cases.iter().map(|case| case["app"].clone()).collect();
    let actual: std::collections::BTreeSet<_> = normalize_apps(&json!(inventory))
        .unwrap()
        .into_iter()
        .map(|app| app.id)
        .collect();
    let expected: std::collections::BTreeSet<_> = cases
        .iter()
        .filter(|case| case["include"] == true)
        .map(|case| case["app"]["id"].as_str().unwrap().to_owned())
        .collect();
    assert_eq!(actual, expected);
}

#[test]
fn asset_loading_and_unknown_app_cards_do_not_require_collected_artwork() {
    let root = std::env::temp_dir().join(format!("luma-assets-no-dumps-{}", std::process::id()));
    std::fs::create_dir_all(&root).unwrap();
    std::fs::write(root.join("version.txt"), "test").unwrap();
    std::fs::write(root.join("font-metrics.json"), "{}").unwrap();
    for webos in [false, true] {
        let assets = view::Assets::load(root.clone(), webos).unwrap();
        let mut state = State::new(Preferences::default());
        state.set_inventory(
            crate::model::Inventory {
                apps: vec![App::new("com.example.regional", "Regional App")],
                inputs: vec![],
            },
            None,
        );
        state.open(1);
        let scene = view::scene_with_pill(
            &state,
            &assets,
            800.,
            100.,
            time::OffsetDateTime::UNIX_EPOCH,
        );
        assert!(scene.draw.iter().any(|draw| matches!(draw,
            crate::renderer::Draw::TintedImage(path, ..) if path.ends_with("ui-icons/generic.lvec"))));
        assert!(scene.draw.iter().any(|draw| matches!(draw,
            crate::renderer::Draw::Text(value, ..) if value == "Regional App")));
    }
    std::fs::remove_dir_all(root).unwrap();
}

#[test]
fn auto_input_visibility_requires_a_positive_connection_report() {
    let mut preferences = Preferences::default();
    let mut input = Input {
        id: "com.webos.app.hdmi1".into(),
        title: "Console".into(),
        port: "HDMI 1".into(),
        connected: None,
        signal: None,
    };
    assert!(!preferences.input_visible(&input));
    input.connected = Some(true);
    assert!(preferences.input_visible(&input));
    preferences
        .input_modes
        .insert(input.id.clone(), InputMode::Off);
    assert!(!preferences.input_visible(&input));
    preferences
        .input_modes
        .insert(input.id.clone(), InputMode::On);
    input.connected = Some(false);
    assert!(preferences.input_visible(&input));
}

#[test]
fn preferences_round_trip_and_corrupt_data_is_not_silently_overwritten() {
    let directory = std::env::temp_dir().join(format!("luma-native-test-{}", std::process::id()));
    let path = directory.join("preferences.json");
    let mut preferences = Preferences {
        favorites: Some(vec![]),
        background: "forest".into(),
        ..Preferences::default()
    };
    preferences
        .input_modes
        .insert("com.webos.app.hdmi1".into(), InputMode::Off);
    storage::save(&path, &preferences).unwrap();
    let loaded = storage::load(&path).unwrap();
    assert_eq!(loaded.favorites, Some(vec![]));
    assert_eq!(loaded.background, "forest");
    assert_eq!(loaded.input_modes["com.webos.app.hdmi1"], InputMode::Off);
    std::fs::write(&path, "broken").unwrap();
    assert!(storage::load(&path).is_err());
    std::fs::remove_dir_all(directory).unwrap();
}

#[test]
fn home_clip_extends_to_screen_bottom_without_changing_other_pages() {
    let mut state = ready();
    for (page, expected_bottom, expected_left, expected_width) in [
        (Page::Home, 1080., 0., 1920.),
        (Page::Apps, 1080., 64., 1792.),
        (Page::Settings, 994.4, 0., 1920.),
    ] {
        state.page = page;
        assert_eq!(state.main_bottom(), expected_bottom);
        let clip = scene(&state)
            .draw
            .into_iter()
            .find_map(|draw| match draw {
                crate::renderer::Draw::Clip(Some(rect)) => Some(rect),
                _ => None,
            })
            .expect("page content clip");
        assert_eq!(clip.x, expected_left);
        assert_eq!(clip.y, if page == Page::Settings { 0. } else { 108.8 });
        assert_eq!(clip.w, expected_width);
        assert!((clip.y + clip.h - expected_bottom).abs() < 0.01);
        let inset = if page == Page::Settings { 12. } else { 64. };
        assert_eq!(state.focus_bottom(), expected_bottom - inset);
    }
    state.page = Page::Home;
    state.moving = Some("test".to_string());
    assert_eq!(state.main_bottom(), 994.4);
}

#[test]
fn favorites_scroll_uses_physical_edges_and_card_aligned_focus() {
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.page = Page::Home;
    state.preferences.favorites = Some(
        state
            .inventory
            .apps
            .iter()
            .take(8)
            .map(|app| app.id.clone())
            .collect(),
    );
    let target_id = state.apps()[1].id.clone();
    state.focus(Target::App(target_id.clone()), &controls(&state));
    let card = controls(&state)
        .into_iter()
        .find(|control| control.target == Target::App(target_id.clone()))
        .expect("focused favorite card");
    assert!(
        (card.rect.x - (crate::state::HOME_STRIP_LEFT + crate::state::HOME_TILE_PITCH)).abs()
            < 0.01
    );
    assert_eq!(state.home_scroll_goal, 0.);
    assert!(
        (state.home_scroll / crate::state::HOME_TILE_PITCH)
            .fract()
            .abs()
            < 0.01
    );

    state.home_scroll = 0.;
    state.home_scroll_goal = 0.;
    state.scroll_favorites(crate::state::HOME_TILE_PITCH * 0.6);
    state.tick();
    let expected_scroll = state.home_scroll_max().min(crate::state::HOME_TILE_PITCH);
    assert!((state.home_scroll - expected_scroll).abs() < 0.01);

    let scene = scene(&state);
    let clip = scene
        .draw
        .iter()
        .find_map(|draw| match draw {
            crate::renderer::Draw::Clip(Some(rect)) => Some(*rect),
            _ => None,
        })
        .expect("vertical body clip");
    assert_eq!(clip.x, crate::state::HOME_VIEWPORT_LEFT);
    assert_eq!(
        clip.w,
        crate::state::HOME_VIEWPORT_RIGHT - crate::state::HOME_VIEWPORT_LEFT
    );
    let first = scene
        .controls
        .iter()
        .find(|control| control.target == Target::App(state.apps()[0].id.clone()))
        .expect("first favorite control");
    if state.home_scroll > 0. {
        assert!(first.rect.x < crate::state::HOME_VIEWPORT_LEFT);
        assert!(first.rect.x + first.rect.w > crate::state::HOME_VIEWPORT_LEFT);
    } else {
        assert_eq!(first.rect.x, crate::state::HOME_STRIP_LEFT);
    }
}

#[test]
fn favorites_remote_focus_scrolls_only_at_physical_edges() {
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.page = Page::Home;
    state.preferences.favorites = Some(
        state
            .inventory
            .apps
            .iter()
            .take(8)
            .map(|app| app.id.clone())
            .collect(),
    );
    let ids: Vec<_> = state.apps().iter().map(|app| app.id.clone()).collect();
    state.focus(Target::App(ids[0].clone()), &controls(&state));

    for id in &ids[1..=5] {
        state.direction(Direction::Right, &controls(&state));
        assert_eq!(state.focus, Target::App(id.clone()));
        assert_eq!(state.home_scroll_goal, 0.);
    }

    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.focus, Target::App(ids[6].clone()));
    assert!(
        (state.home_scroll_goal - crate::state::HOME_TILE_PITCH).abs() < 0.01,
        "edge focus should advance by one card pitch"
    );
    assert!((state.home_scroll - state.home_scroll_goal).abs() < 0.01);

    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::App(ids[5].clone()));
    assert!(
        (state.home_scroll_goal - crate::state::HOME_TILE_PITCH).abs() < 0.01,
        "moving back inside the visible row must not undo the scroll"
    );
}

#[test]
fn home_inputs_are_header_circles_left_of_settings() {
    let mut state = ready();
    for input in &state.inventory.inputs {
        state
            .preferences
            .input_modes
            .insert(input.id.clone(), InputMode::On);
    }
    let home = controls(&state);
    let settings = home
        .iter()
        .find(|c| c.target == Target::TvSettings)
        .expect("TV settings circle");
    let circles: Vec<_> = home
        .iter()
        .filter(|c| matches!(c.target, Target::Input(_)))
        .collect();
    assert!(!circles.is_empty());
    for circle in circles {
        assert_eq!(circle.rect.h, 68.);
        assert_eq!(circle.rect.y, settings.rect.y);
        assert!(circle.rect.x < settings.rect.x);
    }
}
#[test]
fn gallery_and_grid_navigation_scroll_to_keep_focus_visible() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Sidebar(1);
    state.activate();
    state.focus = Target::WallpaperMenu(1);
    state.activate();
    assert_eq!(
        state.settings_level,
        crate::state::SettingsLevel::WallpaperPhotos
    );
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Background(4));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Background(8));
    state.back();
    assert_eq!(state.focus, Target::WallpaperMenu(1));
    state.back();
    assert_eq!(state.focus, Target::Sidebar(1));
    state.open(1);
    let last = state.apps().last().unwrap().id.clone();
    state.focus(Target::App(last), &controls(&state));
    assert!(state.scroll_goal > 0.);
}

#[test]
fn cancelling_options_preserves_identity_and_does_not_save() {
    let mut state = ready();
    state.focus = Target::App("netflix".into());
    state.options();
    assert!(matches!(state.overlay, Some(Overlay::Options { .. })));
    state.focus = Target::CloseDialog;
    assert!(state.activate().is_empty());
    assert_eq!(state.focus, Target::App("netflix".into()));
    assert!(state.overlay.is_none());
}

#[test]
fn pointer_focus_does_not_scroll_the_clicked_control() {
    let mut state = ready();
    state.open(1);
    state.scroll = 150.;
    state.pointer_focus(Target::App("netflix".into()));
    assert_eq!(state.scroll, 150.);
    state.focus(Target::Nav(1), &controls(&state));
    assert_eq!(state.scroll_goal, 0.);
    assert_eq!(state.scroll, 150.);
    state.tick();
    assert!(state.scroll < 150.);
}

#[test]
fn gallery_right_crosses_rows_in_gallery_order() {
    let mut state = ready();
    state.open(2);
    state.section = 1;
    state.focus = Target::Background(2);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.focus, Target::Background(3));
}

#[test]
fn reordering_skips_hidden_and_unavailable_favorite_slots() {
    let mut state = ready();
    state.preferences.favorites = Some(vec![
        "netflix".into(),
        "missing".into(),
        "youtube.leanback.v4".into(),
        "amazon".into(),
    ]);
    state.preferences.hidden.push("youtube.leanback.v4".into());
    state.focus = Target::App("netflix".into());
    state.hold();
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(
        state.preferences.favorites.unwrap(),
        vec!["amazon", "missing", "youtube.leanback.v4", "netflix"]
    );
    assert_eq!(state.focus, Target::App("netflix".into()));
}

#[test]
fn focused_navigation_tabs_switch_pages_immediately() {
    let mut state = ready();
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.page, Page::Apps);
    assert_eq!(state.focus, Target::Nav(1));
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.page, Page::Settings);
    assert_eq!(state.focus, Target::Nav(2));
}

#[test]
fn greeting_subpage_opens_the_keyboard_and_back_restores_its_parent() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Setting(6);
    assert!(
        state
            .direction(Direction::Right, &controls(&state))
            .is_empty()
    );
    assert_eq!(state.subpage, Some(crate::state::Subpage::Greeting));
    assert_eq!(state.focus, Target::GreetingStyle);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::GreetingName);
    assert!(!state.text_input_active());
    assert!(state.activate().is_empty());
    assert!(state.text_input_active());
    state.text("Ana");
    assert_eq!(state.editing_text(), "Ana");
    assert!(state.preferences.greeting_name.is_empty());
    assert_eq!(state.finish_text_input(), vec![Effect::Save]);
    assert_eq!(state.focus, Target::GreetingName);
    assert!(state.finish_text_input().is_empty());
    assert_eq!(
        crate::i18n::Language::En.greeting(9, &state.preferences.greeting_name),
        "Good morning, Ana."
    );
    assert_eq!(state.subpage, Some(crate::state::Subpage::Greeting));
    assert!(state.back().is_empty());
    assert!(state.subpage.is_none());
    assert_eq!(state.focus, Target::Setting(6));
}

#[test]
fn greeting_name_replacement_commits_on_every_keyboard_completion_route() {
    for route in 0..3 {
        let mut state = ready();
        state.preferences.greeting_name = "Ana".into();
        state.open(2);
        state.focus = Target::Setting(6);
        state.activate();
        state.direction(Direction::Down, &controls(&state));
        state.activate();
        assert!(state.editing_text().is_empty());
        state.text("  BobX ");
        state.delete_surrounding_text(-3, 3);
        assert_eq!(state.editing_text(), "  Bo");
        state.text("b  ");
        assert_eq!(state.preferences.greeting_name, "Ana");
        let effects = match route {
            0 => {
                state.overlay = Some(Overlay::SystemKeyboard);
                state.finish_text_input()
            }
            1 => state.back(),
            _ => {
                state.focus = Target::Key(crate::state::KEYS.len() - 1);
                state.activate()
            }
        };
        assert_eq!(effects, vec![Effect::Save]);
        assert_eq!(state.preferences.greeting_name, "Bob");
        assert_eq!(state.focus, Target::GreetingName);
        assert!(state.finish_text_input().is_empty());
        state.activate();
        state.text("   ");
        assert!(state.back().is_empty());
        assert_eq!(state.preferences.greeting_name, "Bob");
    }
}

#[test]
fn remote_can_clear_a_saved_greeting_name_without_moving_the_controls() {
    let mut state = ready();
    state.preferences.greeting_name = "Ana".into();
    state.open(2);
    state.focus = Target::Setting(6);
    state.activate();
    state.direction(Direction::Down, &controls(&state));
    let before: Vec<_> = controls(&state)
        .iter()
        .map(|c| (c.target.clone(), c.rect.y))
        .collect();
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::GreetingNameClear);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.greeting_name.is_empty());
    assert_eq!(state.focus, Target::GreetingName);
    let after: Vec<_> = controls(&state)
        .iter()
        .map(|c| (c.target.clone(), c.rect.y))
        .collect();
    assert_eq!(
        before.iter().map(|(target, _)| target).collect::<Vec<_>>(),
        after.iter().map(|(target, _)| target).collect::<Vec<_>>()
    );
    assert!(
        before
            .iter()
            .zip(after.iter())
            .all(|(a, b)| (a.1 - b.1).abs() < 1.)
    );
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::Setting(6));
    assert!(state.subpage.is_none());
}

#[test]
fn app_name_settings_use_independent_defaults_including_with_legacy_preferences() {
    let old: Preferences = serde_json::from_value(json!({"show_names": true})).unwrap();
    assert!(!old.show_home_names);
    assert!(old.show_app_names);
    let mut state = ready();
    assert!(!state.preferences.show_home_names);
    assert!(state.preferences.show_app_names);
    state.open(2);
    state.focus = Target::Setting(0);
    assert!(
        state
            .direction(Direction::Right, &controls(&state))
            .is_empty()
    );
    assert_eq!(state.subpage, Some(crate::state::Subpage::AppNames));
    assert_eq!(state.focus, Target::AppNamesHome);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.show_home_names);
    assert!(state.preferences.show_app_names);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::AppNamesApps);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.show_home_names);
    assert!(!state.preferences.show_app_names);
    assert_eq!(state.subpage, Some(crate::state::Subpage::AppNames));
    let restored: Preferences =
        serde_json::from_value(serde_json::to_value(&state.preferences).unwrap()).unwrap();
    assert!(restored.show_home_names);
    assert!(!restored.show_app_names);
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::Setting(0));
    assert!(state.subpage.is_none());
}

#[test]
fn home_and_apps_render_only_their_own_caption_preference() {
    let mut state = ready();
    for (home, apps) in [(false, true), (true, false), (true, true), (false, false)] {
        state.preferences.show_home_names = home;
        state.preferences.show_app_names = apps;
        for (page, expected) in [(0, home), (1, apps)] {
            state.open(page);
            let scene = scene(&state);
            let caption = scene.draw.iter().any(
                |draw| matches!(draw, crate::renderer::Draw::Text(value, ..) if value == "Netflix"),
            );
            assert_eq!(caption, expected, "Home={home}, Apps={apps}, page={page}");
            let card = scene
                .controls
                .iter()
                .find(|c| c.target == Target::App("netflix".into()))
                .unwrap();
            assert_eq!(
                card.rect.h > 154.4,
                expected,
                "Hidden captions must not reserve space"
            );
        }
    }
}

#[test]
fn input_name_actions_only_highlight_the_focused_row_and_keep_the_saved_mode() {
    let mut state = ready();
    legacy_look(&mut state.preferences);
    state.preferences.reduced_motion = true;
    state
        .preferences
        .set_input_name("com.webos.app.hdmi1", "Console");
    state.open(2);
    state.focus = Target::Sidebar(crate::state::INPUTS_SECTION);
    state.activate();
    state.focus = Target::InputMode("com.webos.app.hdmi1".into());
    state.activate();
    for target in [Target::InputRename, Target::InputNameReset] {
        state.pointer_focus(target.clone());
        let screen = scene(&state);
        assert!(screen.controls.iter().any(|c| c.target == target));
        assert!(screen.draw.iter().any(|d| matches!(d,
            crate::renderer::Draw::Shape(_, 16., 0., rgba) if rgba[3] > 0.99)));
        assert_eq!(
            state
                .preferences
                .input_modes
                .get("com.webos.app.hdmi1")
                .copied()
                .unwrap_or_default(),
            InputMode::Auto
        );
        assert!(screen.draw.iter().any(|d| matches!(d,
            crate::renderer::Draw::Text(value, ..) if value == "Clear name")));
    }
}

#[test]
fn clock_choices_only_highlight_focus_while_preserving_saved_checkmarks() {
    let mut state = ready();
    legacy_look(&mut state.preferences);
    state.preferences.reduced_motion = true;
    state.preferences.show_seconds = true;
    state.open(2);
    state.focus = Target::Sidebar(0);
    state.activate();
    state.focus = Target::Setting(1);
    state.activate();
    state.focus = Target::ClockTimeFormat;
    state.activate();
    for index in 0..2 {
        state.pointer_focus(Target::Choice(index));
        let screen = scene(&state);
        assert!(
            screen
                .controls
                .iter()
                .any(|c| c.target == Target::Choice(index))
        );
        assert!(screen.draw.iter().any(|d| matches!(d,
            crate::renderer::Draw::Shape(_, 16., 0., rgba) if rgba[3] > 0.99)));
        assert!(state.preferences.show_seconds);
    }
}

#[test]
fn clock_format_subpage_saves_and_restores_its_parent_row() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Setting(1);
    assert!(
        state
            .direction(Direction::Right, &controls(&state))
            .is_empty()
    );
    assert_eq!(state.subpage, Some(crate::state::Subpage::Clock));
    assert_eq!(state.focus, Target::ClockFormat);
    assert!(
        state
            .direction(Direction::Right, &controls(&state))
            .is_empty()
    );
    assert_eq!(state.subpage, Some(crate::state::Subpage::ClockFormat));
    assert_eq!(state.focus, Target::Choice(0));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.hour_24);
    assert!(!state.preferences.show_seconds);
    assert_eq!(state.subpage, Some(crate::state::Subpage::Clock));
    assert_eq!(state.focus, Target::ClockFormat);
    state.direction(Direction::Left, &controls(&state));
    assert!(state.subpage.is_none());
    assert_eq!(state.focus, Target::Setting(1));
    state.activate();
    state.activate();
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.subpage, Some(crate::state::Subpage::Clock));
    assert_eq!(state.focus, Target::ClockFormat);
    state.back();
    assert_eq!(state.focus, Target::Setting(1));
    assert!(state.subpage.is_none());
}

#[test]
fn time_format_selects_seconds_without_changing_the_hour_format() {
    let mut state = ready();
    state.preferences.hour_24 = true;
    state.open(2);
    state.focus = Target::Setting(1);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.subpage, Some(crate::state::Subpage::Clock));
    assert!(!state.preferences.show_seconds);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::ClockTimeFormat);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.subpage, Some(crate::state::Subpage::TimeFormat));
    assert_eq!(state.focus, Target::Choice(0));
    assert!(
        !controls(&state)
            .iter()
            .any(|c| c.target == Target::Choice(2))
    );
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Choice(1));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.show_seconds);
    assert!(state.preferences.hour_24);
    assert_eq!(state.subpage, Some(crate::state::Subpage::Clock));
    assert_eq!(state.focus, Target::ClockTimeFormat);
    state.activate();
    assert_eq!(state.focus, Target::Choice(1));
    state.back();
    assert_eq!(state.subpage, Some(crate::state::Subpage::Clock));
    assert_eq!(state.focus, Target::ClockTimeFormat);
    state.activate();
    state.direction(Direction::Up, &controls(&state));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(!state.preferences.show_seconds);
    assert!(state.preferences.hour_24);
    state.back();
    assert!(state.subpage.is_none());
    assert_eq!(state.focus, Target::Setting(1));
}

#[test]
fn system_category_owns_refresh_and_quit_and_restores_sidebar_focus() {
    let mut state = ready();
    state.open(2);
    assert!(
        !controls(&state)
            .iter()
            .any(|c| matches!(c.target, Target::Setting(3 | 5)))
    );
    assert!(
        controls(&state)
            .iter()
            .any(|c| c.target == Target::Sidebar(crate::state::SYSTEM_SECTION))
    );
    state.focus = Target::Sidebar(crate::state::SYSTEM_SECTION - 1);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Sidebar(crate::state::SYSTEM_SECTION));
    assert_eq!(state.section, crate::state::SYSTEM_SECTION);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.focus, Target::Setting(3));
    assert_eq!(state.activate(), vec![Effect::Reload]);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Setting(5));
    assert_eq!(state.activate(), vec![Effect::Quit]);
    state.back();
    assert_eq!(state.focus, Target::Sidebar(crate::state::SYSTEM_SECTION));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Sidebar(0));
    assert_eq!(state.section, 0);
}

#[test]
fn input_visibility_has_explicit_choices_and_returns_to_the_same_input() {
    let mut state = ready();
    state.open(2);
    state.section = crate::state::INPUTS_SECTION;
    let id = "com.webos.app.hdmi1".to_string();
    state.focus = Target::InputMode(id.clone());
    state.activate();
    assert_eq!(state.focus, Target::Choice(2));
    state.direction(Direction::Up, &controls(&state));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.preferences.input_modes[&id], InputMode::Off);
    assert_eq!(state.focus, Target::InputMode(id.clone()));
    assert!(!state.preferences.input_visible(&state.inventory.inputs[0]));
    state.activate();
    state.back();
    assert_eq!(state.focus, Target::InputMode(id));
    assert!(state.subpage.is_none());
}

#[test]
fn background_entry_restores_the_applied_background() {
    let mut state = ready();
    state.open(2);
    state.preferences.background = "forest".into();
    state.focus = Target::Sidebar(1);
    state.activate();
    assert_eq!(state.focus, Target::WallpaperMenu(0));
    assert_eq!(state.settings_level, crate::state::SettingsLevel::Section);
    state.activate();
    assert_eq!(
        state.settings_level,
        crate::state::SettingsLevel::WallpaperType
    );
    state.back();
    assert_eq!(state.focus, Target::WallpaperMenu(0));
    state.back();
    assert_eq!(state.focus, Target::Sidebar(1));
    assert_eq!(state.preferences.background, "forest");
}

#[test]
fn categories_and_search_have_clear_actions_and_conditional_hidden_control() {
    let mut state = ready();
    state.open(1);
    assert!(
        !controls(&state)
            .iter()
            .any(|c| c.target == Target::Filter(5))
    );
    state.focus = Target::Search;
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::Filter(4));
    state.preferences.hidden.push("netflix".into());
    state.focus = Target::Search;
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::Filter(5));
    state.activate();
    assert_eq!(state.apps().len(), 1);
    state.query = "YouTube".into();
    state.focus = Target::ClearSearch;
    state.activate();
    assert!(state.query.is_empty());
    assert_eq!(state.focus, Target::Search);
}

#[test]
fn a_notice_does_not_escape_modal_focus_and_closing_restores_the_app() {
    let mut state = ready();
    state.open(1);
    state.notify("Saved");
    state.focus = Target::App("netflix".into());
    state.options();
    assert!(
        controls(&state)
            .iter()
            .all(|c| matches!(c.target, Target::Option(_) | Target::CloseDialog))
    );
    state.focus = Target::Option(1);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Option(1));
    state.back();
    assert_eq!(state.focus, Target::App("netflix".into()));
}

#[test]
fn remote_toolbar_focus_normalizes_scroll_but_hover_does_not() {
    let mut state = ready();
    state.open(1);
    state.scroll = 100.;
    state.pointer_focus(Target::Filter(1));
    assert_eq!(state.scroll, 100.);
    state.focus(Target::Filter(2), &controls(&state));
    assert_eq!(state.scroll_goal, 0.);
    state.tick();
    assert!(state.scroll <= 100.);
}

#[test]
fn long_captions_expand_rows_without_overlapping_the_next_row() {
    let mut state = ready();
    state.open(1);
    state.inventory.apps.iter_mut().find(|app| app.id == "netflix").unwrap().title = "A very long installed application title that needs more than two lines to remain fully readable".into();
    let targets = controls(&state);
    let title = targets
        .iter()
        .find(|c| c.target == Target::App("netflix".into()))
        .unwrap();
    let next_id = state.apps()[6].id.clone();
    let next = targets
        .iter()
        .find(|c| c.target == Target::App(next_id.clone()))
        .unwrap();
    assert!(title.rect.h > 240.);
    assert!(next.rect.y > title.rect.y + title.rect.h);
}

#[test]
fn reduced_motion_disables_panel_wallpaper_and_notification_animation() {
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open(2);
    state.focus = Target::Setting(1);
    state.activate();
    assert!(!state.animating());
    state.back();
    state.focus = Target::Background(6);
    state.activate();
    state.notify("Saved");
    assert!(!state.animating());
}

#[test]
fn pinning_a_hidden_app_restores_it_and_leaves_hidden_when_empty() {
    let mut state = ready();
    state.open(1);
    state.filter = 5;
    state.preferences.hidden.push("org.jellyfin.webos".into());
    state.focus = Target::App("org.jellyfin.webos".into());
    state.options();
    state.activate();
    assert!(state.preferences.hidden.is_empty());
    assert_eq!(state.filter, 0);
    assert!(
        state
            .preferences
            .favorites(&state.inventory.apps)
            .contains(&"org.jellyfin.webos".into())
    );
    assert_eq!(state.focus, Target::App("org.jellyfin.webos".into()));
}

#[test]
fn weather_location_keyboard_back_and_sidebar_routes_restore_focus() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Sidebar(crate::state::WEATHER_SECTION);
    state.section = crate::state::WEATHER_SECTION;
    // The sidebar row is Widgets now; Weather is its fourth row.
    state.activate();
    assert_eq!(state.focus, Target::WidgetRow(0));
    for _ in 0..3 {
        state.direction(Direction::Down, &controls(&state));
    }
    assert_eq!(state.focus, Target::WidgetRow(3));
    state.activate();
    assert_eq!(state.focus, Target::WeatherToggle);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::WeatherLocation);
    state.activate();
    assert_eq!(state.focus, Target::WeatherQuery);
    state.activate();
    state.text("Vienna");
    state.back();
    assert_eq!(state.focus, Target::WeatherSearch);
    assert_eq!(state.weather.query, "Vienna");
    assert_eq!(state.subpage, Some(crate::state::Subpage::WeatherLocation));
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::WeatherLocation);
    assert!(state.subpage.is_none());
}

#[test]
fn weather_units_save_without_replacing_celsius_cache_and_hide_keeps_city() {
    let mut state = ready();
    state.open(2);
    state.section = crate::state::WEATHER_SECTION;
    let place = crate::weather::Location {
        name: "Vienna".into(),
        region: "Vienna".into(),
        country: "Austria".into(),
        latitude: 48.2085,
        longitude: 16.3721,
    };
    state.preferences.weather_location = Some(place.clone());
    state.weather.cache = Some(crate::weather::Cache {
        key: place.key(),
        updated_at: 1000,
        reading: crate::weather::Reading {
            temperature: 14.2,
            code: 2,
            is_day: true,
            wind_speed: 0.,
            temperature_3h_ago: None,
            hours: [None; 5],
        },
    });
    state.focus = Target::WeatherTemperature;
    state.activate();
    assert_eq!(state.focus, Target::Choice(0));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(
        state.preferences.temperature_unit,
        crate::weather::Unit::Fahrenheit
    );
    assert_eq!(
        state.weather.cache.as_ref().unwrap().reading.temperature,
        14.2
    );
    assert_eq!(state.focus, Target::WeatherTemperature);
    state.focus = Target::WeatherToggle;
    state.activate();
    assert!(!state.preferences.show_weather);
    assert_eq!(state.preferences.weather_location, Some(place));
}

#[test]
fn removing_weather_location_clears_cache_and_cancels_pending_results() {
    let mut state = ready();
    state.open(2);
    state.section = crate::state::WEATHER_SECTION;
    state.focus = Target::WeatherLocation;
    state.activate();
    state.focus = Target::WeatherClear;
    let effects = state.activate();
    assert_eq!(
        effects,
        vec![
            Effect::Save,
            Effect::Weather(crate::weather::Command::ClearCache)
        ]
    );
    assert!(state.weather.cache.is_none());
    assert!(state.preferences.weather_location.is_none());
    assert_eq!(state.focus, Target::WeatherSearch);
}

#[test]
fn language_selection_restores_its_parent_and_is_saved_with_preferences() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Setting(4);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.subpage, Some(crate::state::Subpage::Language));
    assert_eq!(state.focus, Target::Choice(0));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.preferences.language, crate::i18n::Language::De);
    assert_eq!(state.focus, Target::Setting(4));
    state.activate();
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::Setting(4));
}

#[test]
fn remote_can_select_and_restore_every_language() {
    for (index, language) in crate::i18n::Language::ALL.into_iter().enumerate() {
        let mut state = ready();
        state.open(2);
        state.focus = Target::Setting(4);
        state.activate();
        for _ in 0..index {
            state.direction(Direction::Down, &controls(&state));
        }
        assert_eq!(state.focus, Target::Choice(index));
        assert_eq!(state.activate(), vec![Effect::Save]);
        assert_eq!(state.preferences.language, language);
        assert_eq!(state.focus, Target::Setting(4));

        let saved = serde_json::to_value(&state.preferences).unwrap();
        let mut restored = State::new(serde_json::from_value(saved).unwrap());
        restored.open(2);
        restored.focus = Target::Setting(4);
        restored.activate();
        assert_eq!(restored.preferences.language, language);
        assert_eq!(restored.focus, Target::Choice(index));
        restored.direction(Direction::Down, &controls(&restored));
        assert_eq!(
            restored.focus,
            Target::Choice((index + 1) % crate::i18n::Language::ALL.len())
        );
    }
}

#[test]
fn unsupported_language_preferences_recover_without_losing_other_choices() {
    let preferences: Preferences = serde_json::from_value(
        json!({"language":"unknown","favorites":["netflix"],"show_home_names":true}),
    )
    .unwrap();
    assert_eq!(preferences.language, crate::i18n::Language::En);
    assert!(preferences.show_home_names);
    assert_eq!(preferences.favorites, Some(vec!["netflix".into()]));
}

#[test]
fn unrelated_app_ids_and_titles_keep_their_installed_artwork() {
    for (id, title) in [
        ("com.tvweb.dashboard", "Glasshouse"),
        ("com.example.ardent", "Notes"),
        ("com.example.3ard", "Notes"),
        ("com.example.ard3", "Notes"),
        ("com.example.plexus", "Notes"),
        ("com.example.media", "Standard dashboard"),
        ("com.example.media", "netflixer"),
        ("com.example.media", "preNetflix"),
        ("amazon.alexa.view", "Amazon Alexa"),
        ("com.example.spotify", "Spotify tools"),
        ("com.example.media", "Plex"),
        ("com.example.browser", "Web Browser"),
        ("com.example.livetv", "Live TV"),
    ] {
        let app = App::new(id, title);
        assert_eq!(
            (app.brand.as_str(), app.category.as_str()),
            ("generic", "Utilities"),
            "An unrelated application must not be rebranded: {id} / {title}"
        );
    }
}

#[test]
fn curated_branding_does_not_use_title_words_or_partial_id_matches() {
    for (id, title) in [
        ("com.example.ard_more", "Notes"),
        ("com.example.more-ard", "Notes"),
        ("com.example.ARD", "Notes"),
        ("com.example.media", "ARD"),
        ("com.example.media", "(ARD)"),
        ("com.example.media", "ARD미디어테크"),
        ("com.example.media", "아에르데ARD"),
        ("com.example.media", "아에르데ARD미디어테크"),
        ("com.example.dashboard", "ARD"),
        ("com.example.media", "standard ardent ARD"),
    ] {
        let app = App::new(id, title);
        assert_eq!(
            (app.brand.as_str(), app.category.as_str()),
            ("generic", "Utilities"),
            "Only an exact app ID may select curated artwork: {id} / {title}"
        );
    }
}

#[test]
fn known_app_ids_preserve_the_curated_brands_and_categories() {
    let apps = demo_inventory().apps;
    let expected = [
        ("com.webos.app.livetv", "live-tv", "Streaming"),
        ("netflix", "netflix", "Streaming"),
        ("youtube.leanback.v4", "youtube", "Streaming"),
        ("com.apple.appletv", "apple-tv", "Streaming"),
        ("com.disney.disneyplus-prod", "disney-plus", "Streaming"),
        ("amazon", "prime-video", "Streaming"),
        ("plex", "plex", "Streaming"),
        ("spotify-beehive", "spotify", "Music"),
        ("org.jellyfin.webos", "jellyfin", "Streaming"),
        ("org.xbmc.kodi", "kodi", "Streaming"),
        ("com.limelight.webos", "moonlight", "Gaming"),
        ("org.webosbrew.hbchannel", "homebrew", "Utilities"),
        ("com.webos.app.browser", "browser", "Utilities"),
        ("com.arte.tv", "arte", "Streaming"),
        ("de.zdf.app.zdfm3", "zdf", "Streaming"),
        ("ard.mediathek", "das-erste", "Streaming"),
    ];
    for (id, brand, category) in expected {
        let app = apps.iter().find(|app| app.id == id).unwrap();
        assert_eq!(
            (app.brand.as_str(), app.category.as_str()),
            (brand, category),
            "Known app {id} must retain its curated brand and category"
        );
    }
}

#[test]
fn hdmi_plug_in_reports_the_cable_state_when_connected_only_means_present() {
    let inputs = normalize_inputs(&json!([
        {"id":"HDMI_1","label":"HDMI 1","port":1,"connected":true,"appId":"com.webos.app.hdmi1","hdmiPlugIn":false},
        {"id":"HDMI_2","label":"AVR-X1800H","port":2,"connected":true,"appId":"com.webos.app.hdmi2","hdmiPlugIn":true},
        {"id":"HDMI_3","label":"HDMI 3","port":3,"connected":true,"appId":"com.webos.app.hdmi3","hdmiPlugIn":false},
        {"id":"HDMI_4","label":"HDMI 4","port":4,"connected":true,"appId":"com.webos.app.hdmi4","hdmiPlugIn":false}
    ]))
    .unwrap();
    let connected: Vec<_> = inputs
        .iter()
        .map(|input| (input.id.as_str(), input.connected))
        .collect();
    assert_eq!(
        connected,
        [
            ("com.webos.app.hdmi1", Some(false)),
            ("com.webos.app.hdmi2", Some(true)),
            ("com.webos.app.hdmi3", Some(false)),
            ("com.webos.app.hdmi4", Some(false)),
        ]
    );
    assert_eq!(inputs[1].title, "AVR-X1800H");
    let preferences = Preferences::default();
    let visible: Vec<_> = inputs
        .iter()
        .filter(|input| preferences.input_visible(input))
        .map(|input| input.id.as_str())
        .collect();
    assert_eq!(visible, ["com.webos.app.hdmi2"]);
}

#[test]
fn inputs_without_hdmi_plug_in_keep_the_connected_report() {
    let inputs = normalize_inputs(&json!([
        {"appId":"com.webos.app.hdmi1","id":"HDMI_1","port":1,"connected":true},
        {"appId":"com.webos.app.hdmi2","id":"HDMI_2","port":2,"connected":false},
        {"appId":"com.webos.app.hdmi3","connected":true,"hdmiPlugIn":"yes"},
        {"appId":"com.webos.app.hdmi4"}
    ]))
    .unwrap();
    let connected: Vec<_> = inputs.iter().map(|input| input.connected).collect();
    assert_eq!(connected, [Some(true), Some(false), Some(true), None]);
}

#[test]
fn input_names_are_sanitized_and_old_preferences_load_without_them() {
    let old: Preferences = serde_json::from_value(json!({"background": "forest"})).unwrap();
    assert!(old.input_names.is_empty());
    let mut preferences: Preferences = serde_json::from_value(json!({
        "input_names": {
            "com.webos.app.hdmi1": "  Play\nStation\t5  ",
            "com.webos.app.hdmi2": "   ",
            "bad;id": "Ignored",
            "com.webos.app.hdmi3": "A".repeat(60),
        }
    }))
    .unwrap();
    preferences.sanitize();
    assert_eq!(
        preferences.input_names,
        BTreeMap::from([
            (
                "com.webos.app.hdmi1".to_string(),
                "PlayStation5".to_string()
            ),
            (
                "com.webos.app.hdmi3".to_string(),
                "A".repeat(crate::model::INPUT_NAME_LIMIT)
            ),
        ])
    );
    assert!(preferences.set_input_name("com.webos.app.hdmi2", " DENON "));
    assert!(!preferences.set_input_name("com.webos.app.hdmi2", "DENON"));
    assert_eq!(preferences.input_names["com.webos.app.hdmi2"], "DENON");
    assert!(preferences.set_input_name("com.webos.app.hdmi2", ""));
    assert!(!preferences.input_names.contains_key("com.webos.app.hdmi2"));
    assert!(!preferences.set_input_name("bad;id", "Name"));
}

#[test]
fn custom_input_names_keep_the_label_port_and_status_as_detail() {
    let mut preferences = Preferences::default();
    let input = Input {
        id: "com.webos.app.hdmi2".into(),
        title: "AVR-X1800H".into(),
        port: "HDMI 2".into(),
        connected: Some(true),
        signal: None,
    };
    let language = preferences.language;
    let status = |preferences: &Preferences| {
        view::input_status(&input, preferences.input_name(&input).is_some(), language)
    };
    assert_eq!(preferences.input_title(&input), "HDMI 2");
    assert_eq!(status(&preferences), "AVR-X1800H · Connected");
    preferences.set_input_name(&input.id, "DENON");
    assert_eq!(preferences.input_title(&input), "DENON");
    assert_eq!(status(&preferences), "AVR-X1800H · HDMI 2 · Connected");
    let plain = Input {
        title: "HDMI 2".into(),
        ..input.clone()
    };
    assert_eq!(
        view::input_status(&plain, true, language),
        "HDMI 2 · Connected"
    );
    assert_eq!(view::input_status(&plain, false, language), "Connected");
}

#[test]
fn remote_renames_and_resets_an_input_from_its_settings_page() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Sidebar(crate::state::INPUTS_SECTION);
    state.activate();
    let id = "com.webos.app.hdmi2".to_string();
    state.focus = Target::InputMode(id.clone());
    state.activate();
    assert_eq!(state.focus, Target::Choice(2));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::InputRename);
    assert!(
        !controls(&state)
            .iter()
            .any(|c| c.target == Target::InputNameReset)
    );
    state.activate();
    assert!(matches!(state.overlay, Some(Overlay::Keyboard)));
    state.text("DENONX");
    state.delete();
    assert_eq!(state.back(), vec![Effect::Save]);
    assert_eq!(state.focus, Target::InputRename);
    assert_eq!(state.preferences.input_names[&id], "DENON");
    assert_eq!(
        state.preferences.input_title(&state.inventory.inputs[1]),
        "DENON"
    );
    // Dismissing an empty keyboard keeps the saved name.
    state.activate();
    assert!(state.finish_text_input().is_empty());
    assert_eq!(state.preferences.input_names[&id], "DENON");
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::InputNameReset);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.input_names.is_empty());
    assert_eq!(state.focus, Target::InputRename);
    state.direction(Direction::Up, &controls(&state));
    assert_eq!(state.focus, Target::Choice(2));
    state.focus = Target::InputRename;
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::InputMode(id));
    assert!(state.subpage.is_none());
}

#[test]
fn keyboard_done_saves_a_typed_input_name() {
    let mut state = ready();
    state.open(2);
    state.section = crate::state::INPUTS_SECTION;
    state.focus = Target::InputMode("com.webos.app.hdmi1".into());
    state.activate();
    state.focus = Target::InputRename;
    state.activate();
    state.text("PS5");
    state.focus = Target::Key(
        crate::state::KEYS
            .iter()
            .position(|k| *k == "Done")
            .unwrap(),
    );
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.preferences.input_names["com.webos.app.hdmi1"], "PS5");
    assert!(state.overlay.is_none());
}

#[test]
fn video_wallpaper_mode_keeps_its_setting() {
    let mut preferences = crate::model::Preferences {
        background: "video".into(),
        video_index: 7,
        ..Default::default()
    };
    preferences.sanitize();
    assert_eq!(preferences.background, "video");
    assert_eq!(preferences.video_index, 7);
}

#[test]
fn video_gallery_filters_selection_and_hold_are_independent() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Sidebar(1);
    state.activate();
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    assert_eq!(
        state.settings_level,
        crate::state::SettingsLevel::WallpaperVideos
    );
    let groups = crate::video_catalog::groups(0);
    assert_eq!(
        controls(&state)
            .iter()
            .filter(|c| matches!(c.target, Target::VideoGroup(_)))
            .count(),
        groups.len()
    );
    let index = groups[0].2[0];
    state.focus = Target::VideoGroup(0);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(
        state.settings_level,
        crate::state::SettingsLevel::WallpaperCategory(0)
    );
    assert_eq!(state.focus, Target::VideoPick(index));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(
        state
            .preferences
            .video_excluded
            .contains(&crate::video_catalog::all()[index].id)
    );
    assert_ne!(state.preferences.background, "video");
    assert_eq!(state.hold(), vec![Effect::Save]);
    assert_eq!(state.preferences.background, "video");
    assert_eq!(state.preferences.video_index, index);
    assert!(
        !state
            .preferences
            .video_excluded
            .contains(&crate::video_catalog::all()[index].id)
    );
    state.back();
    assert_eq!(state.focus, Target::VideoGroup(0));
}
#[test]
fn video_grid_navigation_and_back_to_sources() {
    let mut state = ready();
    state.open(2);
    state.focus = Target::Sidebar(1);
    state.activate();
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    state.focus = Target::VideoGroup(0);
    state.direction(Direction::Right, &controls(&state));
    let items = crate::video_catalog::groups(0)[0].2.clone();
    assert_eq!(state.focus, Target::VideoPick(items[0]));
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.focus, Target::VideoPick(items[1]));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::VideoPick(items[5]));
    state.direction(Direction::Up, &controls(&state));
    assert_eq!(state.focus, Target::VideoPick(items[1]));
    state.back();
    assert_eq!(state.focus, Target::VideoGroup(0));
    state.back();
    assert_eq!(state.focus, Target::WallpaperMenu(2));
    state.back();
    assert_eq!(state.focus, Target::Sidebar(1));
    state.back();
    assert_eq!(state.focus, Target::Nav(2));
}

#[test]
fn video_gallery_header_geometry_is_stable_across_source_filters() {
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open(2);
    state.focus = Target::Sidebar(1);
    state.activate();
    let layout = |state: &State| {
        controls(state)
            .into_iter()
            .filter(|c| {
                matches!(
                    c.target,
                    Target::WallpaperMenu(_) | Target::VideoToggle | Target::VideoShuffle
                )
            })
            .map(|c| (c.target, (c.rect.x, c.rect.y, c.rect.w, c.rect.h)))
            .collect::<Vec<_>>()
    };
    let baseline = layout(&state);
    state.preferences.video_shuffle = !state.preferences.video_shuffle;
    state
        .preferences
        .video_excluded
        .insert(crate::video_catalog::all()[0].id.clone());
    assert_eq!(
        baseline,
        layout(&state),
        "wallpaper layout must not jump with selection changes"
    );
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    assert!(
        controls(&state)
            .iter()
            .any(|c| c.target == Target::VideoGroup(0))
    );
    assert!(
        !controls(&state)
            .iter()
            .any(|c| matches!(c.target, Target::VideoFilter(_)))
    );
}

#[test]
fn video_storage_migrates_old_mask_without_touching_other_fields() {
    let mut prefs = serde_json::to_value(Preferences::default()).unwrap();
    let data = prefs.as_object_mut().unwrap();
    data.remove("video_excluded");
    data.remove("video_shuffle");
    data.remove("video_shuffle_seed");
    data.insert("video_sources_mask".into(), json!(4));
    data.insert("greeting_name".into(), json!("Tester"));
    data.insert("input_names".into(), json!({"com.webos.app.hdmi1":"BEAST"}));
    let path =
        std::env::temp_dir().join(format!("luma-round03-migrate-{}.json", std::process::id()));
    std::fs::write(&path, serde_json::to_vec(&prefs).unwrap()).unwrap();
    let migrated = storage::load(&path).unwrap();
    assert_eq!(
        crate::video_catalog::selected_count(&migrated.video_excluded),
        20
    );
    assert_eq!(migrated.greeting_name, "Tester");
    assert_eq!(
        migrated
            .input_names
            .get("com.webos.app.hdmi1")
            .map(String::as_str),
        Some("BEAST")
    );
    assert!(migrated.video_shuffle);
    storage::save(&path, &migrated).unwrap();
    let roundtrip = storage::load(&path).unwrap();
    assert_eq!(roundtrip.video_excluded, migrated.video_excluded);
    let _ = std::fs::remove_file(&path);
}

#[test]
fn video_handoff_crossfades_selected_still_with_constant_scrim() {
    let mut state = ready();
    state.preferences.background = "video".into();
    state.preferences.video_index = 271;
    state.photo_background_backup = "northern-lights".into();
    state.video_frame_ready = false;
    state.video_transition_started = None;
    let pending = scene(&state);
    assert!(matches!(
        pending.draw.first(),
        Some(crate::renderer::Draw::TintedImage(path, _, _, _, tint))
            if path.ends_with("video-stills/271.jpg") && (tint[3] - 1.).abs() < f32::EPSILON
    ));
    assert!(matches!(
        pending.draw.get(1),
        Some(crate::renderer::Draw::Shape(_, _, _, color))
            if (color[3] - 0.23).abs() < 0.001
    ));

    state.video_frame_ready = true;
    state.video_transition_started = Some(std::time::Instant::now());
    let fading = scene(&state);
    assert!(matches!(
        fading.draw.first(),
        Some(crate::renderer::Draw::TintedImage(path, _, _, _, tint))
            if path.ends_with("video-stills/271.jpg") && tint[3] > 0.9
    ));
    assert!(matches!(
        fading.draw.get(1),
        Some(crate::renderer::Draw::Shape(_, _, _, color))
            if (color[3] - 0.23).abs() < 0.001
    ));

    state.video_transition_started = None;
    let playing = scene(&state);
    assert!(matches!(
        playing.draw.first(),
        Some(crate::renderer::Draw::Shape(_, _, _, color))
            if (color[3] - 0.23).abs() < 0.001
    ));
}

#[test]
fn motion_tabs_preserve_two_layers_on_first_frame_and_retarget_without_stacking() {
    let mut state = ready();
    let assets = view::Assets {
        root: PathBuf::new(),
        version: "test".into(),
        metrics: BTreeMap::new(),
        catalog_metrics: BTreeMap::new(),
        active_heading: std::cell::Cell::new(crate::typography::HeadingFont::default()),
        active_text: std::cell::Cell::new(crate::typography::TextFont::default()),
        heading_pct: std::cell::Cell::new(100),
        text_pct: std::cell::Cell::new(100),
        artwork: crate::app_artwork::Service::new(false),
    };
    let now = time::OffsetDateTime::UNIX_EPOCH;
    let nav = view::navigation_for(&assets, state.preferences.language, false);
    let render = |state: &mut State| {
        let index = state.page_index();
        crate::compose(state, &assets, nav.items[index].x, nav.items[index].w, now)
    };
    let home = render(&mut state);
    let n_home = home.body_range.len();
    assert!(n_home > 0);
    state.open(1);
    let apps = render(&mut state);
    assert_eq!(state.rendered_page, Page::Apps);
    assert!(state.previous_page_layer.is_some());
    assert!(
        apps.body_range.len() > state.previous_page_layer.as_ref().unwrap().0.len(),
        "first page-switch frame contains both outgoing and incoming draws"
    );
    state.open(2);
    let settings = render(&mut state);
    assert_eq!(state.rendered_page, Page::Settings);
    assert!(!settings.body_range.is_empty());
    assert_eq!(
        state.previous_page_layer.as_ref().unwrap().0.len(),
        apps.body_range.len(),
        "fast double-navigation targets the last composited visible frame"
    );
}

#[test]
fn remote_scroll_animates_and_pointer_control_follows_visible_card() {
    let mut state = ready();
    state.open(1);
    let last = state.apps().last().unwrap().id.clone();
    state.focus(Target::App(last.clone()), &controls(&state));
    let desired = state.scroll_goal;
    assert!(desired > 0.);
    let previous = controls(&state)
        .into_iter()
        .find(|c| c.target == Target::App(last.clone()))
        .unwrap()
        .rect
        .y;
    state.scroll_last = std::time::Instant::now() - std::time::Duration::from_millis(16);
    state.tick();
    assert!(state.scroll > 0. && state.scroll < desired);
    let current = controls(&state)
        .into_iter()
        .find(|c| c.target == Target::App(last.clone()))
        .unwrap()
        .rect
        .y;
    assert!(
        current < previous,
        "pointer hit rectangle tracks native drawn scroll position"
    );
}

#[test]
fn focus_retarget_resumes_from_current_intensity_without_reset() {
    let mut state = ready();
    let a = Target::Sidebar(0);
    let b = Target::Sidebar(1);
    state.change_focus(a.clone());
    state.focus_tweens.get_mut(&a).unwrap().start -= std::time::Duration::from_millis(70);
    let before = state.focus_level(&a);
    assert!(before > 0. && before < 1.);
    state.change_focus(b.clone());
    assert!((state.focus_tweens[&a].from - before).abs() < 0.01);
    assert_eq!(state.focus_tweens[&b].to, 1.);
}

#[test]
fn rude_greeting_is_default_and_choice_persists_without_touching_other_preferences() {
    let mut state = ready();
    assert_eq!(
        state.preferences.greeting_style,
        crate::weather_phrases::GreetingStyle::Rude
    );
    state.open(2);
    state.focus = Target::Setting(6);
    state.activate();
    assert_eq!(state.focus, Target::GreetingStyle);
    state.activate();
    assert_eq!(state.subpage, Some(crate::state::Subpage::GreetingStyle));
    assert_eq!(state.focus, Target::Choice(1));
    state.focus = Target::Choice(0);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(
        state.preferences.greeting_style,
        crate::weather_phrases::GreetingStyle::Classic
    );
    assert_eq!(state.subpage, Some(crate::state::Subpage::Greeting));
    assert_eq!(state.focus, Target::GreetingStyle);
    let prefs = serde_json::to_string(&state.preferences).unwrap();
    let roundtrip: crate::model::Preferences = serde_json::from_str(&prefs).unwrap();
    assert_eq!(
        roundtrip.greeting_style,
        crate::weather_phrases::GreetingStyle::Classic
    );
    state.back();
    assert!(state.subpage.is_none());
    assert_eq!(state.focus, Target::Setting(6));
    let legacy: crate::model::Preferences = serde_json::from_str("{}").unwrap();
    assert_eq!(
        legacy.greeting_style,
        crate::weather_phrases::GreetingStyle::Rude
    );
}

#[test]
fn smart_home_preferences_backward_compatible() {
    let old = serde_json::json!({"background":"dunes","favorites":["spotify-beehive"]});
    let settings: crate::model::Preferences = serde_json::from_value(old).unwrap();
    assert!(!settings.smart_home.show_tab);
    assert!(settings.smart_home.server_url.is_empty());
    let value = serde_json::to_value(&settings).unwrap();
    let reread: crate::model::Preferences = serde_json::from_value(value).unwrap();
    assert!(!reread.smart_home.show_tab);
    assert_eq!(reread.favorites.as_ref().unwrap()[0], "spotify-beehive");
}
#[test]
fn smart_home_tab_visibility_and_settings_index() {
    let mut state = crate::state::State::new(crate::model::Preferences::default());
    assert_eq!(state.settings_nav_index(), 2);
    state.open(2);
    assert_eq!(state.page, crate::state::Page::Settings);
    state.preferences.smart_home.server_url = "http://homeassistant.local:8123".into();
    state.preferences.smart_home.show_tab = true;
    assert_eq!(state.settings_nav_index(), 3);
    state.open(2);
    assert_eq!(state.page, crate::state::Page::SmartHome);
    state.open(3);
    assert_eq!(state.page, crate::state::Page::Settings);
}

#[test]
fn smart_home_tvos_push_pop_and_selection() {
    use crate::state::{Page, SMARTHOME_SECTION, Subpage, Target};
    let mut state = crate::state::State::new(crate::model::Preferences::default());
    state.preferences.smart_home.server_url = "http://homeassistant.local:8123".into();
    state.preferences.smart_home.show_tab = true;
    state.ha_entities = vec![
        crate::smart_home::Entity {
            id: "light.office".into(),
            name: "Office".into(),
            state: "on".into(),
            domain: "light".into(),
            area: "Office".into(),
            brightness: Some(50),
            unit: String::new(),
            hidden: false,
            device_class: String::new(),
        },
        crate::smart_home::Entity {
            id: "light.living".into(),
            name: "Living".into(),
            state: "off".into(),
            domain: "light".into(),
            area: "Living Room".into(),
            brightness: None,
            unit: String::new(),
            hidden: false,
            device_class: String::new(),
        },
    ];
    state.open_settings();
    state.section = SMARTHOME_SECTION;
    state.focus = Target::SmartSection(0);
    state.activate();
    assert_eq!(state.page, Page::Settings);
    assert_eq!(state.subpage, Some(Subpage::SmartSelect(0)));
    assert_eq!(state.focus, Target::SmartBulk(0, 0));
    state.focus = Target::SmartPick(0, "light.living".into());
    state.activate();
    assert_eq!(
        state.preferences.smart_home.selected_entities,
        vec!["light.office"]
    );
    state.back();
    assert_eq!(state.subpage, None);
    assert_eq!(state.focus, Target::SmartSection(0));
}

#[test]
fn smart_home_selection_explicitly_none_is_not_default_all() {
    use crate::state::Target;
    let mut state = crate::state::State::new(crate::model::Preferences::default());
    state.ha_entities = vec![crate::smart_home::Entity {
        id: "camera.front".into(),
        name: "Front".into(),
        state: "idle".into(),
        domain: "camera".into(),
        area: "".into(),
        brightness: None,
        unit: String::new(),
        hidden: false,
        device_class: String::new(),
    }];
    state.focus = Target::SmartPick(1, "camera.front".into());
    state.activate();
    assert_eq!(
        state.preferences.smart_home.selected_cameras,
        vec!["__none__"]
    );
    state.activate();
    assert_eq!(
        state.preferences.smart_home.selected_cameras,
        vec!["camera.front"]
    );
}

#[test]
fn tvos_settings_push_pop_reveals_parent_focus_without_traps() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.open_settings();
    assert_eq!(state.settings_level, SettingsLevel::Root);
    assert_eq!(state.focus, Target::Nav(2));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::Sidebar(0));
    state.focus = Target::Sidebar(1);
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::Section);
    assert_eq!(state.focus, Target::WallpaperMenu(0));
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::WallpaperVideos);
    state.focus = Target::VideoGroup(0);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.settings_level, SettingsLevel::WallpaperCategory(0));
    assert!(matches!(state.focus, Target::VideoPick(_)));
    state.back();
    assert_eq!(state.focus, Target::VideoGroup(0));
    state.back();
    assert_eq!(state.focus, Target::WallpaperMenu(2));
    state.back();
    assert_eq!(state.focus, Target::Sidebar(1));
    state.back();
    assert_eq!(state.focus, Target::Nav(2));
    state.back();
    assert_eq!(state.page, Page::Home);
}

#[test]
fn tvos_settings_scene_never_uses_small_body_text() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.open_settings();
    let sections = [0, 1, 2, 3, 4, 5];
    for section in sections {
        state.section = section;
        state.settings_level = SettingsLevel::Section;
        let rendered = scene(&state);
        for draw in &rendered.draw[rendered.settings_panel_range.clone()] {
            if let crate::renderer::Draw::Text(label, _, style, _, _) = draw {
                assert!(
                    style.size >= 25.,
                    "too small for TV: {label} @ {}",
                    style.size
                );
            }
        }
    }
    for level in [
        SettingsLevel::Root,
        SettingsLevel::WallpaperType,
        SettingsLevel::WallpaperPhotos,
        SettingsLevel::WallpaperVideos,
        SettingsLevel::WallpaperCategory(0),
    ] {
        state.section = 1;
        state.settings_level = level;
        let rendered = scene(&state);
        for draw in &rendered.draw[rendered.settings_panel_range.clone()] {
            if let crate::renderer::Draw::Text(label, _, style, _, _) = draw {
                assert!(
                    style.size >= 25.,
                    "too small for TV: {label} @ {}",
                    style.size
                );
            }
        }
    }
}

#[test]
fn tvos_category_toggle_keeps_prefs_and_source_selection() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    let favorite = "spotify-beehive".to_owned();
    state.preferences.favorites = Some(vec![favorite.clone()]);
    state.preferences.greeting_name = "Living room".into();
    state
        .preferences
        .input_names
        .insert("hdmi1".into(), "BEAST".into());
    state.open_settings();
    state.focus = Target::Sidebar(1);
    state.activate();
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::WallpaperVideos);
    let count = state.video_selected_count();
    state.focus = Target::VideoSource(1);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.video_selected_count() < count);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.video_selected_count(), count);
    state.focus = Target::VideoGroup(0);
    let before = state.preferences.video_excluded.clone();
    assert!(state.activate().is_empty());
    assert_eq!(state.settings_level, SettingsLevel::WallpaperCategory(0));
    assert_eq!(state.preferences.video_excluded, before);
    let serialized = serde_json::to_string(&state.preferences).unwrap();
    let restored: Preferences = serde_json::from_str(&serialized).unwrap();
    assert_eq!(restored.favorites.unwrap(), vec![favorite]);
    assert_eq!(restored.greeting_name, "Living room");
    assert_eq!(
        restored.input_names.get("hdmi1").map(String::as_str),
        Some("BEAST")
    );
}

#[test]
fn tvos_legacy_section_body_clears_page_heading() {
    use crate::state::{INPUTS_SECTION, SettingsLevel, WEATHER_SECTION};
    let mut state = ready();
    state.open_settings();
    state.settings_level = SettingsLevel::Section;
    for (section, target) in [
        (0, Target::Setting(0)),
        (WEATHER_SECTION, Target::WeatherToggle),
        (
            INPUTS_SECTION,
            Target::InputMode("com.webos.app.hdmi1".into()),
        ),
        (5, Target::Setting(3)),
    ] {
        state.section = section;
        let screen = scene(&state);
        let first = screen
            .controls
            .iter()
            .find(|c| c.target == target)
            .expect("first setting should be rendered");
        assert!(
            first.rect.y >= 184.,
            "row overlaps title in section {section}: {}",
            first.rect.y
        );
    }
}

#[test]
fn tvos_magic_remote_chevron_opens_category_without_mutating_selection() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.open_settings();
    state.focus = Target::Sidebar(1);
    state.activate();
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    let before = state.preferences.video_excluded.clone();
    let screen = scene(&state);
    assert!(
        screen
            .controls
            .iter()
            .any(|c| c.target == Target::VideoGroup(0))
    );
    state.pointer_focus(Target::VideoGroup(0));
    assert!(state.activate().is_empty());
    assert_eq!(state.settings_level, SettingsLevel::WallpaperCategory(0));
    assert_eq!(state.preferences.video_excluded, before);
}

#[test]
fn settings_v2_pointer_back_at_each_depth_returns_to_parent() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open_settings();
    state.focus = Target::Sidebar(1);
    state.activate();
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    state.focus = Target::VideoGroup(0);
    state.direction(Direction::Right, &controls(&state));
    assert_eq!(state.settings_level, SettingsLevel::WallpaperCategory(0));
    for (expected, focus) in [
        (SettingsLevel::WallpaperVideos, Target::VideoGroup(0)),
        (SettingsLevel::Section, Target::WallpaperMenu(2)),
        (SettingsLevel::Root, Target::Sidebar(1)),
    ] {
        let scene = scene(&state);
        let arrow = scene
            .controls
            .iter()
            .find(|c| c.target == Target::SettingsBack)
            .expect("pointer back arrow has clickable control");
        assert_eq!(arrow.rect.w, 56.);
        assert_eq!(arrow.rect.h, 56.);
        assert_eq!(arrow.rect.x, 108.);
        assert_eq!(arrow.rect.y, 208.);
        state.pointer_focus(Target::SettingsBack);
        state.activate();
        assert_eq!(state.settings_level, expected);
        assert_eq!(state.focus, focus);
    }
    assert!(
        scene(&state)
            .controls
            .iter()
            .all(|c| c.target != Target::SettingsBack)
    );
}
#[test]
fn settings_v2_glass_rows_are_exactly_80px_with_no_left_row_icons() {
    let mut state = ready();
    state.open_settings();
    state.preferences.reduced_motion = true;
    let layout = scene(&state);
    let rows: Vec<_> = layout
        .controls
        .iter()
        .filter(|c| matches!(c.target, Target::Sidebar(_)))
        .collect();
    assert_eq!(rows.len(), 8);
    assert!(
        rows.iter()
            .all(|r| r.rect.h == 80. && r.rect.x == 864. && r.rect.w == 940.)
    );
    assert!(layout.draw.iter().any(
        |d| matches!(d,crate::renderer::Draw::Shape(r, radius, _,color)
      if r.x==832. && *radius==28. && color[3] > 0.3)
    ));
}

#[test]
fn settings_v2_category_poster_pitch_keeps_captions_clear() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.open_settings();
    state.settings_level = SettingsLevel::WallpaperCategory(0);
    let scene = scene(&state);
    let cards: Vec<_> = scene
        .controls
        .iter()
        .filter(|c| matches!(c.target, Target::VideoPick(_)))
        .collect();
    assert!(cards.len() >= 8);
    assert!((cards[4].rect.y - cards[0].rect.y - 278.).abs() < 0.01);
    assert_eq!(cards[0].rect.y, cards[1].rect.y);
}

#[test]
fn settings_v2_smart_connect_preserves_parent_and_has_no_token_control() {
    use crate::state::{SettingsLevel, Subpage};
    let mut state = ready();
    state.open_settings();
    state.focus = Target::Sidebar(crate::state::SMARTHOME_SECTION);
    state.activate();
    state.focus = Target::SmartConnect;
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::Section);
    assert_eq!(state.subpage, Some(Subpage::SmartConnect));
    let screen = scene(&state);
    assert!(
        screen
            .controls
            .iter()
            .any(|c| c.target == Target::SmartRetry)
    );
    assert!(
        screen
            .draw
            .iter()
            .any(|d| matches!(d, crate::renderer::Draw::Text(label,_,_,_,_)
        if label == "SIGN IN WITH YOUR PHONE"))
    );
    // The token path is a second phone QR, never remote typing.
    assert!(
        screen
            .controls
            .iter()
            .any(|c| c.target == Target::SmartFallback)
    );
    state.pointer_focus(Target::SettingsBack);
    state.activate();
    assert_eq!(state.subpage, None);
    assert_eq!(state.settings_level, SettingsLevel::Section);
    assert_eq!(state.focus, Target::SmartConnect);
}

#[test]
fn settings_v2_up_navigation_reaches_back_without_leaving_page() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.open_settings();
    state.focus = Target::Sidebar(1);
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::Section);
    state.direction(Direction::Up, &controls(&state));
    assert_eq!(state.focus, Target::SettingsBack);
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::Root);
    assert_eq!(state.focus, Target::Sidebar(1));
}

#[test]
fn settings_revision_back_reaches_home_and_nav_home_click_works_at_any_depth() {
    use crate::state::{Page, SettingsLevel};
    for level in [
        SettingsLevel::Root,
        SettingsLevel::Section,
        SettingsLevel::WallpaperVideos,
        SettingsLevel::WallpaperCategory(0),
    ] {
        let mut state = ready();
        state.open_settings();
        state.section = 1;
        state.settings_level = level;
        state.focus = match level {
            SettingsLevel::Root => Target::Sidebar(1),
            SettingsLevel::Section => Target::WallpaperMenu(2),
            SettingsLevel::WallpaperVideos => Target::VideoGroup(0),
            SettingsLevel::WallpaperCategory(_) => Target::VideoPick(0),
            _ => unreachable!(),
        };
        let mut steps = 0;
        while state.page == Page::Settings && steps < 9 {
            state.back();
            steps += 1;
        }
        assert_eq!(
            state.page,
            Page::Home,
            "Back from {level:?} must reach Home"
        );
        assert!(steps <= 5);
        let mut state = ready();
        state.open_settings();
        state.section = 1;
        state.settings_level = level;
        state.pointer_focus(Target::Nav(0));
        state.activate();
        assert_eq!(
            state.page,
            Page::Home,
            "Home pointer navigation from {level:?}"
        );
    }
}

#[test]
fn settings_revision_panels_share_top_height_and_no_extra_headings() {
    use crate::state::SettingsLevel;
    for (level, section) in [
        (SettingsLevel::Root, 0),
        (SettingsLevel::Section, 0),
        (SettingsLevel::Section, 1),
        (SettingsLevel::WallpaperVideos, 1),
    ] {
        let mut state = ready();
        state.open_settings();
        state.settings_level = level;
        state.section = section;
        state.preferences.reduced_motion = true;
        let rendered = scene(&state);
        let panels: Vec<_> = rendered
            .draw
            .iter()
            .filter_map(|d| {
                if let crate::renderer::Draw::Shape(r, rad, _, col) = d
                    && *rad == 28.
                    && r.y == 184.
                    && col[3] > 0.3
                {
                    return Some(r);
                }
                None
            })
            .collect();
        assert_eq!(panels.len(), 2, "{level:?}/{section} glass panels");
        assert_eq!(panels[0].h, panels[1].h);
        assert_eq!(panels[0].x, crate::state::HOME_STRIP_LEFT);
        assert_eq!(panels[1].x, 832.);
        assert_eq!(panels[1].x + panels[1].w, crate::state::HOME_STRIP_RIGHT);
        assert!(
            rendered.draw[rendered.settings_panel_range.clone()]
                .iter()
                .all(|d| !matches!(d,crate::renderer::Draw::Text(t,_,_,_,_)
            if (t=="Wallpaper"||t=="Settings") && level != SettingsLevel::Root))
        );
    }
}

#[test]
fn settings_preview_illustrations_stay_in_panel_with_centered_copy() {
    use crate::renderer::Draw;
    let mut state = ready();
    state.open_settings();
    state.preferences.reduced_motion = true;
    let mut keys = Vec::new();
    for (section, name, summary) in [
        (0, "General", "Language, clock and motion"),
        (1, "Wallpaper", "Video wallpaper collection"),
        (2, "Widgets", "Weather, crypto, HDMI and Smart Home on Home"),
        (3, "Inputs", "Connected HDMI devices"),
        (4, "Smart Home", "Home Assistant devices"),
        (5, "System", "Device and launcher controls"),
        (6, "Appearance", "Accent color and highlights"),
        (7, "Stacks", "Rows of media on Home"),
    ] {
        state.focus = Target::Sidebar(section);
        let layout = scene(&state);
        // Illustrations replaced the line icons.
        assert!(!layout.draw.iter().any(|d| matches!(
            d,
            Draw::TintedImage(path, rect, _, _, _) if path.contains("ui-icons/") && rect.w == 144.
        )));
        // The same preview keeps one identity between frames, so moving
        // focus within it never crossfades a scene onto itself.
        assert_ne!(layout.settings_sidebar_key, 0);
        assert_eq!(
            layout.settings_sidebar_key,
            scene(&state).settings_sidebar_key
        );
        keys.push(layout.settings_sidebar_key);
        let center_x = 84. + 700. / 2.;
        for label in [name, summary] {
            let (rect, centered) = layout
                .draw
                .iter()
                .find_map(|d| match d {
                    Draw::Text(text, rect, _, _, centered) if text == label => {
                        Some((rect, centered))
                    }
                    _ => None,
                })
                .expect("preview copy");
            assert!(*centered);
            assert!((rect.x + rect.w / 2. - center_x).abs() < 0.01);
        }
        // Every visible shape of the scene stays inside the preview glass.
        let mut clip: Option<crate::state::Rect> = None;
        for d in &layout.draw[layout.settings_sidebar_range.clone()] {
            if let Draw::Clip(c) = d {
                clip = *c;
            }
            if let Draw::Shape(r, ..)
            | Draw::DiagonalGradient(r, ..)
            | Draw::RoundedGradient(r, ..) = d
            {
                let (left, right) = clip.map_or((r.x, r.x + r.w), |c| {
                    (r.x.max(c.x), (r.x + r.w).min(c.x + c.w))
                });
                if right <= left {
                    continue;
                }
                assert!(left >= 84. && right <= 784., "{name}: {r:?}");
                assert!(r.y >= 184. && r.y + r.h <= 184. + 788., "{name}: {r:?}");
            }
        }
    }
    keys.sort_unstable();
    keys.dedup();
    assert_eq!(keys.len(), 8);
}

#[test]
fn settings_v2_back_is_within_left_glass_panel() {
    let mut state = ready();
    state.open_settings();
    state.focus = Target::Sidebar(0);
    state.activate();
    state.preferences.reduced_motion = true;
    let layout = scene(&state);
    let button = layout
        .controls
        .iter()
        .find(|c| c.target == Target::SettingsBack)
        .unwrap();
    assert_eq!(
        (button.rect.x, button.rect.y, button.rect.w, button.rect.h),
        (108., 208., 56., 56.)
    );
    assert!(button.rect.x >= 84. + 24. && button.rect.y >= 184. + 24.);
    assert!(button.rect.x + button.rect.w <= 84. + 700. - 24.);
    assert!(button.rect.y + button.rect.h <= 184. + 568. - 24.);
}

#[test]
fn settings_v2_back_does_not_cover_wallpaper_thumbnails_or_category_count() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open_settings();
    state.section = 1;
    state.settings_level = SettingsLevel::Section;
    let frame = scene(&state);
    let back = frame
        .controls
        .iter()
        .find(|c| c.target == Target::SettingsBack)
        .unwrap()
        .rect;
    let images: Vec<_> = frame
        .draw
        .iter()
        .filter_map(|d| match d {
            crate::renderer::Draw::Image(path, rect, _, _)
                if path.contains("video-thumbnails/") =>
            {
                Some(rect)
            }
            _ => None,
        })
        .collect();
    assert_eq!(images.len(), 6);
    assert!(images.iter().all(|r| r.y >= back.y + back.h + 8.));
    state.settings_level = SettingsLevel::WallpaperCategory(0);
    let frame = scene(&state);
    let back = frame
        .controls
        .iter()
        .find(|c| c.target == Target::SettingsBack)
        .unwrap()
        .rect;
    let count = frame
        .draw
        .iter()
        .find_map(|d| match d {
            crate::renderer::Draw::Text(label, rect, _, _, _) if label == "23 of 23 selected" => {
                Some(rect)
            }
            _ => None,
        })
        .unwrap();
    assert!(count.x >= back.x + back.w + 8.);
}

#[test]
fn settings_revision_select_all_is_56px_centered_and_inside_panel() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open_settings();
    state.settings_level = SettingsLevel::WallpaperCategory(0);
    let frame = scene(&state);
    let select = frame
        .controls
        .iter()
        .find(|c| c.target == Target::VideoSelectAll(0))
        .expect("Select All button")
        .rect;
    assert_eq!(select.y, 208.);
    assert_eq!(select.h, 56.);
    assert!(select.y + select.h <= 992.);
    let text = frame
        .draw
        .iter()
        .find_map(|d| match d {
            crate::renderer::Draw::Text(s, r, _, _, center)
                if s == "Deselect All" || s == "Select All" =>
            {
                assert!(*center);
                Some(r)
            }
            _ => None,
        })
        .expect("Select All label");
    assert!((text.y + text.h / 2. - (select.y + select.h / 2.)).abs() <= 2.);
}

#[test]
fn settings_inputs_group_connected_first_without_phantom_gap() {
    let mut state = ready();
    state.open_settings();
    state.section = crate::state::INPUTS_SECTION;
    state.settings_level = crate::state::SettingsLevel::Section;
    state.preferences.reduced_motion = true;
    let layout = scene(&state);
    let mut rows = layout
        .controls
        .iter()
        .filter(|c| matches!(c.target, Target::InputMode(_)))
        .collect::<Vec<_>>();
    rows.sort_by(|a, b| a.rect.y.total_cmp(&b.rect.y));
    assert_eq!(rows.len(), state.inventory.inputs.len());
    assert!(
        rows.iter()
            .all(|r| r.rect.h == 104. && r.rect.x == 864. && r.rect.w == 940.)
    );
    assert!(layout.draw.iter().any(|d| matches!(d,
        crate::renderer::Draw::Text(text,_,_,_,_) if text=="CONNECTED")));
}

#[test]
fn settings_shared_horizontal_edges_match_home_and_apps() {
    let mut state = ready();
    state.open_settings();
    state.preferences.reduced_motion = true;
    let rendered = scene(&state);
    let glass = rendered
        .draw
        .iter()
        .filter_map(|d| {
            if let crate::renderer::Draw::Shape(r, rad, _, color) = d
                && *rad == 28.
                && r.y == 184.
                && color[3] > 0.3
            {
                return Some(*r);
            }
            None
        })
        .collect::<Vec<_>>();
    assert_eq!(glass.len(), 2);
    assert_eq!(glass[0].x, crate::state::HOME_STRIP_LEFT);
    assert_eq!(glass[1].x + glass[1].w, crate::state::HOME_STRIP_RIGHT);
}
#[test]
fn video_sources_and_categories_have_distinct_pointer_hitboxes() {
    use crate::state::SettingsLevel;
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open_settings();
    state.focus = Target::Sidebar(1);
    state.activate();
    state.focus = Target::WallpaperMenu(2);
    state.activate();
    let controls = scene(&state).controls;
    assert!(controls.iter().any(|r| r.target == Target::VideoSource(1)));
    assert!(controls.iter().any(|r| r.target == Target::VideoGroup(0)));
    let before = state.video_selected_count();
    state.pointer_focus(Target::VideoSource(1));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.video_selected_count() < before);
    state.pointer_focus(Target::VideoGroup(0));
    assert!(state.activate().is_empty());
    assert_eq!(state.settings_level, SettingsLevel::WallpaperCategory(0));
    let clip = crate::video_catalog::groups(0)[0].2[0];
    state.focus = Target::VideoPick(clip);
    let before_clip = state
        .preferences
        .video_excluded
        .contains(&crate::video_catalog::all()[clip].id);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_ne!(
        before_clip,
        state
            .preferences
            .video_excluded
            .contains(&crate::video_catalog::all()[clip].id)
    );
}

#[test]
fn settings_root_six_rows_have_symmetric_32px_inner_padding() {
    let mut state = ready();
    state.open_settings();
    state.preferences.reduced_motion = true;
    let layout = scene(&state);
    let panels = layout
        .draw
        .iter()
        .filter_map(crate::view::tvos_settings_view::backdrop_rect)
        .collect::<Vec<_>>();
    assert_eq!(panels.len(), 6);
    assert!(panels.iter().all(|r| (r.h - 788.).abs() < 0.01));
    let last = layout
        .controls
        .iter()
        .find(|c| c.target == Target::Sidebar(5))
        .unwrap();
    assert!((last.rect.y + last.rect.h + 32. - (184. + 788.)).abs() < 0.01);
}
#[test]
fn settings_backdrops_stay_in_place_during_content_cascade_and_height_change() {
    use crate::state::SettingsLevel;
    use std::time::{Duration, Instant};
    let mut state = ready();
    state.open_settings();
    state.preferences.reduced_motion = false;
    let old_scene = scene(&state);
    state.last_body = old_scene.draw[old_scene.body_range.clone()].to_vec();
    state.settings_level = SettingsLevel::Section;
    state.section = 0;
    let old = old_scene.draw[old_scene.settings_panel_range.clone()].to_vec();
    state.previous_panel_layer = Some((old, Instant::now() - Duration::from_millis(100), true));
    state.panel_started = Some(Instant::now() - Duration::from_millis(100));
    let changed = scene(&state);
    let panels = changed.draw[changed.settings_panel_range.clone()]
        .iter()
        .filter_map(crate::view::tvos_settings_view::backdrop_rect)
        .collect::<Vec<_>>();
    assert_eq!(panels.len(), 6);
    for r in panels {
        assert!(r.y == 184. || r.y == 192.);
        assert!(r.x == crate::state::HOME_STRIP_LEFT || r.x == 832.);
        assert!(
            r.h < 696. && r.h > 568.,
            "height should ease between pages: {}",
            r.h
        );
    }
    let background_count = changed
        .draw
        .iter()
        .filter_map(crate::view::tvos_settings_view::backdrop_rect)
        .count();
    assert_eq!(background_count, 6);
}
#[test]
fn focused_connected_input_keeps_prefix_readable_and_green_status() {
    let mut state = ready();
    state.open_settings();
    state.section = crate::state::INPUTS_SECTION;
    state.settings_level = crate::state::SettingsLevel::Section;
    state.preferences.reduced_motion = true;
    state.inventory.inputs[0].title = "PC".into();
    state.focus = Target::InputMode(state.inventory.inputs[0].id.clone());
    let layout = scene(&state);
    let mut found_prefix = false;
    let mut found_green = false;
    for d in &layout.draw {
        if let crate::renderer::Draw::Text(value, rect, _, color, _) = d {
            if value == "PC · " {
                found_prefix = true;
                assert_eq!(rect.x, 896.);
                assert!(color[0] < 0.4 && color[1] < 0.4 && color[2] < 0.4);
            }
            if value == "Connected" {
                found_green = true;
                assert!(
                    (color[0] - 48. / 255.).abs() < 0.01 && (color[1] - 209. / 255.).abs() < 0.01
                );
            }
        }
    }
    assert!(found_prefix && found_green);
}

#[test]
fn accent_preferences_default_is_backwards_compatible_and_persists() {
    let mut prefs = Preferences::default();
    // The default look is the default: Citrus gradient everywhere.
    assert_eq!(prefs.accent.id, "Citrus");
    assert_eq!(prefs.accent.kind, "gradient");
    assert!(prefs.accent.use_focus && prefs.accent.use_nav && prefs.accent.use_headline);
    prefs.accent.choose(8);
    assert_eq!(prefs.accent.id, "Aurora");
    prefs.accent.use_focus = true;
    prefs.accent.use_nav = true;
    prefs.accent.use_headline = true;
    let stored = serde_json::to_string(&prefs).unwrap();
    assert!(stored.contains("\"accent\""));
    let loaded: Preferences = serde_json::from_str(&stored).unwrap();
    assert_eq!(loaded.accent.id, "Aurora");
    assert_eq!(loaded.accent.colors(), (0xA978FF, 0x3FA2FF));
    assert!(loaded.accent.use_focus && loaded.accent.use_nav && loaded.accent.use_headline);
    let mut old = serde_json::to_value(prefs).unwrap();
    old.as_object_mut().unwrap().remove("accent");
    let migrated: Preferences = serde_json::from_value(old).unwrap();
    assert_eq!(migrated.accent.id, "Citrus");
    assert!(migrated.accent.use_focus);
}
#[test]
fn appearance_has_four_eight_color_rows_and_three_toggles() {
    let mut state = ready();
    legacy_look(&mut state.preferences);
    state.open_settings();
    state.section = crate::state::APPEARANCE_SECTION;
    state.settings_level = crate::state::SettingsLevel::Section;
    state.focus = Target::AccentChoice(7);
    state.preferences.reduced_motion = true;
    let rendered = scene(&state);
    assert_eq!(
        rendered
            .controls
            .iter()
            .filter(|r| matches!(r.target, Target::AccentChoice(_)))
            .count(),
        16
    );
    assert_eq!(
        rendered
            .controls
            .iter()
            .filter(|r| matches!(r.target, Target::AccentOption(_)))
            .count(),
        3
    );
    assert_eq!(
        rendered
            .draw
            .iter()
            .filter(|d| matches!(d, crate::renderer::Draw::DiagonalGradient(_, _, _, _)))
            .count(),
        8
    );
    state.focus = Target::AccentChoice(8);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.preferences.accent.id, "Aurora");
    state.focus = Target::AccentOption(0);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert!(state.preferences.accent.use_focus);
}
#[test]
fn appearance_navigation_preserves_root_position_and_back() {
    let mut state = ready();
    state.open_settings();
    state.preferences.reduced_motion = true;
    state.focus = Target::Sidebar(1);
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(
        state.focus,
        Target::Sidebar(crate::state::APPEARANCE_SECTION)
    );
    state.activate();
    assert_eq!(state.focus, Target::AccentChoice(7));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::AccentChoice(15));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::AccentOption(0));
    state.back();
    assert_eq!(
        state.focus,
        Target::Sidebar(crate::state::APPEARANCE_SECTION)
    );
}

#[test]
fn appearance_left_direction_never_navigates_back() {
    use crate::state::{APPEARANCE_SECTION, SettingsLevel};
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open_settings();
    state.section = APPEARANCE_SECTION;
    state.settings_level = SettingsLevel::Section;
    state.focus = Target::AccentChoice(7);
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.settings_level, SettingsLevel::Section);
    assert_eq!(state.focus, Target::AccentChoice(6));
    state.focus = Target::AccentChoice(0);
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.settings_level, SettingsLevel::Section);
    assert_eq!(state.focus, Target::SettingsBack);
    state.focus = Target::AccentChoice(8);
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::SettingsBack);
    state.focus = Target::AccentOption(0);
    state.direction(Direction::Left, &controls(&state));
    assert_eq!(state.focus, Target::SettingsBack);
    state.focus = Target::SettingsBack;
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::Root);
    assert_eq!(state.focus, Target::Sidebar(APPEARANCE_SECTION));
}
#[test]
fn bright_accent_navigation_uses_dark_ink() {
    let dark = crate::view::contrast_text_for_accent(0xC6FF00, 0x00D5FF);
    assert!(dark[0] < 0.15 && dark[1] < 0.15 && dark[2] < 0.15);
    let bright = crate::view::contrast_text_for_accent(0xFFFFFF, 0xFFFFFF);
    assert!(bright[0] < 0.15);
    let pale_blue = crate::view::contrast_text_for_accent(0x64D2FF, 0x0A84FF);
    assert!(pale_blue[0] < 0.15);
}
#[test]
fn gradient_focus_ring_uses_two_color_native_border() {
    use crate::state::{APPEARANCE_SECTION, SettingsLevel};
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.preferences.accent.choose(12); // 8 solids + Citrus gradient index 4
    state.preferences.accent.use_focus = true;
    state.open_settings();
    state.focus = Target::Sidebar(APPEARANCE_SECTION);
    let rendered = scene(&state);
    // The focused Settings row is one solid accent gradient fill (no outline).
    assert!(
        rendered
            .draw
            .iter()
            .any(|d| matches!(d, crate::renderer::Draw::DiagonalGradient(_, _, _, _)))
    );
    assert_eq!(state.preferences.accent.colors(), (0xFFE94A, 0x3FD3FF));
    state.settings_level = SettingsLevel::Section;
    state.section = APPEARANCE_SECTION;
    let scene = scene(&state);
    let swatches = scene
        .controls
        .iter()
        .filter(|r| matches!(r.target, Target::AccentChoice(_)))
        .count();
    assert_eq!(swatches, 16);
}

#[test]
fn typography_all_pages_use_semantic_tv_scale() {
    use crate::renderer::Draw;
    let scale = [25., 29., 31., 38., 52., 108.];
    let mut state = ready();
    legacy_look(&mut state.preferences);
    for page in 0..3 {
        state.open(page);
        let scene = scene(&state);
        let mut seen = 0;
        // Settings illustrations scale their own fixed-size type with the scene.
        let art = if scene.settings_sidebar_key != 0 {
            scene.settings_sidebar_range.clone()
        } else {
            0..0
        };
        for (index, command) in scene.draw.into_iter().enumerate() {
            if art.contains(&index) {
                continue;
            }
            if let Draw::Text(_, rect, style, _, _) = command {
                // Home widgets are deliberately denser TV type: their 18–84px
                // hierarchy keeps six hourly columns and price rows whole.
                // The zone is grid columns 4–6 with the text line above it.
                let weather = page == 0
                    && rect.x >= crate::state::HOME_STRIP_LEFT + 3. * crate::state::HOME_TILE_PITCH
                    && rect.y >= 168. - state.scroll
                    && rect.y <= 640. - state.scroll;
                // The caption under a focused header circle is deliberately small.
                let circle_caption = rect.y >= 112. && rect.y < 160. && rect.x > 1200.;
                if circle_caption {
                    assert!(style.size >= 19.);
                    continue;
                }
                // Header clock (as tall as the navigation pill) and the date
                // beside it, which steps down to fit before the navigation.
                if rect.y < 112. && rect.x < 760. {
                    assert!(style.size >= 21.);
                    continue;
                }
                if weather {
                    assert!(
                        (18. ..=84.).contains(&style.size),
                        "weather text must stay legible: {}",
                        style.size
                    );
                } else {
                    // Small labels keep their own size from the 18 px floor.
                    assert!(
                        scale.contains(&style.size) || (18. ..27.).contains(&style.size),
                        "page {page}: {}",
                        style.size
                    );
                }
                assert!(style.weight >= 500, "page {page}: {}", style.weight);
                seen += 1;
            }
        }
        assert!(seen > 0, "page {page} contains no text");
    }
}

#[test]
fn independent_fonts_roundtrip_preserves_preferences_and_limits() {
    use crate::typography::{HeadingFont, TextFont};
    let mut original = serde_json::to_value(Preferences::default()).unwrap();
    original["heading_font"] = json!("unbounded");
    original["text_font"] = json!("golostext");
    original["heading_size_pct"] = json!(110);
    original["text_size_pct"] = json!(90);
    original["hidden"] = json!(["com.example.hidden"]);
    original["input_names"] = json!({"hdmi1":"BEAST","hdmi2":"Apple TV"});
    let p: Preferences = serde_json::from_value(original.clone()).unwrap();
    assert_eq!(p.heading_font, HeadingFont::Unbounded);
    assert_eq!(p.text_font, TextFont::Golostext);
    assert_eq!(p.heading_size_pct, 110);
    let saved = serde_json::to_value(p).unwrap();
    assert_eq!(saved["hidden"], original["hidden"]);
    assert_eq!(saved["input_names"], original["input_names"]);
    assert_eq!(saved["heading_font"], "unbounded");
    assert_eq!(saved["text_font"], "golostext");
}
#[test]
fn appearance_has_independent_font_lists_and_clipped_scroll() {
    use crate::state::{APPEARANCE_SECTION, SettingsLevel};
    use crate::typography::{HeadingFont, TextFont};
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.open_settings();
    state.focus = Target::Sidebar(APPEARANCE_SECTION);
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::Section);
    let rendered = scene(&state);
    assert!(
        rendered
            .controls
            .iter()
            .any(|c| c.target == Target::HeadingFontOpen)
    );
    assert!(
        rendered
            .controls
            .iter()
            .any(|c| c.target == Target::TextFontOpen)
    );
    assert!(
        rendered
            .controls
            .iter()
            .any(|c| c.target == Target::HeadingSize)
    );
    assert!(
        rendered
            .controls
            .iter()
            .any(|c| c.target == Target::TextSize)
    );
    assert_eq!(
        rendered
            .controls
            .iter()
            .filter(|c| matches!(c.target, Target::AccentChoice(_)))
            .count(),
        16
    );
    state.focus = Target::HeadingFontOpen;
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::HeadingFonts);
    let rendered = scene(&state);
    assert_eq!(
        rendered
            .controls
            .iter()
            .filter(|c| matches!(c.target, Target::HeadingFontPick(_)))
            .count(),
        HeadingFont::ALL.len()
    );
    state.focus = Target::HeadingFontPick(2);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.preferences.heading_font, HeadingFont::Unbounded);
    state.back();
    assert_eq!(state.settings_level, SettingsLevel::Section);
    assert_eq!(state.focus, Target::HeadingFontOpen);
    state.focus = Target::TextFontOpen;
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::TextFonts);
    assert_eq!(
        scene(&state)
            .controls
            .iter()
            .filter(|c| matches!(c.target, Target::TextFontPick(_)))
            .count(),
        TextFont::ALL.len()
    );
    state.focus = Target::TextFontPick(1);
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.preferences.text_font, TextFont::Manrope);
    state.back();
    assert_eq!(state.focus, Target::TextFontOpen);
    state.focus = Target::HeadingSize;
    state.preferences.heading_size_pct = 170;
    state.activate();
    assert_eq!(state.preferences.heading_size_pct, 85);
    state.focus = Target::TextSize;
    state.preferences.text_size_pct = 150;
    state.activate();
    assert_eq!(state.preferences.text_size_pct, 90);
}
#[test]
fn appearance_approved_2240_palette_and_spacing() {
    use crate::model::{ACCENT_GRADIENTS, ACCENT_SOLIDS};
    let reference_solids = [
        0x4D9DF7, 0x7F7DE8, 0xC77FEA, 0xF2677F, 0xF5B04A, 0x5CCB79, 0x7FCDEB, 0xF2F2F5,
    ];
    let reference_gradients = [
        (0xA978FF, 0x3FA2FF),
        (0xF95B7D, 0xFAB942),
        (0x46E5AF, 0x42ADF1),
        (0xF760A8, 0xFCBB97),
        (0xFFE94A, 0x3FD3FF),
        (0xEC447B, 0x8E54DC),
        (0xFAD750, 0xF79445),
        (0xF7F8FA, 0x9EABBA),
    ];
    assert_eq!(ACCENT_SOLIDS.map(|(_, color)| color), reference_solids);
    assert_eq!(
        ACCENT_GRADIENTS.map(|(_, a, b)| (a, b)),
        reference_gradients
    );
    let mut state = ready();
    state.open_settings();
    state.section = crate::state::APPEARANCE_SECTION;
    state.settings_level = crate::state::SettingsLevel::Section;
    let scene = scene(&state);
    let right = 832.;
    let top = 184.;
    let safe = 808.;
    assert!(scene.draw.iter().any(
        |d| matches!(d,crate::renderer::Draw::Clip(Some(r)) if r.x>=right && r.y>=top && r.h<=safe)
    ));
}
#[test]
fn nav_labels_do_not_use_heading_font_by_size() {
    let mut state = ready();
    state.open(0);
    let scene = scene(&state);
    for draw in &scene.draw {
        if let crate::renderer::Draw::Text(label, _, style, _, _) = draw
            && [
                "Home",
                "Apps",
                "Settings",
                "Next video",
                "Video gallery",
                "Netflix",
            ]
            .contains(&label.as_str())
        {
            assert_eq!(
                style.display,
                Some(false),
                "interactive label {label} is display"
            );
        }
    }
}

#[test]
fn upgraded_2240_preserves_original_approved_palette() {
    let mut state = ready();
    state.preferences.accent.kind = "gradient".into();
    state.preferences.accent.id = "Citrus".into();
    state.preferences.accent.normalized();
    assert_eq!(state.preferences.accent.colors(), (0xFFE94A, 0x3FD3FF));
    assert_eq!(crate::model::ACCENT_SOLIDS.len(), 8);
    assert_eq!(crate::model::ACCENT_GRADIENTS.len(), 8);
}

#[test]
fn ui_resolution_modes_are_bounded_and_persisted() {
    use crate::model::{Preferences, UiResolution};
    assert_eq!(UiResolution::ALL.len(), 4);
    assert_eq!(UiResolution::Auto.pixels(), crate::raster::Size::UHD);
    assert_eq!(
        UiResolution::Qhd.pixels(),
        crate::raster::Size::new(2560, 1440)
    );
    assert_eq!(UiResolution::Hd.pixels(), crate::raster::Size::HD);
    assert_eq!(UiResolution::Uhd.lower(), UiResolution::Qhd);
    assert_eq!(UiResolution::Qhd.lower(), UiResolution::Hd);
    assert_eq!(UiResolution::Hd.lower(), UiResolution::Hd);
    let mut prefs = Preferences::default();
    assert_eq!(prefs.ui_resolution, UiResolution::Qhd);
    prefs.ui_resolution = UiResolution::Auto;
    assert_eq!(prefs.ui_resolution_value(), "Auto · 4K");
    prefs.auto_ui_cap = UiResolution::Qhd;
    assert_eq!(prefs.ui_resolution_value(), "Auto · 1440p");
    prefs.ui_resolution = UiResolution::Hd;
    assert_eq!(prefs.resolved_ui_size(), crate::raster::Size::HD);
    let encoded = serde_json::to_string(&prefs).unwrap();
    let restored: Preferences = serde_json::from_str(&encoded).unwrap();
    assert_eq!(restored.ui_resolution, UiResolution::Hd);
    assert_eq!(restored.auto_ui_cap, UiResolution::Qhd);
    let legacy: Preferences = serde_json::from_str("{}").unwrap();
    assert_eq!(legacy.resolved_ui_size(), UiResolution::Qhd.pixels());
}

#[test]
fn ui_resolution_selection_back_restores_appearance_and_remote_navigation() {
    use crate::model::UiResolution;
    use crate::state::{APPEARANCE_SECTION, SettingsLevel};
    let mut state = ready();
    legacy_look(&mut state.preferences);
    state.preferences.reduced_motion = true;
    state.open_settings();
    state.focus = Target::Sidebar(APPEARANCE_SECTION);
    state.activate();
    let appearance = scene(&state);
    assert!(
        appearance
            .controls
            .iter()
            .any(|c| c.target == Target::UiResolutionOpen)
    );
    state.focus = Target::UiResolutionOpen;
    state.activate();
    assert_eq!(state.settings_level, SettingsLevel::UiResolution);
    assert_eq!(state.focus, Target::UiResolutionPick(0));
    let choices = scene(&state);
    assert_eq!(
        choices
            .controls
            .iter()
            .filter(|c| matches!(c.target, Target::UiResolutionPick(_)))
            .count(),
        4
    );
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::UiResolutionPick(1));
    state.direction(Direction::Down, &controls(&state));
    assert_eq!(state.focus, Target::UiResolutionPick(2));
    assert_eq!(state.activate(), vec![Effect::Save]);
    assert_eq!(state.preferences.ui_resolution, UiResolution::Qhd);
    state.back();
    assert_eq!(state.settings_level, SettingsLevel::Section);
    assert_eq!(state.focus, Target::UiResolutionOpen);
    state.back();
    assert_eq!(state.settings_level, SettingsLevel::Root);
    assert_eq!(state.focus, Target::Sidebar(APPEARANCE_SECTION));
}

#[test]
fn nunito_heading_and_body_are_independent_and_live() {
    use crate::typography::{HeadingFont, TextFont};
    let mut state = ready();
    state.preferences.heading_font = HeadingFont::Nunito;
    state.preferences.text_font = TextFont::Inter;
    assert_eq!(state.preferences.heading_font.name(), "Nunito");
    assert!(HeadingFont::ALL.contains(&HeadingFont::Nunito));
    assert!(TextFont::ALL.contains(&TextFont::Nunito));
    assert!(HeadingFont::Nunito.scale() >= 0.9 && HeadingFont::Nunito.scale() <= 1.14);
    let prefs = serde_json::to_string(&state.preferences).unwrap();
    assert!(prefs.contains("\"heading_font\":\"nunito\""));
    state.preferences.text_font = TextFont::Nunito;
    assert_eq!(state.preferences.text_font.id(), "nunito");
}

#[test]
fn large_weather_heading_wraps_at_most_twice_and_pushes_favorites_below_subtitle() {
    use crate::renderer::Draw;
    use crate::weather_phrases::{Category, Phrase};
    let mut state = ready();
    state.preferences.reduced_motion = true;
    state.preferences.heading_size_pct = 170;
    state.preferences.text_size_pct = 150;
    state.rude_weather.current = Some(Phrase {
        category: Category::Cloudy,
        title: "Another ridiculous grey weather headline with several words".into(),
        subtitle: "Nothing is cooperating today".into(),
    });
    let rendered = scene(&state);
    let mut heading_lines: Vec<f32> = Vec::new();
    let mut subtitle_bottom = 0.0f32;
    let mut favorites_y = None;
    for draw in rendered.draw {
        if let Draw::Text(ref label, rect, style, _, _) = draw {
            if label == "Another "
                || label == "ridiculous "
                || label == "grey "
                || label == "weather "
                || label == "headline "
                || label == "with "
                || label == "several "
                || label == "words"
            {
                if !heading_lines.iter().any(|&y| (y - rect.y).abs() < 0.5) {
                    heading_lines.push(rect.y);
                }
                assert!(style.display == Some(true));
            }
            if label == "today" {
                subtitle_bottom = rect.y + rect.h;
            }
            if label == "Favorite apps" {
                favorites_y = Some(rect.y);
            }
        }
    }
    assert!(!heading_lines.is_empty(), "Rude headline is visible");
    assert!(
        heading_lines.len() <= 2,
        "Rude headline must fit two lines: {heading_lines:?}"
    );
    assert!(subtitle_bottom > heading_lines.iter().copied().fold(0.0f32, f32::max));
    assert!(favorites_y.expect("Favorites") >= subtitle_bottom + 2.);
}
#[test]
fn heading_text_size_bounds_keep_new_upper_limits_after_prefs_roundtrip() {
    let mut prefs = Preferences {
        heading_size_pct: 255,
        text_size_pct: 255,
        ..Default::default()
    };
    prefs.sanitize();
    assert_eq!(prefs.heading_size_pct, 170);
    assert_eq!(prefs.text_size_pct, 150);
    let stored = serde_json::to_string(&prefs).unwrap();
    let loaded: Preferences = serde_json::from_str(&stored).unwrap();
    assert_eq!(loaded.heading_size_pct, 170);
    assert_eq!(loaded.text_size_pct, 150);
}

/// The pre-25.10 defaults that many layout tests were written against.
fn legacy_look(prefs: &mut Preferences) {
    prefs.accent = crate::model::Accent {
        kind: "solid".into(),
        id: "White".into(),
        use_focus: false,
        use_nav: false,
        use_headline: false,
    };
    prefs.heading_font = crate::typography::HeadingFont::Archivo;
    prefs.text_font = crate::typography::TextFont::Inter;
    prefs.heading_size_pct = 100;
    prefs.text_size_pct = 100;
    prefs.phrase_subtitle_pct = 100;
    prefs.ui_resolution = crate::model::UiResolution::Auto;
}

#[test]
fn leaving_a_scrolled_stack_row_glides_home_with_one_small_swing() {
    use crate::state::{STACK_RETURN_DELAY, STACK_RETURN_TIME, stack_return_curve};
    for offset in [300., 1200., 5000.] {
        assert_eq!(stack_return_curve(offset, STACK_RETURN_DELAY * 0.5), offset);
        let mid = stack_return_curve(offset, STACK_RETURN_DELAY + 0.15);
        assert!(mid > 0. && mid < offset);
        let lowest = (0..400)
            .map(|i| stack_return_curve(offset, i as f32 * STACK_RETURN_TIME / 400.))
            .fold(f32::MAX, f32::min);
        assert!(
            lowest < 0. && lowest > -41. && lowest > -offset * 0.05,
            "overshoot {lowest}"
        );
        let end = stack_return_curve(offset, STACK_RETURN_TIME - 0.01);
        assert!(end.abs() < 4., "settled {end}");
        const { assert!(STACK_RETURN_TIME <= 0.45) };
        // One swing only: once it starts coming back it never turns again.
        let samples: Vec<f32> = (0..=400)
            .map(|i| stack_return_curve(offset, i as f32 * STACK_RETURN_TIME / 400.))
            .collect();
        let turns = samples
            .windows(3)
            .filter(|w| (w[1] - w[0]) * (w[2] - w[1]) < 0.)
            .count();
        assert_eq!(turns, 1, "wobble");
        assert_eq!(stack_return_curve(offset, STACK_RETURN_TIME + 0.01), 0.);
    }
}

#[test]
fn stack_card_opens_title_card_and_back_returns_to_the_card() {
    use crate::media::{Detail, PlayRequest};
    use crate::stacks::{StackConfig, StackItem};
    let mut state = ready();
    state.preferences.stacks = vec![StackConfig {
        source: "jellyfin".into(),
        ..Default::default()
    }];
    state.stack_items = vec![
        (1..=3)
            .map(|id| StackItem {
                title: format!("Film {id}"),
                poster: None,
                id,
            })
            .collect(),
    ];
    state.focus = Target::StackCard(0, 1);
    assert_eq!(state.activate(), vec![Effect::MediaDetails(2)]);
    assert!(state.movie.is_some());
    assert_eq!(state.focus, Target::MoviePlay);
    state.movie_details(Detail {
        id: 2,
        title: "Film 2".into(),
        subtitles: vec![("English".into(), "http://x/en.srt".into())],
        qualities: vec!["1080p".into(), "720p".into()],
        ..Default::default()
    });
    // The card is drawn on top and takes every control.
    let targets: Vec<Target> = controls(&state).into_iter().map(|c| c.target).collect();
    assert!(targets.contains(&Target::MovieClose));
    assert!(!targets.iter().any(|t| matches!(t, Target::StackCard(..))));
    // The pickers sit in Play's row; OK opens the subtitles panel.
    state.direction(Direction::Right, &[]);
    assert_eq!(state.focus, Target::MoviePill(1));
    state.activate();
    assert_eq!(state.focus, Target::MovieOption(0));
    state.direction(Direction::Down, &[]);
    state.activate();
    assert_eq!(state.focus, Target::MoviePill(1));
    state.direction(Direction::Down, &[]);
    assert_eq!(
        state.activate(),
        vec![Effect::MediaPlay(PlayRequest {
            id: 2,
            episode: None,
            quality: None,
            subtitle: Some("English".into()),
        })]
    );
    // More like this lists the other cards of the row.
    state.direction(Direction::Down, &[]);
    assert_eq!(state.focus, Target::MovieSimilar(0));
    state.back();
    assert!(state.movie.is_none());
    assert_eq!(state.focus, Target::StackCard(0, 1));
}

#[test]
fn title_card_waits_for_details_then_comes_in_without_the_stand_in_title() {
    use crate::media::Detail;
    use crate::renderer::Draw;
    use crate::stacks::{StackConfig, StackItem};
    let mut state = ready();
    state.preferences.stacks = vec![StackConfig {
        source: "jellyfin".into(),
        ..Default::default()
    }];
    state.stack_items = vec![vec![StackItem {
        title: "Фильм / Film".into(),
        poster: None,
        id: 7,
    }]];
    state.focus = Target::StackCard(0, 0);
    state.activate();
    let visible = |state: &State, text: &str| {
        scene(state)
            .draw
            .iter()
            .any(|d| matches!(d, Draw::Text(t, _, _, color, _) if t == text && color[3] > 0.01))
    };
    // While the details travel, the stack title ("RU / EN") never shows.
    assert!(!visible(&state, "Фильм / Film"));
    state.movie_details(Detail {
        id: 7,
        title: "Фильм".into(),
        ..Default::default()
    });
    // The details start the entrance; it ends with everything in place.
    let m = state.movie.as_mut().unwrap();
    assert!(m.shown.is_some());
    m.opened = std::time::Instant::now() - std::time::Duration::from_secs(2);
    m.shown = Some(m.opened);
    assert!(visible(&state, "Фильм"));
    assert!(!visible(&state, "Фильм / Film"));
}

#[test]
fn root_status_reads_the_homebrew_exec_reply() {
    use crate::platform::parse_root_status;
    assert_eq!(parse_root_status("noroot\n"), None);
    assert_eq!(parse_root_status(""), None);
    let status = parse_root_status(
        "root\nwake\n{\n  \"settings\": { \"homeAutoLaunch\": \"off\" },\n  \"returnValue\": true\n}\n",
    )
    .unwrap();
    assert!(status.wake);
    assert_eq!(status.home_auto_launch, Some(false));
    let status = parse_root_status("root\n").unwrap();
    assert!(!status.wake);
    assert_eq!(status.home_auto_launch, None);
}

#[test]
fn auto_input_follows_the_hdmi_picture_not_only_the_cable() {
    let reply = json!({"returnValue": true,
        "HDMI1": {"5v": "TRUE", "signal": "TRUE"},
        "HDMI2": {"5v": "TRUE", "signal": "FALSE"},
        "HDMI3": {"5v": "FALSE", "signal": "FALSE"}});
    let signals = crate::platform::parse_signals(&reply);
    assert_eq!(signals, vec![(1, true), (2, false), (3, false)]);
    let mut inputs = demo_inventory().inputs;
    assert!(crate::model::apply_signals(&mut inputs, &signals));
    let preferences = Preferences::default();
    // Both cables are plugged in; only the device sending a picture shows.
    assert!(preferences.input_visible(&inputs[0]));
    assert!(!preferences.input_visible(&inputs[1]));
    assert!(!crate::model::apply_signals(&mut inputs, &signals));
}

fn ha_entity(id: &str, name: &str, state: &str) -> crate::smart_home::Entity {
    crate::smart_home::Entity {
        id: id.into(),
        name: name.into(),
        state: state.into(),
        domain: id.split_once('.').unwrap().0.into(),
        ..Default::default()
    }
}

#[test]
fn smart_home_recommends_controls_not_maintenance_entities() {
    let mut hidden = ha_entity("switch.porch", "Porch", "on");
    hidden.hidden = true;
    let mut door = ha_entity("binary_sensor.front", "Front door", "off");
    door.device_class = "door".into();
    let useful = [
        ha_entity("light.desk", "Desk", "on"),
        ha_entity("switch.soundbar", "Sony Soundbar", "off"),
        ha_entity("camera.yard", "Yard", "idle"),
        door,
    ];
    let noise = [
        hidden,
        ha_entity("switch.led_indicator", "Mini Switch Indicator", "on"),
        ha_entity("sensor.mini_battery", "Mini Switch Battery", "88"),
        ha_entity("binary_sensor.config_dirty", "Config Dirty", "off"),
        ha_entity("light.garden", "Garden", "unavailable"),
        ha_entity("sensor.power", "Power", "12"),
    ];
    assert!(useful.iter().all(|e| e.useful()));
    assert!(noise.iter().all(|e| !e.useful()));
}

#[test]
fn smart_home_shows_one_stream_per_camera() {
    use crate::smart_home::stream_twin;
    assert_eq!(
        stream_twin("camera.garden_sd_stream").as_deref(),
        Some("camera.garden_hd_stream")
    );
    assert_eq!(stream_twin("camera.garden_hd_stream"), None);
    assert!(ha_entity("camera.garden_hd_stream", "Garden HD", "idle").useful());
    assert!(!ha_entity("camera.garden_sd_stream", "Garden SD", "idle").useful());
    let mut state = crate::state::State::new(crate::model::Preferences::default());
    state.ha_entities = vec![
        ha_entity(
            "camera.outdoor_camera_hd_stream",
            "Outdoor Camera HD Stream",
            "idle",
        ),
        ha_entity(
            "camera.outdoor_camera_sd_stream",
            "Outdoor Camera SD Stream",
            "idle",
        ),
        ha_entity(
            "camera.living_room_cam_hd_stream",
            "Living Room Cam HD Stream",
            "idle",
        ),
        ha_entity(
            "camera.living_room_cam_sd_stream",
            "Living Room Cam SD Stream",
            "idle",
        ),
    ];
    let shown: Vec<_> = state.ha_tab(1).iter().map(|e| e.id.clone()).collect();
    assert_eq!(
        shown,
        [
            "camera.living_room_cam_hd_stream",
            "camera.outdoor_camera_hd_stream"
        ]
    );
}

#[test]
fn smart_home_tab_defaults_to_recommended_and_bulk_choices() {
    use crate::state::Target;
    let mut state = crate::state::State::new(crate::model::Preferences::default());
    let mut diagnostic = ha_entity("switch.reboot", "Reboot", "off");
    diagnostic.hidden = true;
    state.ha_entities = vec![
        ha_entity("light.desk", "Desk", "on"),
        ha_entity("sensor.mini_battery", "Mini Switch Battery", "88"),
        diagnostic,
    ];
    let ids = |state: &crate::state::State| -> Vec<String> {
        state.ha_tab(0).iter().map(|e| e.id.clone()).collect()
    };
    // Hidden/diagnostic entities are not even listed; noise is listed but off.
    assert_eq!(state.ha_selection_entries(0).len(), 2);
    assert_eq!(ids(&state), vec!["light.desk"]);
    state.focus = Target::SmartBulk(0, 1);
    state.activate();
    assert_eq!(ids(&state).len(), 2);
    state.focus = Target::SmartBulk(0, 2);
    state.activate();
    assert!(ids(&state).is_empty());
    state.focus = Target::SmartBulk(0, 0);
    state.activate();
    assert_eq!(ids(&state), vec!["light.desk"]);
}

#[test]
fn smart_home_old_everything_selection_is_reset_once() {
    let mut preferences = crate::model::Preferences::default();
    preferences.smart_home.selected_entities = vec!["sensor.noise".into()];
    let state = crate::state::State::new(preferences);
    assert!(state.preferences.smart_home.selected_entities.is_empty());
    assert_eq!(state.preferences.smart_home.selection_version, 1);
    let kept = crate::state::State::new(state.preferences.clone());
    assert_eq!(kept.preferences.smart_home.selection_version, 1);
}

#[test]
fn hidden_camera_snapshot_is_blurred_small() {
    let sharp = image::RgbImage::from_fn(640, 360, |x, y| {
        if (x / 8 + y / 8) % 2 == 0 {
            image::Rgb([255, 255, 255])
        } else {
            image::Rgb([0, 0, 0])
        }
    });
    let mut jpeg = Vec::new();
    sharp
        .write_to(
            &mut std::io::Cursor::new(&mut jpeg),
            image::ImageFormat::Jpeg,
        )
        .unwrap();
    let soft = crate::smart_home::blur_snapshot(&jpeg).unwrap();
    let soft = image::load_from_memory(&soft).unwrap().to_luma8();
    assert_eq!((soft.width(), soft.height()), (480, 270));
    // The checkerboard is gone: every pixel sits near the mid grey.
    assert!(soft.pixels().all(|p| (80..=176).contains(&p.0[0])));
}

#[test]
fn unsupported_saved_media_source_is_ignored_without_losing_other_settings() {
    let saved = serde_json::json!({
        "stacks": [
            {"source": "obsolete", "collection": "popular", "name": "Old row"},
            {"source": "jellyfin", "collection": "recent", "name": "Recent media"}
        ],
        "former_account": {"unexpected": "value"},
        "luma_player": true
    });
    let mut prefs: crate::model::Preferences = serde_json::from_value(saved).unwrap();
    prefs.sanitize();
    assert_eq!(prefs.stacks.len(), 1);
    assert_eq!(prefs.stacks[0].source, "jellyfin");
    assert_eq!(prefs.stacks[0].collection, "recent");
    assert!(prefs.luma_player);
}