use crate::definition::ThemeDefinition;
use crate::ramps::{AccentShades, Oklch, contrast_foreground, derive_shades, mix};
use crate::system::SystemTheme;
use crate::{
    Borders, ColorTokens, Elevations, Motion, Radius, Scrollbar, SizeTable, Spacing, ThemeVariant,
};
use gpui::px;

/// The floor of a custom titlebar's height, in px at 100% scaling: the height
/// macOS and Linux titlebars draw at regardless of the control scale.
const TITLEBAR_HEIGHT_MIN_PX: f32 = 34.0;

/// Derived state shades for the colors that get pressed and hovered.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Ramps {
    pub primary: AccentShades,
    pub secondary: AccentShades,
    pub destructive: AccentShades,
    pub success: AccentShades,
    pub warning: AccentShades,
    pub info: AccentShades,
}

/// Everything a component paints from, after the overlay chain.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ResolvedTheme {
    pub variant: ThemeVariant,
    pub colors: ColorTokens,
    pub ramps: Ramps,
    pub radius: Radius,
    pub borders: Borders,
    pub spacing: Spacing,
    pub elevations: Elevations,
    pub motion: Motion,
    pub scrollbar: Scrollbar,
    /// The height the window's titlebar strips draw at, per the platform.
    pub titlebar_height: gpui::Pixels,
    /// The platform's native root font size; the fallback theme uses 16.
    pub root_font_size: gpui::Pixels,
    /// The platform's monospace family, for code surfaces.
    pub mono_font: &'static str,
    pub sizes: SizeTable,
    pub accessibility: crate::system::AccessibilityPreferences,
}

