pub(crate) mod geometry;
pub mod layout;
pub use geometry::{GeometryIntent, PanelGeometry};
mod radius;
use crate::PanelStyle;
pub use radius::CornerRadii;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashSet};

/// The effects protocol accepts 32 regions; reserve one for the overflow group.
pub const MAX_GROUPS: usize = 31;

fn yes() -> bool {
    true
}
fn priority() -> u8 {
    50
}
fn spacing() -> f32 {
    1.0
}
fn padding() -> [u16; 2] {
    [2, 3]
}

#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
#[serde(transparent)]
pub struct PanelId(pub String);

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Edge {
    #[default]
    Top,
    Bottom,
}

impl Edge {
    pub fn key(self) -> &'static str {
        match self {
            Self::Top => "top",
            Self::Bottom => "bottom",
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
#[serde(transparent)]
pub struct GroupId(pub String);

#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
#[serde(transparent)]
pub struct ItemId(pub String);

#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum Representation {
    Wide,
    Compact,
    Icon,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum OverflowPolicy {
    #[default]
    Auto,
    Never,
    Always,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum WorkspaceStyle {
    Numbers,
    #[default]
    Dots,
    Tabs,
    WindowStacks,
    AppIcons,
}

impl WorkspaceStyle {
    pub const ALL: [Self; 5] = [
        Self::Numbers,
        Self::Dots,
        Self::Tabs,
        Self::WindowStacks,
        Self::AppIcons,
    ];

    pub fn key(self) -> &'static str {
        match self {
            Self::Numbers => "numbers",
            Self::Dots => "dots",
            Self::Tabs => "tabs",
            Self::WindowStacks => "window-stacks",
            Self::AppIcons => "app-icons",
        }
    }

    pub fn label(self) -> &'static str {
        match self {
            Self::Numbers => "Numbers",
            Self::Dots => "Dots",
            Self::Tabs => "Tabs",
            Self::WindowStacks => "Window stacks",
            Self::AppIcons => "App icons",
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
#[serde(tag = "kind", rename_all = "kebab-case")]
pub enum ItemKind {
    Overview,
    Workspaces {
        #[serde(default)]
        style: WorkspaceStyle,
    },
    FocusedWindow,
    Media,
    Activities,
    QuickSettings,
    NightLight,
    Network,
    Audio,
    Recording,
    Notifications,
    Battery {
        #[serde(default = "yes")]
        percentage: bool,
    },
    Clock,
    DisplayMode,
    Overflow,
}

impl ItemKind {
    /// Smallest useful allocation before a flexible control moves into overflow.
    pub fn minimum_width(self) -> Option<f32> {
        match self {
            Self::FocusedWindow => Some(48.),
            Self::Workspaces { .. } => Some(24.),
            Self::Media => Some(112.),
            _ => None,
        }
    }

    pub fn label(self) -> &'static str {
        match self {
            Self::Overview => "Overview",
            Self::Workspaces { .. } => "Workspaces",
            Self::FocusedWindow => "Focused window",
            Self::Media => "Media",
            Self::Activities => "Activities",
            Self::QuickSettings => "Quick Settings",
            Self::NightLight => "Night light",
            Self::Network => "Network",
            Self::Audio => "Audio",
            Self::Recording => "Recording",
            Self::Notifications => "Notifications",
            Self::Battery { .. } => "Battery",
            Self::Clock => "Clock",
            Self::DisplayMode => "Display mode",
            Self::Overflow => "Overflow",
        }
    }
    pub fn representations(self) -> &'static [Representation] {
        use Representation::*;
        match self {
            Self::Activities | Self::Media | Self::Clock => &[Wide, Compact, Icon],
            Self::Battery { percentage: true } => &[Wide, Icon],
            Self::Workspaces { .. } | Self::FocusedWindow => &[Wide],
            _ => &[Icon],
        }
    }
}

#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct Item {
    pub id: ItemId,
    #[serde(flatten)]
    pub kind: ItemKind,
    // Preserve the existing gap between status controls and the clock/display.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub gap_before: Option<f32>,
    #[serde(default)]
    pub overflow: OverflowPolicy,
    #[serde(default = "priority")]
    pub priority: u8,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub representation: Option<Representation>,
    #[serde(default = "yes")]
    pub visible: bool,
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    pub metadata: BTreeMap<String, serde_json::Value>,
}

impl<'de> Deserialize<'de> for Item {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let fields = value
            .as_object()
            .ok_or_else(|| serde::de::Error::custom("expected a panel item"))?;
        const OPTIONS: &[&str] = &[
            "id",
            "kind",
            "gap_before",
            "overflow",
            "priority",
            "representation",
            "visible",
            "metadata",
            "style",
            "percentage",
        ];
        for key in fields.keys() {
            if !OPTIONS.contains(&key.as_str()) {
                return Err(serde::de::Error::unknown_field(key, OPTIONS));
            }
        }
        if fields.contains_key("style")
            && fields.get("kind").and_then(serde_json::Value::as_str) != Some("workspaces")
        {
            return Err(serde::de::Error::custom(
                "style is only supported by Workspaces items",
            ));
        }
        if fields.contains_key("percentage")
            && fields.get("kind").and_then(serde_json::Value::as_str) != Some("battery")
        {
            return Err(serde::de::Error::custom(
                "percentage is only supported by Battery items",
            ));
        }
        #[derive(Deserialize)]
        struct Fields {
            id: ItemId,
            #[serde(flatten)]
            kind: ItemKind,
            #[serde(default)]
            gap_before: Option<f32>,
            #[serde(default)]
            overflow: OverflowPolicy,
            #[serde(default = "priority")]
            priority: u8,
            #[serde(default)]
            representation: Option<Representation>,
            #[serde(default = "yes")]
            visible: bool,
            #[serde(default)]
            metadata: BTreeMap<String, serde_json::Value>,
        }
        let item: Fields = serde_json::from_value(value).map_err(serde::de::Error::custom)?;
        Ok(Self {
            id: item.id,
            kind: item.kind,
            gap_before: item.gap_before,
            overflow: item.overflow,
            priority: item.priority,
            representation: item.representation,
            visible: item.visible,
            metadata: item.metadata,
        })
    }
}

impl Item {
    /// Start at the configured preference and retain supported smaller forms.
    pub fn representations(&self) -> Vec<Representation> {
        let supported = self.kind.representations();
        let preferred = self.representation.unwrap_or(supported[0]);
        let alternatives: Vec<_> = supported
            .iter()
            .copied()
            .filter(|representation| *representation as u8 >= preferred as u8)
            .collect();
        if alternatives.is_empty() {
            vec![supported[0]]
        } else {
            alternatives
        }
    }
    pub fn new(id: &str, kind: ItemKind) -> Self {
        Self {
            id: ItemId(id.into()),
            kind,
            gap_before: None,
            representation: None,
            visible: true,
            metadata: BTreeMap::new(),
            overflow: if matches!(
                kind,
                ItemKind::Overview | ItemKind::Workspaces { .. } | ItemKind::FocusedWindow
            ) {
                OverflowPolicy::Never
            } else {
                OverflowPolicy::Auto
            },
            priority: if matches!(kind, ItemKind::Overview | ItemKind::Workspaces { .. }) {
                100
            } else if kind == ItemKind::Activities {
                20
            } else {
                50
            },
        }
    }

    pub fn available(&self, availability: Availability) -> bool {
        if !self.visible {
            return false;
        }
        match self.kind {
            ItemKind::Activities => availability.activities,
            ItemKind::Media => availability.media,
            ItemKind::Network => availability.network,
            ItemKind::Audio => availability.audio,
            ItemKind::Notifications => availability.notifications,
            ItemKind::Battery { .. } => availability.battery,
            ItemKind::DisplayMode => availability.external_display,
            _ => true,
        }
    }
}

#[derive(Clone, Copy, Debug, Default)]
pub struct Availability {
    pub media: bool,
    pub activities: bool,
    pub network: bool,
    pub audio: bool,
    pub notifications: bool,
    pub battery: bool,
    pub external_display: bool,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum PanelSurface {
    None,
    #[default]
    Solid,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum GroupSurface {
    #[default]
    None,
    Inset,
    Island,
}

impl GroupSurface {
    pub fn key(self) -> &'static str {
        match self {
            Self::None => "none",
            Self::Inset => "inset",
            Self::Island => "island",
        }
    }
}

#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Group {
    pub id: GroupId,
    #[serde(default)]
    pub items: Vec<Item>,
    #[serde(default = "spacing")]
    pub spacing: f32,
    #[serde(default = "padding")]
    pub padding: [u16; 2],
    #[serde(default = "crate::default_island_padding")]
    pub island_padding: f32,
}