/// Overlay order (later wins): neutral base → system → preset definition.
pub(crate) fn resolve(
    system: &SystemTheme,
    preset: Option<&ThemeDefinition>,
    mode_override: Option<ThemeVariant>,
) -> ResolvedTheme {
    let variant = mode_override
        .or(preset.and_then(|def| def.mode))
        .unwrap_or(system.variant);

    let base = match variant {
        ThemeVariant::Light => ColorTokens::light(),
        ThemeVariant::Dark => ColorTokens::dark(),
    };

    let system_palette = system.palette;
    let pick = |def: Option<gpui::Hsla>, system: Option<gpui::Hsla>, base: gpui::Hsla| {
        def.or(system).unwrap_or(base)
    };

    let def_color = |field: fn(&ThemeDefinition) -> Option<gpui::Hsla>| preset.and_then(field);

    let accent = pick(def_color(|d| d.accent()), system.accent, base.accent);
    let primary = pick(def_color(|d| d.primary()), system.accent, base.primary);

    let destructive = pick(
        def_color(|d| d.destructive()),
        system_palette.destructive,
        base.destructive,
    );
    let success = pick(
        def_color(|d| d.success()),
        system_palette.success,
        base.success,
    );
    let warning = pick(
        def_color(|d| d.warning()),
        system_palette.warning,
        base.warning,
    );
    let info = pick(def_color(|d| d.info()), system_palette.info, base.info);

    let mut colors = ColorTokens {
        background: pick(
            def_color(|d| d.background()),
            system_palette.background,
            base.background,
        ),
        foreground: pick(
            def_color(|d| d.foreground()),
            system_palette.foreground,
            base.foreground,
        ),
        surface: pick(
            def_color(|d| d.surface()),
            system_palette.surface,
            base.surface,
        ),
        surface_foreground: pick(
            def_color(|d| d.surface_foreground()),
            system_palette.surface_foreground,
            base.surface_foreground,
        ),
        primary,
        primary_foreground: pick(
            def_color(|d| d.primary_foreground()),
            system_palette.primary_foreground,
            contrast_foreground(primary),
        ),
        secondary: pick(
            def_color(|d| d.secondary()),
            system_palette.secondary,
            base.secondary,
        ),
        secondary_foreground: pick(
            def_color(|d| d.secondary_foreground()),
            system_palette.secondary_foreground,
            base.secondary_foreground,
        ),
        muted: pick(def_color(|d| d.muted()), system_palette.muted, base.muted),
        muted_hover: pick(
            def_color(|d| d.muted_hover()),
            system_palette.muted_hover,
            base.muted_hover,
        ),
        muted_foreground: pick(
            def_color(|d| d.muted_foreground()),
            system_palette.muted_foreground,
            base.muted_foreground,
        ),
        accent,
        accent_foreground: pick(
            def_color(|d| d.accent_foreground()),
            system_palette.accent_foreground,
            contrast_foreground(accent),
        ),
        destructive,
        destructive_foreground: pick(
            def_color(|d| d.destructive_foreground()),
            None,
            contrast_foreground(destructive),
        ),
        success,
        success_foreground: pick(
            def_color(|d| d.success_foreground()),
            None,
            contrast_foreground(success),
        ),
        warning,
        warning_foreground: pick(
            def_color(|d| d.warning_foreground()),
            None,
            contrast_foreground(warning),
        ),
        info,
        info_foreground: pick(
            def_color(|d| d.info_foreground()),
            None,
            contrast_foreground(info),
        ),
        border: pick(
            def_color(|d| d.border()),
            system_palette.border,
            base.border,
        ),
        input: pick(def_color(|d| d.input()), system_palette.input, base.input),
        ring: pick(def_color(|d| d.ring()), system_palette.ring, base.ring),
        selection: pick(
            def_color(|d| d.selection()),
            system_palette.selection,
            base.selection,
        ),
        overlay: pick(
            def_color(|d| d.overlay()),
            system_palette.overlay,
            base.overlay,
        ),
        scrollbar_thumb: pick(
            def_color(|d| d.scrollbar_thumb()),
            system_palette.scrollbar_thumb,
            base.scrollbar_thumb,
        ),
    };

    let accessibility = system.accessibility;
    if accessibility.high_contrast {
        colors.border = mix(
            Oklch::from_hsla(colors.border),
            Oklch::from_hsla(colors.foreground),
            0.35,
        )
        .to_hsla();
    }

    // The platform's root font size scales every control metric:
    // a medium control's label is exactly the root font size.
    //
    // Fallback: 16 (the web default gpui also uses for rems).
    let root_font_size = system.root_font_size.unwrap_or(px(16.));
    let mut sizes = SizeTable::with_root_font_size(root_font_size);

    if let Some(control_height) = system.control_height {
        sizes.set_control_height(control_height);
    }

    if let Some(input_height) = system.input_height {
        sizes.set_input_height(input_height);
    }

    if let Some(switch_height) = system.switch_height {
        sizes.set_switch_metrics(
            switch_height,
            system.switch_width.unwrap_or(switch_height * 2.25),
            system.switch_knob.unwrap_or(switch_height * 0.85),
        );
    }

    if let Some(menu_item_height) = system.menu_item_height {
        sizes.set_menu_item_height(menu_item_height);
    }

    // A platform that states its titlebar height wins.
    let titlebar_height = system
        .titlebar_height
        .unwrap_or_else(|| sizes.medium.control_height.max(px(TITLEBAR_HEIGHT_MIN_PX)));

    let mut radius = Radius::default();

    if let Some(control) = preset
        .and_then(|def| def.control_radius)
        .map(px)
        .or(system.control_radius)
    {
        radius.control = control;
    }

    if let Some(overlay) = preset
        .and_then(|def| def.overlay_radius)
        .map(px)
        .or(system.overlay_radius)
    {
        radius.overlay = overlay;
    }

    if let Some(sm) = preset
        .and_then(|def| def.sm_radius)
        .map(px)
        .or(system.sm_radius)
    {
        radius.sm = sm;
    }

    ResolvedTheme {
        variant,
        ramps: Ramps {
            primary: derive_shades(primary, colors.background, variant == ThemeVariant::Dark),
            secondary: derive_shades(
                colors.secondary,
                colors.background,
                variant == ThemeVariant::Dark,
            ),
            destructive: derive_shades(
                destructive,
                colors.background,
                variant == ThemeVariant::Dark,
            ),
            success: derive_shades(success, colors.background, variant == ThemeVariant::Dark),
            warning: derive_shades(warning, colors.background, variant == ThemeVariant::Dark),
            info: derive_shades(info, colors.background, variant == ThemeVariant::Dark),
        },
        colors,
        radius,
        borders: Borders::for_platform(system.source, variant),
        spacing: Spacing {
            unit: system.source.spacing_unit(),
        },
        elevations: Elevations::for_platform(system.source, variant),
        motion: Motion::default(),
        scrollbar: Scrollbar {
            autohide: system.source.scrollbar_autohide(),
            ..Scrollbar::default()
        },
        titlebar_height,
        root_font_size,
        mono_font: mono_font(),
        sizes,
        accessibility,
    }
}