impl Group {
    fn new(id: &str, items: Vec<Item>, padding: [u16; 2], island_padding: f32) -> Self {
        Self {
            id: GroupId(id.into()),
            items,
            spacing: 1.0,
            padding,
            island_padding,
        }
    }
}

#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct Zone {
    pub groups: Vec<Group>,
    pub spacing: f32,
}

#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Panel {
    pub id: PanelId,
    #[serde(default)]
    pub edge: Edge,
    #[serde(default)]
    pub geometry: GeometryIntent,
    #[serde(default)]
    pub style: PanelStyle,
    #[serde(default, skip_serializing_if = "default_morph")]
    pub morph: crate::morph::Profile,
    #[serde(default)]
    pub border: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub background_opacity: Option<f32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub corner_radius: Option<CornerRadii>,
    #[serde(default)]
    pub start: Zone,
    #[serde(default)]
    pub center: Zone,
    #[serde(default)]
    pub end: Zone,
}

impl Default for Zone {
    fn default() -> Self {
        Self {
            groups: Vec::new(),
            spacing: 8.0,
        }
    }
}

fn default_morph(profile: &crate::morph::Profile) -> bool {
    *profile == crate::morph::Profile::default()
}

pub fn validate(panels: &[Panel]) -> Result<(), String> {
    if panels.len() != 1 {
        return Err("configure exactly one panel; multiple panels are not supported yet".into());
    }
    let valid_id = |value: &str| {
        !value.is_empty()
            && value.len() <= 128
            && value
                .bytes()
                .all(|byte| byte.is_ascii_alphanumeric() || b"-_.:@".contains(&byte))
            && !value.starts_with('_')
    };
    let mut panel_ids = HashSet::new();
    for panel in panels {
        if !PanelStyle::AVAILABLE.contains(&panel.style) {
            return Err(format!(
                "panel style {} is not available yet",
                panel.style.key()
            ));
        }
        panel.geometry.validate()?;
        panel.morph.validate()?;
        if panel.group_count() > MAX_GROUPS {
            return Err(format!(
                "a panel supports at most {MAX_GROUPS} groups, reserving one region for overflow"
            ));
        }
        if let Some(opacity) = panel.background_opacity
            && (!opacity.is_finite() || !(0.0..=1.0).contains(&opacity))
        {
            return Err("panel background opacity must be between 0 and 1".into());
        }
        if let Some(radius) = panel.corner_radius {
            radius.validate()?;
        }
        if !valid_id(&panel.id.0) || !panel_ids.insert(&panel.id.0) {
            return Err(format!("invalid or duplicate panel ID {:?}", panel.id.0));
        }
        let mut group_ids = HashSet::new();
        let mut item_ids = HashSet::new();
        for zone in [&panel.start, &panel.center, &panel.end] {
            if !zone.spacing.is_finite() || !(0.0..=64.0).contains(&zone.spacing) {
                return Err("panel zone spacing must be between 0 and 64".into());
            }
            for group in &zone.groups {
                if !valid_id(&group.id.0) || !group_ids.insert(&group.id.0) {
                    return Err(format!("invalid or duplicate group ID {:?}", group.id.0));
                }
                if !group.spacing.is_finite()
                    || !(0.0..=64.0).contains(&group.spacing)
                    || !group.island_padding.is_finite()
                    || !(0.0..=32.0).contains(&group.island_padding)
                    || group.padding.iter().any(|value| *value > 32)
                {
                    return Err("invalid panel group spacing or padding".into());
                }
                for item in &group.items {
                    if !valid_id(&item.id.0) || !item_ids.insert(&item.id.0) {
                        return Err(format!("invalid or duplicate item ID {:?}", item.id.0));
                    }
                    if item.priority > 100
                        || item
                            .gap_before
                            .is_some_and(|gap| !gap.is_finite() || !(0.0..=64.0).contains(&gap))
                    {
                        return Err("panel item priority must be 0..100 and gaps 0..64".into());
                    }
                    if item.kind == ItemKind::Overflow {
                        return Err(
                            "overflow is supplied by the panel; it cannot be configured as an item"
                                .into(),
                        );
                    }
                }
            }
        }
    }
    Ok(())
}

impl Default for Panel {
    fn default() -> Self {
        Self::from_preset(PanelStyle::Flat)
    }
}

impl Panel {
    pub fn preset(&self) -> Option<PanelStyle> {
        Some(self.style)
    }

    pub fn apply_preset(&mut self, style: PanelStyle) {
        self.style = style;
    }

    pub fn surface(&self) -> PanelSurface {
        if matches!(self.style, PanelStyle::Flat | PanelStyle::Frame) {
            PanelSurface::Solid
        } else {
            PanelSurface::None
        }
    }

    pub fn group_surface(&self) -> GroupSurface {
        if self.surface() == PanelSurface::Solid {
            GroupSurface::None
        } else {
            GroupSurface::Island
        }
    }

    pub fn zone_spacing(&self, zone: &Zone) -> f32 {
        if self.style.connected() {
            0.
        } else {
            zone.spacing
        }
    }

    pub fn shape_parameters(&self) -> crate::scene::Parameters {
        crate::scene::Parameters {
            style: self.style,
            attached: self.style == PanelStyle::Morph && self.morph.attached,
            fillet: if self.style == PanelStyle::Morph {
                12.
            } else {
                crate::scene::Parameters::default().fillet
            },
            edge: self.edge,
            height: self.resolved_geometry().height.into(),
            radius: self.corner_radius.map(|r| crate::shape::AnchoredRadii(r.0)),
            ..Default::default()
        }
    }

    pub fn resolved_geometry(&self) -> PanelGeometry {
        let mut geometry = self.geometry.resolve(self.style);
        if self.style == PanelStyle::Morph && self.morph.attached {
            geometry.edge_margin = 0;
        }
        geometry
    }

    pub fn exclusive_zone(&self, hidden: bool) -> i32 {
        if hidden {
            0
        } else {
            let geometry = self.resolved_geometry();
            (geometry.height.round() as i32).saturating_add(geometry.window_clearance)
        }
    }

    pub fn group_count(&self) -> usize {
        [&self.start, &self.center, &self.end]
            .into_iter()
            .map(|zone| zone.groups.len())
            .sum()
    }

    /// Appearance changes do not replace item ownership or measured allocation.
    pub fn same_composition(&self, other: &Self) -> bool {
        let same_zone = |left: &Zone, right: &Zone| {
            left.spacing == right.spacing
                && left.groups.len() == right.groups.len()
                && left.groups.iter().zip(&right.groups).all(|(left, right)| {
                    left.id == right.id
                        && left.items == right.items
                        && left.spacing == right.spacing
                        && left.padding == right.padding
                        && left.island_padding == right.island_padding
                        && (self.group_surface() == GroupSurface::Island)
                            == (other.group_surface() == GroupSurface::Island)
                })
        };
        self.id == other.id
            && self.edge == other.edge
            && self.style == other.style
            && self.morph == other.morph
            && same_zone(&self.start, &other.start)
            && same_zone(&self.center, &other.center)
            && same_zone(&self.end, &other.end)
    }

    pub fn resolved_radius(&self, shell_radius: f32) -> CornerRadii {
        self.corner_radius
            .unwrap_or_else(|| CornerRadii::uniform(shell_radius))
    }

    /// The overflow trigger is generated, never persisted as a configured item.
    pub fn overflow_group(&self) -> Group {
        Group {
            id: GroupId("_overflow".into()),
            items: vec![Item {
                id: ItemId("_overflow".into()),
                kind: ItemKind::Overflow,
                gap_before: None,
                representation: None,
                visible: true,
                metadata: BTreeMap::new(),
                overflow: OverflowPolicy::Never,
                priority: 100,
            }],
            spacing: 0.0,
            padding: [2, 3],
            island_padding: self
                .end
                .groups
                .first()
                .map_or(crate::default_island_padding(), |group| {
                    group.island_padding
                }),
        }
    }