/// The platform's monospace family, for code surfaces.
fn mono_font() -> &'static str {
    if cfg!(target_os = "macos") {
        "Menlo"
    } else if cfg!(target_os = "windows") {
        "Consolas"
    } else {
        "monospace"
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::system::{AccessibilityPreferences, PartialPalette, SourceKind};
    use gpui::{Rgba, rgb};

    fn hsla(hex: u32) -> gpui::Hsla {
        gpui::Hsla::from(rgb(hex))
    }

    fn system(
        variant: ThemeVariant,
        palette: PartialPalette,
        accent: Option<gpui::Hsla>,
    ) -> SystemTheme {
        SystemTheme {
            variant,
            accent,
            palette,
            control_radius: None,
            overlay_radius: None,
            sm_radius: None,
            control_height: None,
            input_height: None,
            menu_item_height: None,
            switch_height: None,
            switch_width: None,
            switch_knob: None,
            titlebar_height: None,
            root_font_size: None,
            accessibility: AccessibilityPreferences::default(),
            source: SourceKind::Macos,
        }
    }

    #[test]
    fn empty_system_resolves_to_the_neutral_fallback() {
        for variant in [ThemeVariant::Light, ThemeVariant::Dark] {
            let resolved = resolve(
                &SystemTheme {
                    source: SourceKind::Fallback,
                    ..system(variant, PartialPalette::default(), None)
                },
                None,
                None,
            );
            let base = match variant {
                ThemeVariant::Light => ColorTokens::light(),
                ThemeVariant::Dark => ColorTokens::dark(),
            };
            assert_eq!(resolved.colors.background, base.background);
            assert_eq!(resolved.colors.accent, base.accent);
            assert_eq!(resolved.ramps.primary.base, base.primary);
            assert_eq!(resolved.ramps.secondary.base, base.secondary);
            assert_eq!(resolved.radius.sm, px(4.));
            assert_eq!(resolved.radius.control, px(6.));
            assert_eq!(resolved.root_font_size, px(16.));
            assert_eq!(resolved.sizes.medium.control_height, px(28.));
            assert_eq!(resolved.sizes.medium.input_height, px(30.));
            assert_eq!(resolved.sizes.medium.text_size, px(16.));
            assert_eq!(resolved.sizes.large.avatar_size, px(48.));
            assert_eq!(resolved.sizes.small.caption_size, px(13.6 * 0.85));
            assert_eq!(resolved.sizes.medium.caption_size, px(16.));
            assert_eq!(resolved.sizes.large.caption_size, px(16.));
            assert_eq!(resolved.sizes.medium.dense_padding_x, px(16. * 0.75));
            assert_eq!(resolved.sizes.medium.plate_inset, px(4.));
            assert_eq!(resolved.sizes.medium.strip_height, px(32.));
            assert_eq!(resolved.sizes.medium.icon_size, px(16.));
            assert_eq!(resolved.sizes.medium.menu_item_height, px(28. * 0.85));
            assert_eq!(resolved.sizes.medium.switch_height, px(21.));
            assert_eq!(resolved.sizes.medium.switch_width, px(21. * 2.25));
            assert_eq!(resolved.sizes.medium.switch_knob, px(21. * 0.85));
            assert_eq!(
                resolved.borders,
                Borders {
                    buttons: true,
                    fields: true,
                    overlays: true,
                    focus_ring: false,
                }
            );
            assert_eq!(resolved.spacing.unit, px(4.));
            assert_eq!(resolved.titlebar_height, px(34.));
        }
    }

    #[test]
    fn a_stated_titlebar_height_wins_over_the_control_scale() {
        let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None);
        stated.titlebar_height = Some(px(32.));
        assert_eq!(resolve(&stated, None, None).titlebar_height, px(32.));
    }

    #[test]
    fn a_stated_root_font_size_scales_the_size_table() {
        // macOS states 13pt; the medium control shrinks to native proportions.
        let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None);
        stated.root_font_size = Some(px(13.));
        let resolved = resolve(&stated, None, None);
        assert_eq!(resolved.root_font_size, px(13.));
        assert_eq!(resolved.sizes.medium.control_height, px(22.75));
        assert_eq!(resolved.sizes.medium.text_size, px(13.));
        assert_eq!(resolved.sizes.small.text_size, px(11.05));
    }

    #[test]
    fn scrollbar_autohide_follows_the_platform_source() {
        let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None);
        stated.source = SourceKind::Macos;
        assert!(resolve(&stated, None, None).scrollbar.autohide);

        stated.source = SourceKind::Gnome;
        assert!(resolve(&stated, None, None).scrollbar.autohide);

        stated.source = SourceKind::Omarchy;
        assert!(resolve(&stated, None, None).scrollbar.autohide);

        stated.source = SourceKind::Windows;
        assert!(!resolve(&stated, None, None).scrollbar.autohide);

        stated.source = SourceKind::Kde;
        assert!(!resolve(&stated, None, None).scrollbar.autohide);

        stated.source = SourceKind::Fallback;
        assert!(!resolve(&stated, None, None).scrollbar.autohide);
    }

    #[test]
    fn a_stated_input_height_overrides_the_derived_one_and_scales() {
        let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None);
        stated.input_height = Some(px(24.));
        let resolved = resolve(&stated, None, None);
        assert_eq!(resolved.sizes.medium.input_height, px(24.));
        let derived = SizeTable::with_root_font_size(px(16.));
        let scale = px(24.) / derived.medium.input_height;
        let expected_small = (derived.small.input_height * scale).floor();
        assert_eq!(resolved.sizes.small.input_height, expected_small);
    }

    #[test]
    fn a_stated_control_height_overrides_the_medium_class_and_scales() {
        let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None);
        stated.control_height = Some(px(32.));
        let resolved = resolve(&stated, None, None);
        assert_eq!(resolved.sizes.medium.control_height, px(32.));

        let derived = SizeTable::with_root_font_size(px(16.));
        let scale = px(32.) / derived.medium.control_height;
        let expected_small = (derived.small.control_height * scale).floor();
        let expected_large = (derived.large.control_height * scale).floor();
        assert_eq!(resolved.sizes.small.control_height, expected_small);
        assert_eq!(resolved.sizes.large.control_height, expected_large);
    }

    #[test]
    fn stated_switch_and_menu_metrics_override_the_derived_ones() {
        let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None);
        stated.switch_height = Some(px(20.));
        stated.switch_width = Some(px(40.));
        stated.switch_knob = Some(px(12.));
        stated.menu_item_height = Some(px(33.));
        let resolved = resolve(&stated, None, None);

        assert_eq!(resolved.sizes.medium.switch_height, px(20.));
        assert_eq!(resolved.sizes.medium.switch_width, px(40.));
        assert_eq!(resolved.sizes.medium.switch_knob, px(12.));
        assert_eq!(resolved.sizes.medium.menu_item_height, px(33.));
    }

    #[test]
    fn the_radius_ladder_follows_stated_values_with_preset_priority() {
        let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None);
        stated.control_radius = Some(px(9.));
        stated.overlay_radius = Some(px(15.));
        stated.sm_radius = Some(px(6.));
        let resolved = resolve(&stated, None, None);
        assert_eq!(resolved.radius.control, px(9.));
        assert_eq!(resolved.radius.overlay, px(15.));
        assert_eq!(resolved.radius.sm, px(6.));

        let def = ThemeDefinition::parse_toml("overlay_radius = 12.0\n").unwrap();
        let overridden = resolve(&stated, Some(&def), None);
        assert_eq!(overridden.radius.overlay, px(12.));
        assert_eq!(overridden.radius.sm, px(6.));
    }

    #[test]
    fn borders_and_spacing_follow_the_platform_source() {
        let chrome = |source| {
            let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None);
            stated.source = source;
            let resolved = resolve(&stated, None, None);
            (resolved.borders, resolved.spacing.unit)
        };

        let (borders, unit) = chrome(SourceKind::Windows);
        assert!(borders.buttons && borders.fields && borders.overlays && !borders.focus_ring);
        assert_eq!(unit, px(4.));

        let (borders, unit) = chrome(SourceKind::Kde);
        assert!(borders.buttons && borders.fields && borders.overlays && !borders.focus_ring);
        assert_eq!(unit, px(4.));

        let (borders, unit) = chrome(SourceKind::Macos);
        assert!(!borders.buttons && borders.fields && !borders.overlays && borders.focus_ring);
        assert_eq!(unit, px(4.));

        for source in [SourceKind::Gnome, SourceKind::Omarchy] {
            let (borders, unit) = chrome(source);
            assert!(!borders.buttons && !borders.fields && !borders.overlays && borders.focus_ring);
            assert_eq!(unit, px(6.));
        }

        let (borders, unit) = chrome(SourceKind::Fallback);
        assert!(borders.buttons && borders.fields && borders.overlays && !borders.focus_ring);
        assert_eq!(unit, px(4.));
    }

    #[test]
    fn dark_mode_separates_overlays_by_border() {
        for source in [SourceKind::Macos, SourceKind::Gnome, SourceKind::Omarchy] {
            let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None);
            stated.source = source;
            let resolved = resolve(&stated, None, None);
            assert!(
                resolved.borders.overlays,
                "{source:?} frames floating layers in dark"
            );
            assert!(resolved.elevations.popover.shadows().is_empty());
            assert!(resolved.elevations.dialog.shadows().is_empty());
        }
    }

    #[test]
    fn overlay_is_translucent_and_overridable() {
        let light = resolve(
            &system(ThemeVariant::Light, PartialPalette::default(), None),
            None,
            None,
        );
        let dark = resolve(
            &system(ThemeVariant::Dark, PartialPalette::default(), None),
            None,
            None,
        );

        // Both scrims are translucent black; dark is denser for contrast.
        assert!(light.colors.overlay.a > 0.0 && light.colors.overlay.a < 0.5);
        assert!(dark.colors.overlay.a > light.colors.overlay.a);

        let def = ThemeDefinition::parse_toml("overlay = \"#000000\"").unwrap();
        let overridden = resolve(
            &system(ThemeVariant::Light, PartialPalette::default(), None),
            Some(&def),
            None,
        );
        assert_eq!(overridden.colors.overlay, hsla(0x000000));
        assert_eq!(overridden.colors.overlay.a, 1.0);
    }

    #[test]
    fn elevations_and_motion_resolve_with_defaults() {
        let resolved = resolve(
            &system(ThemeVariant::Light, PartialPalette::default(), None),
            None,
            None,
        );

        // The popover shadow is softer and tighter than the dialog's.
        assert!(
            resolved.elevations.popover.layers[0].blur_radius
                < resolved.elevations.dialog.layers[0].blur_radius
        );
        assert!(resolved.motion.overlay > std::time::Duration::ZERO);
        let shadows = resolved.elevations.popover.shadows();
        assert_eq!(shadows.len(), 2);
        assert!(!shadows[0].inset);
    }

    #[test]
    fn elevations_follow_the_platform_in_light_mode_and_share_one_dark_stack() {
        let popover = |source| {
            let mut stated = system(ThemeVariant::Light, PartialPalette::default(), None);
            stated.source = source;
            resolve(&stated, None, None).elevations.popover
        };

        // macOS paints a soft layered stack; Linux keeps a compact single one.
        assert_eq!(popover(SourceKind::Macos).shadows().len(), 2);
        assert_eq!(popover(SourceKind::Gnome).shadows().len(), 1);
        assert!(
            popover(SourceKind::Macos).layers[0].color.a
                < popover(SourceKind::Gnome).layers[0].color.a
        );

        // Dark mode is one shared stack, however the adapter detected.
        let dark = |source| {
            let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None);
            stated.source = source;
            resolve(&stated, None, None).elevations
        };
        assert_eq!(dark(SourceKind::Macos), dark(SourceKind::Windows));
        assert_eq!(dark(SourceKind::Macos), dark(SourceKind::Fallback));
    }

    #[test]
    fn system_colors_override_the_base_but_leave_the_rest_intact() {
        let palette = PartialPalette {
            background: Some(hsla(0x112233)),
            border: Some(hsla(0x445566)),
            ..PartialPalette::default()
        };
        let resolved = resolve(
            &system(ThemeVariant::Dark, palette, Some(hsla(0xff8800))),
            None,
            None,
        );
        assert_eq!(resolved.colors.background, hsla(0x112233));
        assert_eq!(resolved.colors.border, hsla(0x445566));
        assert_eq!(resolved.colors.accent, hsla(0xff8800));
        assert_eq!(resolved.colors.foreground, ColorTokens::dark().foreground);
    }

    #[test]
    fn a_system_stated_accent_foreground_beats_the_derivation() {
        // What macOS reports via alternateSelectedControlTextColor: white,
        // even where the derivation would pick black (light accent).
        let palette = PartialPalette {
            accent_foreground: Some(hsla(0xffffff)),
            ..PartialPalette::default()
        };
        let resolved = resolve(
            &system(ThemeVariant::Light, palette, Some(hsla(0xffd60a))),
            None,
            None,
        );
        assert_eq!(resolved.colors.accent, hsla(0xffd60a));
        assert_eq!(resolved.colors.accent_foreground, hsla(0xffffff));
        // Without the stated foreground the derivation applies.
        let derived = resolve(
            &system(
                ThemeVariant::Light,
                PartialPalette::default(),
                Some(hsla(0xffd60a)),
            ),
            None,
            None,
        );
        assert_eq!(derived.colors.accent_foreground, hsla(0x000000));
    }

    #[test]
    fn preset_beats_system_and_the_mode_override_beats_everything() {
        let def = ThemeDefinition::parse_toml(
            "mode = \"dark\"\nbackground = \"#1a1b26\"\naccent = \"#7aa2f7\"\ncontrol_radius = 12.0\n",
        )
        .unwrap();
        let palette = PartialPalette {
            background: Some(hsla(0xffffff)),
            ..PartialPalette::default()
        };
        let resolved = resolve(
            &system(ThemeVariant::Light, palette, None),
            Some(&def),
            None,
        );
        assert_eq!(resolved.variant, ThemeVariant::Dark);
        // Compare in RGB space: Hsla round-trips are lossy at low saturation.
        let bg = Rgba::from(resolved.colors.background);
        assert!((bg.r - 0x1a as f32 / 255.0).abs() < 0.001);
        assert!((bg.b - 0x26 as f32 / 255.0).abs() < 0.001);
        let accent = Rgba::from(resolved.colors.accent);
        assert!((accent.r - 0x7a as f32 / 255.0).abs() < 0.001);
        // And the metric override beats the radius default.
        assert_eq!(resolved.radius.control, px(12.));

        let forced = resolve(
            &system(ThemeVariant::Light, palette, None),
            Some(&def),
            Some(ThemeVariant::Light),
        );
        assert_eq!(forced.variant, ThemeVariant::Light);
        // The override flips the variant (and with it the base roles), but
        // the preset's explicit background still wins over the base.
        let forced_bg = Rgba::from(forced.colors.background);
        assert!((forced_bg.r - 0x1a as f32 / 255.0).abs() < 0.001);
    }

    #[test]
    fn an_accent_only_override_derives_foregrounds_and_ramps() {
        let def = ThemeDefinition::parse_toml("mode = \"dark\"\naccent = \"#7aa2f7\"\n").unwrap();
        let resolved = resolve(
            &system(ThemeVariant::Dark, PartialPalette::default(), None),
            Some(&def),
            None,
        );
        // The definition sets accent only; primary still falls back to the
        // dark base. accent_foreground/primary_foreground are derived per
        // color, and the ramp tracks its own base.
        let accent = Rgba::from(resolved.colors.accent);
        assert!((accent.r - 0x7a as f32 / 255.0).abs() < 0.001);
        assert_eq!(
            resolved.colors.primary,
            ColorTokens::dark().primary,
            "primary should stay at the base until a definition names it"
        );
        assert_eq!(resolved.ramps.primary.base, resolved.colors.primary);
        assert_eq!(resolved.ramps.destructive.base, resolved.colors.destructive);
        assert_ne!(resolved.ramps.primary.hover, resolved.ramps.primary.base);
        assert_ne!(resolved.ramps.primary.subtle, resolved.ramps.primary.base);
    }

    #[test]
    fn system_accent_becomes_primary() {
        let resolved = resolve(
            &system(
                ThemeVariant::Dark,
                PartialPalette::default(),
                Some(hsla(0x7aa2f7)),
            ),
            None,
            None,
        );
        let primary = Rgba::from(resolved.colors.primary);
        assert!((primary.r - 0x7a as f32 / 255.0).abs() < 0.001);
        assert_eq!(resolved.ramps.primary.base, resolved.colors.primary);
        assert_eq!(
            resolved.colors.primary_foreground,
            resolved.colors.accent_foreground
        );
    }

    #[test]
    fn high_contrast_sharpens_the_border_toward_the_foreground() {
        let mut a11y = AccessibilityPreferences::default();
        let plain = resolve(
            &system(ThemeVariant::Dark, PartialPalette::default(), None),
            None,
            None,
        );
        a11y.high_contrast = true;
        let contrasted = resolve(
            &SystemTheme {
                accessibility: a11y,
                ..system(ThemeVariant::Dark, PartialPalette::default(), None)
            },
            None,
            None,
        );
        let plain_border = Oklch::from_hsla(plain.colors.border);
        let contrasted_border = Oklch::from_hsla(contrasted.colors.border);
        let foreground_l = Oklch::from_hsla(plain.colors.foreground).l;
        assert!((contrasted_border.l - foreground_l).abs() < (plain_border.l - foreground_l).abs());
    }

    #[test]
    fn every_resolved_role_is_distinct_enough_to_paint_with() {
        for variant in [ThemeVariant::Light, ThemeVariant::Dark] {
            let resolved = resolve(
                &system(variant, PartialPalette::default(), None),
                None,
                None,
            );
            assert_ne!(resolved.colors.background, resolved.colors.foreground);
            assert_ne!(resolved.colors.border, resolved.colors.background);
            assert_ne!(resolved.colors.muted_foreground, resolved.colors.foreground);
            assert!(resolved.colors.ring != resolved.colors.background);
        }
    }

    #[test]
    fn info_stays_calm_when_the_accent_warms_up() {
        // The whole point of the info role: a warm platform accent (GNOME
        // red, Omarchy red themes) must not make Info toasts read as Danger.
        let red_accent = hsla(0xdc2626);
        let resolved = resolve(
            &system(
                ThemeVariant::Dark,
                PartialPalette::default(),
                Some(red_accent),
            ),
            None,
            None,
        );
        assert_eq!(resolved.ramps.primary.base, red_accent);
        assert_ne!(resolved.colors.info, resolved.colors.destructive);
        assert_ne!(resolved.ramps.info.base, resolved.ramps.destructive.base);
    }

    #[test]
    fn info_follows_the_severity_overlay_chain() {
        let palette = PartialPalette {
            info: Some(hsla(0x155e75)),
            ..PartialPalette::default()
        };
        let system_stated = resolve(&system(ThemeVariant::Dark, palette, None), None, None);
        assert_eq!(system_stated.colors.info, hsla(0x155e75));
        assert_eq!(system_stated.ramps.info.base, hsla(0x155e75));

        let def = ThemeDefinition::parse_toml("info = \"#0ea5e9\"\n").unwrap();
        let preset_stated = resolve(&system(ThemeVariant::Dark, palette, None), Some(&def), None);
        assert_eq!(preset_stated.colors.info, hsla(0x0ea5e9));
    }
}