    pub fn item(&self, id: &ItemId) -> Option<&Item> {
        [&self.start, &self.center, &self.end]
            .into_iter()
            .flat_map(|zone| &zone.groups)
            .flat_map(|group| &group.items)
            .find(|item| &item.id == id)
    }

    /// Build a stable initial composition; presets are an editor convenience.
    pub fn from_preset(preset: PanelStyle) -> Self {
        use ItemKind::*;

        let item = Item::new;
        let padding = crate::default_island_padding();
        let overview = item("overview", Overview);
        let workspaces = item(
            "workspaces",
            Workspaces {
                style: WorkspaceStyle::default(),
            },
        );
        let title = item("focused-window", FocusedWindow);
        let controls = vec![
            item("media", Media),
            item("quick-settings", QuickSettings),
            item("night-light", NightLight),
            item("network", Network),
            item("audio", Audio),
            item("recording", Recording),
            item("notifications", Notifications),
            item("battery", Battery { percentage: true }),
        ];
        let clock = item("clock", Clock);
        let display = item("display-mode", DisplayMode);

        let (start, center, end) = match preset {
            PanelStyle::Flat => (
                vec![
                    Group::new("overview", vec![overview], [0, 0], padding),
                    Group::new("workspaces", vec![workspaces], [2, 3], padding),
                ],
                Group::new("title", vec![title], [0, 0], padding),
                vec![
                    Group::new("status", controls, [2, 3], padding),
                    Group::new("time", vec![clock], [2, 3], padding),
                    Group::new("display", vec![display], [0, 0], padding),
                ],
            ),
            _ => {
                let mut controls = controls;
                controls.extend([clock, display]);
                (
                    vec![Group::new(
                        "navigation",
                        vec![overview, workspaces],
                        [2, 3],
                        padding,
                    )],
                    Group::new("title", vec![title], [0, 0], padding),
                    vec![Group::new("status", controls, [2, 3], padding)],
                )
            }
        };

        Self {
            id: PanelId("main".into()),
            edge: Edge::Top,
            geometry: GeometryIntent::default(),
            style: preset,
            morph: Default::default(),
            border: false,
            background_opacity: Option::None,
            corner_radius: Option::None,
            start: Zone {
                groups: start,
                spacing: if preset == PanelStyle::Floating {
                    8.0
                } else {
                    3.0
                },
            },
            center: Zone {
                groups: vec![center],
                spacing: 8.0,
            },
            end: Zone {
                groups: end,
                spacing: 8.0,
            },
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn fullscreen_releases_the_entire_reservation_without_discarding_pins() {
        let mut panel = Panel::from_preset(PanelStyle::Floating);
        panel.geometry.height = Some(36.);
        panel.geometry.window_clearance = Some(4);
        assert_eq!(panel.exclusive_zone(false), 40);
        assert_eq!(panel.exclusive_zone(true), 0);
        assert_eq!(panel.geometry.window_clearance, Some(4));
    }

    fn items(panel: &Panel) -> Vec<&Item> {
        [&panel.start, &panel.center, &panel.end]
            .into_iter()
            .flat_map(|zone| &zone.groups)
            .flat_map(|group| &group.items)
            .collect()
    }

    #[test]
    fn group_capacity_reserves_overflow_even_for_empty_groups() {
        for background in [PanelStyle::Flat, PanelStyle::Floating] {
            let mut panel = Panel::from_preset(background);
            panel.start.groups.clear();
            panel.center.groups.clear();
            panel.end.groups = (0..MAX_GROUPS)
                .map(|i| Group::new(&format!("group-{i}"), Vec::new(), [2, 3], 4.))
                .collect();
            assert_eq!(panel.group_count(), MAX_GROUPS);
            validate(std::slice::from_ref(&panel)).unwrap();
            panel
                .start
                .groups
                .push(Group::new("one-too-many", Vec::new(), [2, 3], 4.));
            assert!(validate(&[panel]).unwrap_err().contains("31 groups"));
        }
    }

    #[test]
    fn defaults_preserve_order_and_ids_across_background_changes() {
        let continuous = Panel::default();
        let islands = Panel::from_preset(PanelStyle::Floating);
        let expected = [
            "overview",
            "workspaces",
            "focused-window",
            "media",
            "quick-settings",
            "night-light",
            "network",
            "audio",
            "recording",
            "notifications",
            "battery",
            "clock",
            "display-mode",
        ];
        for panel in [&continuous, &islands] {
            let ids: Vec<_> = items(panel).iter().map(|item| item.id.0.as_str()).collect();
            assert_eq!(ids, expected);
            assert_eq!(Panel::from_preset(panel.preset().unwrap()), *panel);
        }
        assert_eq!(continuous.start.groups.len(), 2);
        assert_eq!(continuous.end.groups.len(), 3);
        assert_eq!(islands.start.groups.len(), 1);
        assert_eq!(islands.end.groups.len(), 1);
        assert!(!islands.border && !continuous.border);
    }

    #[test]
    fn availability_filters_without_removing_or_reidentifying_instances() {
        let panel = Panel::default();
        let all = items(&panel);
        let visible = |availability| {
            all.iter()
                .filter(|item| item.available(availability))
                .map(|item| item.id.0.as_str())
                .collect::<Vec<_>>()
        };
        assert_eq!(
            visible(Availability::default()),
            [
                "overview",
                "workspaces",
                "focused-window",
                "quick-settings",
                "night-light",
                "recording",
                "clock"
            ]
        );
        assert_eq!(
            visible(Availability {
                activities: true,
                media: true,
                network: true,
                audio: true,
                notifications: true,
                battery: true,
                external_display: true
            }),
            all.iter()
                .map(|item| item.id.0.as_str())
                .collect::<Vec<_>>()
        );
        assert_eq!(items(&panel).len(), 13);
    }

    #[test]
    fn settings_map_to_instances_and_group_presentation() {
        let mut panel = Panel::from_preset(PanelStyle::Floating);
        panel.center.groups[0].items[0].visible = false;
        let battery = panel.end.groups[0]
            .items
            .iter_mut()
            .find(|item| item.id.0 == "battery")
            .unwrap();
        battery.kind = ItemKind::Battery { percentage: false };
        for group in [&mut panel.start, &mut panel.center, &mut panel.end]
            .into_iter()
            .flat_map(|zone| &mut zone.groups)
        {
            group.island_padding = 13.;
        }
        assert_eq!(
            panel.center.groups[0].items[0].kind,
            ItemKind::FocusedWindow
        );
        assert!(!panel.center.groups[0].items[0].visible);
        let all = items(&panel);
        assert_eq!(
            all.iter().find(|item| item.id.0 == "battery").unwrap().kind,
            ItemKind::Battery { percentage: false }
        );
        for zone in [&panel.start, &panel.center, &panel.end] {
            for group in &zone.groups {
                assert_eq!(group.island_padding, 13.0);
            }
        }
        assert_eq!(
            all.iter()
                .find(|item| item.id.0 == "clock")
                .unwrap()
                .gap_before,
            None
        );
    }

    #[test]
    fn two_clock_instances_have_distinct_identity() {
        let first = Item::new("main-clock", ItemKind::Clock);
        let second = Item::new("other-clock", ItemKind::Clock);
        assert_eq!(first.kind, second.kind);
        assert_ne!(first.id, second.id);
    }
    #[test]
    fn removed_item_fields_are_rejected() {
        for value in [
            serde_json::json!({"id":"title", "kind":"focused-window", "enabled":false}),
            serde_json::json!({"id":"spaces", "kind":"workspaces", "workspace_style":"numbers"}),
        ] {
            assert!(serde_json::from_value::<Item>(value).is_err());
        }
    }

    #[test]
    fn surface_changes_only_replace_composition_when_item_geometry_changes() {
        let panel = Panel::default();
        let mut changed = panel.clone();
        changed.style = PanelStyle::Flat;
        assert!(panel.same_composition(&changed));
        changed.style = PanelStyle::Floating;
        assert!(!panel.same_composition(&changed));
        changed.style = PanelStyle::Flat;
        assert!(panel.same_composition(&changed));
        changed.end.groups[0].padding[1] += 1;
        assert!(!panel.same_composition(&changed));
    }
}