//! Docking: a tree of splits and tab groups. Panels are rounded frames separated by
//! thin gutters; each group has a tab strip (active tab bright, with a panel menu "≡"); the focused
//! panel gets a blue outline. Gutters drag to resize; workspaces are serialized trees.

use egui::{Align2, Rect, Sense, Stroke, pos2, vec2};
use serde::{Deserialize, Serialize};

use craft_ui::layout::{ResizeHandle, ResizeHandleStyle, SplitAxis, SplitSize as SharedSplitSize, split_rect};

use crate::icons::{self, Icon};
use crate::theme::Tokens;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PanelKind {
    Project,
    EffectControls,
    Composition,
    Layer,
    Timeline,
    Info,
    Audio,
    Preview,
    EffectsPresets,
    Properties,
    Character,
    Paragraph,
    Align,
    Tracker,
    Wiggler,
    Smoother,
    MotionSketch,
    Paint,
    Brushes,
    RenderQueue,
    Flowchart,
    History,
    Markers,
    MaskInterpolation,
    ScriptConsole,
    EssentialGraphics,
    /// A dockable ScriptUI panel (a script from the ScriptUI Panels folder), by script window id.
    ScriptPanel(u32),
    /// Another Composition viewer (View ▸ New Viewer), by viewer id (`panels::viewers`).
    Viewer(u32),
    LumetriScopes,
    Footage,
    MediaBrowser,
    Metadata,
    Progress,
    ContentAwareFill,
    /// Window ▸ Create Nulls From Paths (our own panel).
    CreateNullsFromPaths,
    /// Window ▸ VR Comp Editor (our own panel).
    VrCompEditor,
}

impl PanelKind {
    pub const ALL: [PanelKind; 34] = [
        PanelKind::Project,
        PanelKind::EffectControls,
        PanelKind::Composition,
        PanelKind::Layer,
        PanelKind::Timeline,
        PanelKind::Info,
        PanelKind::Audio,
        PanelKind::Preview,
        PanelKind::EffectsPresets,
        PanelKind::Properties,
        PanelKind::Character,
        PanelKind::Paragraph,
        PanelKind::Align,
        PanelKind::Tracker,
        PanelKind::Wiggler,
        PanelKind::Smoother,
        PanelKind::MotionSketch,
        PanelKind::Paint,
        PanelKind::Brushes,
        PanelKind::RenderQueue,
        PanelKind::Flowchart,
        PanelKind::History,
        PanelKind::Markers,
        PanelKind::MaskInterpolation,
        PanelKind::ScriptConsole,
        PanelKind::EssentialGraphics,
        PanelKind::LumetriScopes,
        PanelKind::Footage,
        PanelKind::MediaBrowser,
        PanelKind::Metadata,
        PanelKind::Progress,
        PanelKind::ContentAwareFill,
        PanelKind::CreateNullsFromPaths,
        PanelKind::VrCompEditor,
    ];
    pub fn title(self) -> &'static str {
        match self {
            PanelKind::Project => "Project",
            PanelKind::EffectControls => "Effect Controls",
            PanelKind::Composition => "Composition",
            PanelKind::Layer => "Layer",
            PanelKind::Timeline => "Timeline",
            PanelKind::Info => "Info",
            PanelKind::Audio => "Audio",
            PanelKind::Preview => "Preview",
            PanelKind::EffectsPresets => "Effects & Presets",
            PanelKind::Properties => "Properties",
            PanelKind::Character => "Character",
            PanelKind::Paragraph => "Paragraph",
            PanelKind::Align => "Align",
            PanelKind::Tracker => "Tracker",
            PanelKind::Wiggler => "Wiggler",
            PanelKind::Smoother => "Smoother",
            PanelKind::MotionSketch => "Motion Sketch",
            PanelKind::Paint => "Paint",
            PanelKind::Brushes => "Brushes",
            PanelKind::RenderQueue => "Render Queue",
            PanelKind::Flowchart => "Flowchart",
            PanelKind::History => "History",
            PanelKind::Markers => "Markers",
            PanelKind::MaskInterpolation => "Mask Interpolation",
            PanelKind::ScriptConsole => "Script Console",
            PanelKind::EssentialGraphics => "Essential Graphics",
            PanelKind::ScriptPanel(_) => "ScriptUI Panel",
            PanelKind::Viewer(_) => "Composition",
            PanelKind::LumetriScopes => "Lumetri Scopes",
            PanelKind::Footage => "Footage",
            PanelKind::MediaBrowser => "Media Browser",
            PanelKind::Metadata => "Metadata",
            PanelKind::Progress => "Progress",
            PanelKind::ContentAwareFill => "Content-Aware Fill",
            PanelKind::CreateNullsFromPaths => "Create Nulls From Paths",
            PanelKind::VrCompEditor => "VR Comp Editor",
        }
    }
    pub fn id(self) -> String {
        format!("{self:?}")
    }
    pub fn from_name(s: &str) -> Option<PanelKind> {
        let n = s.to_ascii_lowercase().replace([' ', '_', '-', '&'], "");
        Self::ALL.iter().copied().find(|p| format!("{p:?}").to_ascii_lowercase() == n || p.title().to_ascii_lowercase().replace([' ', '&', '-'], "") == n)
    }
    /// Window-menu shortcut.
    pub fn window_shortcut(self) -> Option<&'static str> {
        match self {
            PanelKind::Project => Some("Cmd+0"),
            PanelKind::Info => Some("Cmd+2"),
            PanelKind::Preview => Some("Cmd+3"),
            PanelKind::Audio => Some("Cmd+4"),
            PanelKind::EffectsPresets => Some("Cmd+5"),
            PanelKind::Character => Some("Cmd+6"),
            PanelKind::Paragraph => Some("Cmd+7"),
            PanelKind::Paint => Some("Cmd+8"),
            PanelKind::Brushes => Some("Cmd+9"),
            PanelKind::RenderQueue => Some("Cmd+Alt+0"),
            PanelKind::EffectControls => Some("F3"),
            _ => None,
        }
    }
    /// Chrome-less panels (none in the AE layout; kept for parity with the docking code).
    pub fn compact(self) -> bool {
        false
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub enum SplitSize {
    Ratio(f32),
    /// First child has a fixed size in points.
    FixedA(f32),
    /// Second child has a fixed size in points.
    FixedB(f32),
}

impl SplitSize {
    fn shared(self) -> SharedSplitSize {
        match self {
            Self::Ratio(value) => SharedSplitSize::Ratio(value),
            Self::FixedA(value) => SharedSplitSize::FixedFirst(value),
            Self::FixedB(value) => SharedSplitSize::FixedSecond(value),
        }
    }
}

/// One frame in a [`DockNode::Stack`]: a header with one tab per panel (a panel dropped onto a
/// stacked panel joins its frame as a tab, as in After Effects).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(from = "StackEntryRepr")]
pub struct StackEntry {
    pub panels: Vec<PanelKind>,
    /// The shown tab.
    pub active: usize,
    pub open: bool,
    /// Content height when open (set by dragging the gaps); `None` = share the remaining height.
    pub height: Option<f32>,
}

/// A saved [`StackEntry`]: workspaces saved before stacked frames held tabs name one `panel`.
#[derive(Deserialize)]
struct StackEntryRepr {
    #[serde(default)]
    panel: Option<PanelKind>,
    #[serde(default)]
    panels: Vec<PanelKind>,
    #[serde(default)]
    active: usize,
    open: bool,
    #[serde(default)]
    height: Option<f32>,
}

impl From<StackEntryRepr> for StackEntry {
    fn from(r: StackEntryRepr) -> StackEntry {
        let mut panels = r.panels;
        if let Some(p) = r.panel
            && !panels.contains(&p)
        {
            panels.insert(0, p);
        }
        let active = r.active.min(panels.len().saturating_sub(1));
        StackEntry { panels, active, open: r.open, height: r.height }
    }
}

impl StackEntry {
    /// A frame showing just `panel`.
    pub fn new(panel: PanelKind, open: bool, height: Option<f32>) -> StackEntry {
        StackEntry { panels: vec![panel], active: 0, open, height }
    }
    pub fn contains(&self, p: PanelKind) -> bool {
        self.panels.contains(&p)
    }
    /// The frame's shown panel.
    pub fn shown(&self) -> Option<PanelKind> {
        self.panels.get(self.active).or(self.panels.first()).copied()
    }
    /// Show `p` (one of its tabs).
    fn show(&mut self, p: PanelKind) {
        if let Some(i) = self.panels.iter().position(|x| *x == p) {
            self.active = i;
        }
    }
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum DockNode {
    /// `vertical`: children stacked top/bottom; else side by side.
    Split {
        vertical: bool,
        size: SplitSize,
        a: Box<DockNode>,
        b: Box<DockNode>,
    },
    Tabs {
        panels: Vec<PanelKind>,
        active: usize,
    },
    /// After Effects' stacked panels (e.g. the Default workspace's right column): each panel has
    /// a header row; clicking it expands or collapses the panel in place, and dragging the gap
    /// between two open panels resizes them.
    Stack {
        entries: Vec<StackEntry>,
    },
}

fn tabs(p: &[PanelKind], active: usize) -> DockNode {
    DockNode::Tabs { panels: p.to_vec(), active }
}
fn stack(e: &[(PanelKind, bool, Option<f32>)]) -> DockNode {
    DockNode::Stack { entries: e.iter().map(|&(panel, open, height)| StackEntry::new(panel, open, height)).collect() }
}
fn hsplit(size: SplitSize, a: DockNode, b: DockNode) -> DockNode {
    DockNode::Split { vertical: false, size, a: Box::new(a), b: Box::new(b) }
}
fn vsplit(size: SplitSize, a: DockNode, b: DockNode) -> DockNode {
    DockNode::Split { vertical: true, size, a: Box::new(a), b: Box::new(b) }
}

/// The built-in workspaces: After Effects 2026's (Window ▸ Workspace), less Libraries (an Adobe
/// service). Learn shows the Home screen (community links instead of Adobe's tutorials);
/// Essential Graphics uses the Properties panel; Undocked Panels floats the panels over the
/// Composition panel.
pub const WORKSPACES: &[&str] = &[
    "Default",
    "Standard",
    "Small Screen",
    "Animation",
    "Effects",
    "Motion Tracking",
    "Paint",
    "Text",
    "Minimal",
    "All Panels",
    "Review",
    "Learn",
    "Essential Graphics",
    "Color",
    "Undocked Panels",
];

/// The floating panels a workspace starts with (Undocked Panels), in points for a window of
/// about 1680×1020 (they are kept inside the window when drawn).
pub fn workspace_floating(name: &str) -> Vec<Floating> {
    use PanelKind::*;
    let f = |panels: &[PanelKind], rect: [f32; 4]| Floating { panels: panels.to_vec(), active: 0, rect };
    match name {
        "Undocked Panels" => vec![
            f(&[Project, EffectControls], [24.0, 110.0, 320.0, 420.0]),
            f(&[Preview, Info, Audio], [1330.0, 110.0, 320.0, 300.0]),
            f(&[EffectsPresets, Properties, Character, Paragraph], [1330.0, 430.0, 320.0, 360.0]),
            f(&[Timeline, RenderQueue], [24.0, 640.0, 1280.0, 340.0]),
        ],
        _ => vec![],
    }
}

/// The default layout of a named workspace.
pub fn workspace(name: &str) -> DockNode {
    use PanelKind::*;
    use SplitSize::*;
    let right = |p: &[PanelKind], q: &[PanelKind]| vsplit(Ratio(0.45), tabs(p, 0), tabs(q, 0));
    match name {
        "Animation" => vsplit(
            Ratio(0.55),
            hsplit(
                FixedA(300.0),
                tabs(&[Project, EffectControls], 1),
                hsplit(FixedB(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview, Audio], &[EffectsPresets, Smoother, Wiggler, MotionSketch])),
            ),
            tabs(&[Timeline, RenderQueue], 0),
        ),
        "Effects" => vsplit(
            Ratio(0.58),
            hsplit(
                FixedA(340.0),
                tabs(&[EffectControls, Project], 0),
                hsplit(FixedB(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview], &[EffectsPresets])),
            ),
            tabs(&[Timeline, RenderQueue], 0),
        ),
        "Motion Tracking" => vsplit(
            Ratio(0.6),
            hsplit(
                FixedA(300.0),
                tabs(&[Project, EffectControls], 0),
                hsplit(FixedB(300.0), tabs(&[Layer, Composition], 0), right(&[Info, Preview], &[Tracker])),
            ),
            tabs(&[Timeline], 0),
        ),
        "Paint" => vsplit(
            Ratio(0.6),
            hsplit(
                FixedA(300.0),
                tabs(&[Project, EffectControls], 0),
                hsplit(FixedB(300.0), tabs(&[Layer, Composition], 0), right(&[Paint, Info], &[Brushes, Preview])),
            ),
            tabs(&[Timeline], 0),
        ),
        "Text" => vsplit(
            Ratio(0.58),
            hsplit(
                FixedA(300.0),
                tabs(&[Project, EffectControls], 0),
                hsplit(FixedB(300.0), tabs(&[Composition], 0), right(&[Character, Paragraph], &[Align, Preview, EffectsPresets])),
            ),
            tabs(&[Timeline], 0),
        ),
        "Minimal" => vsplit(Ratio(0.6), tabs(&[Composition], 0), tabs(&[Timeline], 0)),
        // Review: a large viewer with the markers and the project beside it.
        "Review" => vsplit(
            Ratio(0.66),
            hsplit(FixedA(280.0), tabs(&[Project, Markers], 0), hsplit(FixedB(260.0), tabs(&[Composition, Layer], 0), right(&[Preview, Info], &[Audio]))),
            tabs(&[Timeline, RenderQueue], 0),
        ),
        // Essential Graphics: the Properties panel (After Effects' successor to the Essential
        // Graphics panel) full height on the right, type panels beside the viewer.
        "Essential Graphics" => hsplit(
            FixedB(320.0),
            vsplit(
                Ratio(0.58),
                hsplit(
                    FixedA(280.0),
                    tabs(&[Project, EffectControls], 0),
                    hsplit(FixedB(260.0), tabs(&[Composition, Layer], 0), right(&[Character, Paragraph], &[Align, Preview])),
                ),
                tabs(&[Timeline], 0),
            ),
            stack(&[(Properties, true, None), (EffectsPresets, false, None)]),
        ),
        // Color: wide Effect Controls for grading effects, Info for colour readouts.
        "Color" => vsplit(
            Ratio(0.6),
            hsplit(
                FixedA(360.0),
                tabs(&[EffectControls, Project], 0),
                hsplit(FixedB(340.0), tabs(&[Composition, Layer], 0), right(&[LumetriScopes, Info, Preview], &[EffectsPresets])),
            ),
            tabs(&[Timeline], 0),
        ),
        // Undocked Panels: the Composition panel docked, the others floating
        // ([`workspace_floating`]).
        "Undocked Panels" => tabs(&[Composition, Layer, Flowchart], 0),
        "Small Screen" => vsplit(
            Ratio(0.55),
            hsplit(
                FixedA(240.0),
                tabs(&[Project, EffectControls], 0),
                hsplit(FixedB(240.0), tabs(&[Composition], 0), tabs(&[Info, Preview, EffectsPresets], 1)),
            ),
            tabs(&[Timeline], 0),
        ),
        "All Panels" => vsplit(
            Ratio(0.55),
            hsplit(
                FixedA(300.0),
                tabs(&[Project, EffectControls, Flowchart, History, MediaBrowser, Metadata], 0),
                hsplit(
                    FixedB(300.0),
                    tabs(&[Composition, Layer, Footage], 0),
                    right(
                        &[Info, Preview, Audio, Align, Character, Paragraph, LumetriScopes],
                        &[
                            EffectsPresets,
                            Properties,
                            Tracker,
                            Wiggler,
                            Smoother,
                            MotionSketch,
                            Paint,
                            Brushes,
                            Markers,
                            ContentAwareFill,
                            CreateNullsFromPaths,
                            VrCompEditor,
                        ],
                    ),
                ),
            ),
            tabs(&[Timeline, RenderQueue, Progress], 0),
        ),
        "Standard" => vsplit(
            Ratio(0.56),
            hsplit(
                FixedA(300.0),
                tabs(&[Project, EffectControls], 0),
                hsplit(FixedB(290.0), tabs(&[Composition, Layer], 0), right(&[Info, Audio], &[Preview, EffectsPresets])),
            ),
            tabs(&[Timeline, RenderQueue], 0),
        ),
        // Default (as in After Effects): Project/Effect Controls | Composition over the Timeline,
        // and a full-height right column with Preview above the Properties panel.
        _ => hsplit(
            FixedB(300.0),
            vsplit(Ratio(0.56), hsplit(FixedA(300.0), tabs(&[Project, EffectControls], 0), tabs(&[Composition, Layer], 0)), tabs(&[Timeline, RenderQueue], 0)),
            stack(&[(Preview, true, Some(46.0)), (Properties, true, None), (Align, false, None), (Audio, false, None), (EffectsPresets, false, None)]),
        ),
    }
}

impl DockNode {
    /// Every panel in the tree.
    pub fn panels(&self, out: &mut Vec<PanelKind>) {
        match self {
            DockNode::Split { a, b, .. } => {
                a.panels(out);
                b.panels(out);
            }
            DockNode::Tabs { panels, .. } => out.extend(panels.iter().copied()),
            DockNode::Stack { entries } => out.extend(entries.iter().flat_map(|e| e.panels.iter().copied())),
        }
    }
    pub fn contains(&self, p: PanelKind) -> bool {
        let mut v = Vec::new();
        self.panels(&mut v);
        v.contains(&p)
    }
    /// Make `p` the active tab of its group. Returns false if not present.
    pub fn activate(&mut self, p: PanelKind) -> bool {
        if !crate::dock_shared::valid_tree(self) {
            return false;
        }
        match self {
            DockNode::Split { a, b, .. } => a.activate(p) || b.activate(p),
            DockNode::Tabs { panels, active } => {
                if let Some(i) = panels.iter().position(|x| *x == p) {
                    *active = i;
                    true
                } else {
                    false
                }
            }
            DockNode::Stack { entries } => match entries.iter_mut().find(|e| e.contains(p)) {
                Some(e) => {
                    e.show(p);
                    e.open = true;
                    true
                }
                None => false,
            },
        }
    }
    /// Expand or collapse a stacked panel's frame (showing `p`). Returns false if `p` is not in
    /// a stack.
    pub fn toggle_stacked(&mut self, p: PanelKind) -> bool {
        if !crate::dock_shared::valid_tree(self) {
            return false;
        }
        match self {
            DockNode::Split { a, b, .. } => a.toggle_stacked(p) || b.toggle_stacked(p),
            DockNode::Tabs { .. } => false,
            DockNode::Stack { entries } => match entries.iter_mut().find(|e| e.contains(p)) {
                Some(e) => {
                    e.show(p);
                    e.open = !e.open;
                    true
                }
                None => false,
            },
        }
    }

    pub fn is_visible(&self, p: PanelKind) -> bool {
        match self {
            DockNode::Split { a, b, .. } => a.is_visible(p) || b.is_visible(p),
            DockNode::Tabs { panels, active } => panels.get(*active) == Some(&p),
            DockNode::Stack { entries } => entries.iter().any(|e| e.open && e.shown() == Some(p)),
        }
    }
    /// Close a panel (remove its tab; empty groups collapse their split).
    pub fn close(&mut self, p: PanelKind) {
        if !crate::dock_shared::valid_for_close(self) {
            return;
        }
        if let DockNode::Split { a, b, .. } = self {
            a.close(p);
            b.close(p);
            let empty = |n: &DockNode| match n {
                DockNode::Tabs { panels, .. } => panels.is_empty(),
                DockNode::Stack { entries } => entries.is_empty(),
                DockNode::Split { .. } => false,
            };
            if empty(a) {
                *self = (**b).clone();
            } else if empty(b) {
                *self = (**a).clone();
            }
        } else if let DockNode::Tabs { panels, active } = self {
            let shown = panels.get(*active).copied();
            panels.retain(|x| *x != p);
            *active = shown.and_then(|shown| panels.iter().position(|x| *x == shown)).unwrap_or((*active).min(panels.len().saturating_sub(1)));
        } else if let DockNode::Stack { entries } = self {
            for e in entries.iter_mut() {
                let shown = e.shown();
                e.panels.retain(|x| *x != p);
                e.active = shown.and_then(|shown| e.panels.iter().position(|x| *x == shown)).unwrap_or(e.active.min(e.panels.len().saturating_sub(1)));
            }
            entries.retain(|e| !e.panels.is_empty());
        }
    }
    /// Add a panel as a tab next to `near` (or into the first group).
    pub fn open_near(&mut self, p: PanelKind, near: PanelKind) {
        if !crate::dock_shared::valid_tree(self) {
            return;
        }
        if self.contains(p) {
            self.activate(p);
            return;
        }
        fn add(n: &mut DockNode, p: PanelKind, near: PanelKind) -> bool {
            match n {
                DockNode::Split { a, b, .. } => add(a, p, near) || add(b, p, near),
                DockNode::Tabs { panels, active } => {
                    if panels.contains(&near) {
                        panels.push(p);
                        *active = panels.len() - 1;
                        true
                    } else {
                        false
                    }
                }
                DockNode::Stack { entries } => match entries.iter().position(|e| e.contains(near)) {
                    Some(i) => {
                        entries.insert(i + 1, StackEntry::new(p, true, None));
                        true
                    }
                    None => false,
                },
            }
        }
        fn add_first(n: &mut DockNode, p: PanelKind) -> bool {
            match n {
                DockNode::Split { a, b, .. } => add_first(a, p) || add_first(b, p),
                DockNode::Tabs { panels, active } if !panels.is_empty() => {
                    panels.push(p);
                    *active = panels.len() - 1;
                    true
                }
                DockNode::Stack { entries } if !entries.is_empty() => {
                    entries.push(StackEntry::new(p, true, None));
                    true
                }
                _ => false,
            }
        }
        if self.panel_count() == 0 {
            // Every panel was closed: there is no anchor, so the panel becomes the whole dock.
            *self = tabs(&[p], 0);
        } else if !add(self, p, near) && !add(self, p, PanelKind::EffectsPresets) && !add(self, p, PanelKind::Project) {
            // None of the anchors is docked (e.g. Minimal with Timeline closed): use the first group.
            add_first(self, p);
        }
    }
}

/// Where a dragged panel tab lands on a group: as a tab (center) or split off to one side.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Zone {
    Center,
    Left,
    Right,
    Top,
    Bottom,
}

impl Zone {
    pub(crate) fn shared(self) -> craft_ui::docking::Zone {
        match self {
            Self::Center => craft_ui::docking::Zone::Center,
            Self::Left => craft_ui::docking::Zone::Left,
            Self::Right => craft_ui::docking::Zone::Right,
            Self::Top => craft_ui::docking::Zone::Top,
            Self::Bottom => craft_ui::docking::Zone::Bottom,
        }
    }

    pub fn from_name(s: &str) -> Option<Zone> {
        Some(match s.to_ascii_lowercase().as_str() {
            "center" | "tab" => Zone::Center,
            "left" => Zone::Left,
            "right" => Zone::Right,
            "top" => Zone::Top,
            "bottom" => Zone::Bottom,
            _ => return None,
        })
    }
}

/// The drop zone for a pointer at `pos` over a group `rect` (with a `tab_h` tab strip): the tab
/// strip and the middle of the group are Center; within a quarter of the size from an edge,
/// the nearest edge.
pub fn drop_zone(rect: Rect, tab_h: f32, pos: egui::Pos2) -> Zone {
    match craft_ui::docking::drop_zone(rect, tab_h, pos) {
        Some(craft_ui::docking::Zone::Left) => Zone::Left,
        Some(craft_ui::docking::Zone::Right) => Zone::Right,
        Some(craft_ui::docking::Zone::Top) => Zone::Top,
        Some(craft_ui::docking::Zone::Bottom) => Zone::Bottom,
        _ => Zone::Center,
    }
}

/// The shared preview region, or an empty rectangle for invalid geometry.
pub fn zone_rect(rect: Rect, zone: Zone) -> Rect {
    craft_ui::docking::zone_rect(rect, zone.shared()).unwrap_or(Rect::NOTHING)
}

/// A panel group floating over the dock (undocked).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Floating {
    pub panels: Vec<PanelKind>,
    pub active: usize,
    /// [x, y, w, h] in points.
    pub rect: [f32; 4],
}

/// A floating group moved out of the main window into its own native window (which can sit on
/// another monitor): the group holding `panel` shows there.
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct PanelWindow {
    pub panel: PanelKind,
    /// The window's [x, y] outer position and [w, h] inner size, in desktop points.
    pub rect: [f32; 4],
}

/// The smallest and largest native panel window, in points.
pub const PANEL_WINDOW_MIN: [f32; 2] = [160.0, 100.0];
pub const PANEL_WINDOW_MAX: f32 = 16_384.0;
/// The farthest a native panel window may sit from the desktop origin, in points.
pub const PANEL_WINDOW_MAX_POS: f32 = 100_000.0;

impl PanelWindow {
    /// The rect made safe to hand to the windowing system: finite, with a size within
    /// [`PANEL_WINDOW_MIN`]..=[`PANEL_WINDOW_MAX`] and a position within
    /// ±[`PANEL_WINDOW_MAX_POS`] (hostile workspace files and bad monitor reports included).
    pub fn sanitized(rect: [f32; 4]) -> [f32; 4] {
        let finite = |v: f32, fallback: f32| if v.is_finite() { v } else { fallback };
        let [x, y, w, h] = rect;
        [
            finite(x, 0.0).clamp(-PANEL_WINDOW_MAX_POS, PANEL_WINDOW_MAX_POS),
            finite(y, 0.0).clamp(-PANEL_WINDOW_MAX_POS, PANEL_WINDOW_MAX_POS),
            finite(w, 420.0).clamp(PANEL_WINDOW_MIN[0], PANEL_WINDOW_MAX),
            finite(h, 320.0).clamp(PANEL_WINDOW_MIN[1], PANEL_WINDOW_MAX),
        ]
    }
}

impl DockNode {
    /// Insert panel `p` relative to the group that holds `anchor`: as a tab next to it
    /// (Center) or in a new group split off to one side. In a stack, the group is `anchor`'s
    /// frame: Center adds a tab to that frame and Top / Bottom add a frame above or below it
    /// (#302); Left / Right split the column. `p` is removed from its old place first. Returns
    /// false (tree unchanged) if `anchor` isn't docked or is `p` itself alone.
    pub fn dock_panel(&mut self, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {
        if !crate::dock_shared::valid_tree(self) || p == anchor || !self.contains(anchor) {
            return false;
        }
        let before = self.clone();
        self.close(p);
        fn rec(n: &mut DockNode, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {
            let here = match n {
                DockNode::Split { a, b, .. } => return rec(a, p, anchor, zone) || rec(b, p, anchor, zone),
                DockNode::Tabs { panels, .. } => panels.contains(&anchor),
                DockNode::Stack { entries } => entries.iter().any(|e| e.contains(anchor)),
            };
            if !here {
                return false;
            }
            match (zone, &mut *n) {
                (Zone::Center, DockNode::Tabs { panels, active }) => {
                    let i = panels.iter().position(|x| *x == anchor).map_or(panels.len(), |i| i + 1);
                    panels.insert(i, p);
                    *active = i;
                }
                (Zone::Center, DockNode::Stack { entries }) => {
                    let Some(e) = entries.iter_mut().find(|e| e.contains(anchor)) else { return false };
                    let i = e.panels.iter().position(|x| *x == anchor).map_or(e.panels.len(), |i| i + 1);
                    e.panels.insert(i, p);
                    e.active = i;
                    e.open = true;
                }
                (Zone::Top | Zone::Bottom, DockNode::Stack { entries }) => {
                    let Some(i) = entries.iter().position(|e| e.contains(anchor)) else { return false };
                    let at = if zone == Zone::Top { i } else { i + 1 };
                    entries.insert(at, StackEntry::new(p, true, None));
                }
                (z, node) => {
                    let new = tabs(&[p], 0);
                    let old = std::mem::replace(node, tabs(&[], 0));
                    let vertical = matches!(z, Zone::Top | Zone::Bottom);
                    let (a, b) = if matches!(z, Zone::Left | Zone::Top) { (new, old) } else { (old, new) };
                    *node = DockNode::Split { vertical, size: SplitSize::Ratio(0.5), a: Box::new(a), b: Box::new(b) };
                }
            }
            true
        }
        if rec(self, p, anchor, zone) {
            true
        } else {
            *self = before;
            false
        }
    }

    /// Move panel `p` into the group that holds `anchor` as a tab before `before` (one of that
    /// group's panels) or last, and show it. False (tree unchanged) if `anchor` isn't docked.
    pub fn insert_tab(&mut self, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {
        if !crate::dock_shared::valid_tree(self) {
            return false;
        }
        if p == anchor || !self.contains(anchor) {
            return false;
        }
        let saved = self.clone();
        self.close(p);
        fn rec(n: &mut DockNode, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {
            match n {
                DockNode::Split { a, b, .. } => rec(a, p, anchor, before) || rec(b, p, anchor, before),
                DockNode::Tabs { panels, active } if panels.contains(&anchor) => {
                    let i = before.and_then(|b| panels.iter().position(|x| *x == b)).unwrap_or(panels.len());
                    panels.insert(i, p);
                    *active = i;
                    true
                }
                DockNode::Stack { entries } => {
                    // A tab of the anchor's frame.
                    let Some(e) = entries.iter_mut().find(|e| e.contains(anchor)) else { return false };
                    let i = before.and_then(|b| e.panels.iter().position(|x| *x == b)).unwrap_or(e.panels.len());
                    e.panels.insert(i, p);
                    e.active = i;
                    e.open = true;
                    true
                }
                _ => false,
            }
        }
        if rec(self, p, anchor, before) {
            true
        } else {
            *self = saved;
            false
        }
    }

    /// Path of the group containing `p` (as in [`Group::path`]; stacks add `sN`).
    pub fn path_of(&self, p: PanelKind) -> Option<String> {
        fn rec(n: &DockNode, p: PanelKind, path: &str) -> Option<String> {
            match n {
                DockNode::Split { a, b, .. } => rec(a, p, &format!("{path}a")).or_else(|| rec(b, p, &format!("{path}b"))),
                DockNode::Tabs { panels, .. } => panels.contains(&p).then(|| path.to_string()),
                DockNode::Stack { entries } => entries.iter().position(|e| e.contains(p)).map(|i| format!("{path}s{i}")),
            }
        }
        rec(self, p, "")
    }

    /// Number of panels in the tree.
    pub fn panel_count(&self) -> usize {
        let mut v = vec![];
        self.panels(&mut v);
        v.len()
    }
}

/// A full layout: the docked tree plus floating panels (what a workspace saves).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Layout {
    pub root: DockNode,
    #[serde(default)]
    pub floating: Vec<Floating>,
}

impl Layout {
    /// Apply a shared transaction without replacing the persisted app schema.
    pub fn apply(&mut self, action: craft_ui::docking::Action<PanelKind>) -> Result<(), String> {
        crate::dock_shared::encode(&self.root, &self.floating)?.validate().map_err(|error| error.to_string())?;
        let moving_to_float = match &action {
            craft_ui::docking::Action::Float { panel, .. } => Some(*panel),
            craft_ui::docking::Action::Move { panel, anchor, .. } if self.floating.iter().any(|group| group.panels.contains(anchor)) => Some(*panel),
            _ => None,
        };
        if moving_to_float.is_some_and(|panel| self.root.contains(panel) && self.root.panel_count() <= 1) {
            return Err("the last docked panel must remain in the workspace".into());
        }
        crate::dock_shared::apply(self, action)
    }

    /// Undock an existing panel; the final docked panel stays in the workspace.
    pub fn float(&mut self, p: PanelKind, rect: [f32; 4]) -> bool {
        self.apply(craft_ui::docking::Action::Float { panel: p, rect }).is_ok()
    }

    /// Close an existing floating panel and collapse its empty group.
    pub fn unfloat(&mut self, p: PanelKind) -> bool {
        crate::dock_shared::unfloat(self, p)
    }

    /// Move or reorder a docked/floating tab through the shared transaction.
    pub fn insert_tab(&mut self, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {
        if !crate::dock_shared::valid_tree(&self.root) {
            return false;
        }
        self.apply(craft_ui::docking::Action::Move { panel: p, anchor, placement: craft_ui::docking::Placement::Tab { before } }).is_ok()
    }

    /// Dock a panel beside an anchor; floating destinations accept tabs only.
    pub fn dock(&mut self, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {
        if !crate::dock_shared::valid_tree(&self.root) {
            return false;
        }
        self.apply(craft_ui::docking::Action::Move { panel: p, anchor, placement: craft_ui::docking::Placement::Split(zone.shared()) }).is_ok()
    }

    pub fn contains(&self, p: PanelKind) -> bool {
        self.root.contains(p) || self.floating.iter().any(|group| group.panels.contains(&p))
    }
}

/// One laid-out tab group.
pub struct Group {
    pub path: String,
    pub rect: Rect,
    pub content: Rect,
    pub panels: Vec<PanelKind>,
    pub active: usize,
    /// In a [`DockNode::Stack`]: whether the panel is expanded.
    pub stacked: Option<bool>,
}

/// Actions produced by interacting with the dock chrome.
#[derive(Debug, Clone, PartialEq)]
pub enum DockAction {
    Activate(PanelKind),
    /// Expand/collapse a stacked panel.
    ToggleStacked(PanelKind),
    Focus(PanelKind),
    Close(PanelKind),
    PanelMenu(PanelKind, egui::Pos2),
    /// A tab started being dragged (re-dock or undock).
    BeginDrag(PanelKind),
    /// The tab's lock was toggled (Composition / Timeline viewer lock).
    ToggleLock(PanelKind),
    /// A document tab of a panel was clicked (the Timeline's tab of comp `id`).
    ActivateDoc(PanelKind, u64),
    /// A document tab's close button (or middle click): close that document (comp `id`).
    CloseDoc(PanelKind, u64),
}

/// One document a panel shows as a tab of its own (the Timeline: one tab per open comp, as in
/// After Effects).
#[derive(Debug, Clone, PartialEq)]
pub struct DocTab {
    pub id: u64,
    pub title: String,
    pub deco: Option<TabDeco>,
    /// The document the panel shows now.
    pub active: bool,
}

/// What a group's tabs show: labels, the comp swatch / close / lock decorations and the panels
/// that show one tab per document.
pub struct TabInfo<'a> {
    pub title: &'a dyn Fn(PanelKind) -> String,
    pub decos: &'a [(PanelKind, TabDeco)],
    pub docs: &'a [(PanelKind, Vec<DocTab>)],
}

/// What drawing a group's chrome produced: actions and where each panel's tabs are (a panel with
/// document tabs spans all of them; tabs hidden behind the overflow chevron are left out).
#[derive(Default)]
pub struct Chrome {
    pub actions: Vec<DockAction>,
    pub tabs: Vec<(PanelKind, Rect)>,
}

/// After Effects-style extras on a tab that shows a composition (Composition, Timeline): a close
/// button (×), the item's label colour as a small square and the viewer lock.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TabDeco {
    pub swatch: egui::Color32,
    pub locked: bool,
    /// Close button and lock (Composition, Timeline); Effect Controls shows just the swatch.
    pub viewer: bool,
}

/// Lay out the tree into group rects (with `gap` gutters) and handle gutter dragging.
pub fn layout(ui: &mut egui::Ui, node: &mut DockNode, rect: Rect, t: &Tokens, path: &str, out: &mut Vec<Group>, reg: &mut crate::automation::Registry) {
    let mut actions = Vec::new();
    layout_with_actions(ui, node, rect, t, path, out, reg, &mut actions);
    for action in actions {
        crate::dock_shared::apply_tree(node, action);
    }
}

/// Lay out chrome while returning mutations for the application's UI command route.
pub fn layout_with_actions(
    ui: &mut egui::Ui,
    node: &mut DockNode,
    rect: Rect,
    t: &Tokens,
    path: &str,
    out: &mut Vec<Group>,
    reg: &mut crate::automation::Registry,
    actions: &mut Vec<craft_ui::docking::Action<PanelKind>>,
) {
    layout_inner(ui, node, rect, t, path, &[], out, reg, actions);
}

fn layout_inner(
    ui: &mut egui::Ui,
    node: &mut DockNode,
    rect: Rect,
    t: &Tokens,
    path: &str,
    tree_path: &[bool],
    out: &mut Vec<Group>,
    reg: &mut crate::automation::Registry,
    actions: &mut Vec<craft_ui::docking::Action<PanelKind>>,
) {
    match node {
        DockNode::Tabs { panels, active } => {
            let tab_h = if panels.len() == 1 && panels[0].compact() { 8.0 } else { t.tab_h };
            let content = Rect::from_min_max(pos2(rect.min.x, rect.min.y + tab_h), rect.max);
            out.push(Group { path: path.to_string(), rect, content, panels: panels.clone(), active: *active, stacked: None });
        }
        DockNode::Stack { entries } => {
            // A header for every entry; the open panels' bodies share the rest.
            let head = t.tab_h;
            let g = t.gap;
            let n = entries.len() as f32;
            let avail = rect.height() - n * head - (n - 1.0).max(0.0) * g;
            let bodies = stack_bodies(entries, avail);
            let mut y = rect.min.y;
            let mut drag = None;
            for (i, e) in entries.iter().enumerate() {
                let body = bodies.get(i).copied().unwrap_or(0.0);
                let r = Rect::from_min_max(pos2(rect.min.x, y), pos2(rect.max.x, (y + head + body).min(rect.max.y)));
                let content = Rect::from_min_max(pos2(r.min.x, r.min.y + head), r.max);
                let group = format!("{path}s{i}");
                // The gap below a panel resizes the open panels on either side of it.
                let above = entries.get(..=i).and_then(|s| s.iter().rposition(|x| x.open));
                let below = entries.get(i + 1..).and_then(|s| s.iter().position(|x| x.open)).map(|k| i + 1 + k);
                if let (Some(above), Some(below)) = (above, below) {
                    let gap = Rect::from_min_max(pos2(rect.min.x, r.max.y), pos2(rect.max.x, r.max.y + g));
                    if let Some(d) = gutter(ui, gap, true, &group, t, reg) {
                        drag = Some((above, below, d));
                    }
                }
                out.push(Group { path: group, rect: r, content, panels: e.panels.clone(), active: e.active, stacked: Some(e.open) });
                y = r.max.y + g;
            }
            if let Some((above, below, d)) = drag {
                let mut proposed = entries.clone();
                resize_stacked(&mut proposed, &bodies, above, below, d);
                for (before, after) in entries.iter().zip(proposed) {
                    if before.height != after.height
                        && let Some(panel) = after.shown()
                    {
                        actions.push(craft_ui::docking::Action::ResizeStack { panel, height: after.height });
                    }
                }
            }
        }
        DockNode::Split { vertical, size, a, b } => {
            let axis = if *vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal };
            let Some(split) = split_rect(rect, axis, size.shared(), t.gap, 20.0) else { return };
            let response = resize_handle(split.divider, *vertical, path, t).value(split.first_size(), 0.0..=split.available()).show(ui);
            reg.add(&format!("dock.gutter.{path}"), response.response.rect, "gutter");
            if response.delta != 0.0
                && let Some(resized) = split.resized(size.shared(), response.delta, 40.0)
            {
                actions.push(craft_ui::docking::Action::ResizeSplit { path: tree_path.to_vec(), size: resized });
            }
            let mut first_path = tree_path.to_vec();
            first_path.push(false);
            let mut second_path = tree_path.to_vec();
            second_path.push(true);
            layout_inner(ui, a, split.first, t, &format!("{path}a"), &first_path, out, reg, actions);
            layout_inner(ui, b, split.second, t, &format!("{path}b"), &second_path, out, reg, actions);
        }
    }
}

/// A gap between dock areas that drags to resize them (`vertical`: up and down), with a slightly
/// larger hit area than the gap. Returns the drag this frame.
fn gutter(ui: &mut egui::Ui, gap: Rect, vertical: bool, path: &str, t: &Tokens, reg: &mut crate::automation::Registry) -> Option<f32> {
    let response = resize_handle(gap, vertical, path, t).show(ui);
    reg.add(&format!("dock.gutter.{path}"), response.response.rect, "gutter");
    (response.delta != 0.0).then_some(response.delta)
}

fn resize_handle(gap: Rect, vertical: bool, path: &str, t: &Tokens) -> ResizeHandle<'static> {
    let axis = if vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal };
    let style = ResizeHandleStyle { hovered: t.focus.gamma_multiply(0.4), dragged: t.focus.gamma_multiply(0.9), focused: t.focus };
    let label = if vertical { crate::i18n::tr("Height:") } else { crate::i18n::tr("Width:") };
    ResizeHandle::new(egui::Id::new(("dock-gutter", path.to_string())), axis, gap, label, style)
}

/// The least body height of an open stacked panel (when the stack has room for it).
const STACK_MIN: f32 = 40.0;

/// An open stacked panel without a height of its own: it shares the room the others leave.
fn flexible(e: &StackEntry) -> bool {
    e.open && !e.height.is_some_and(f32::is_finite)
}

/// The body heights of a stack's panels in `avail` points (headers and gaps taken out). Open
/// panels with a height keep it and the others share the rest; when no panel takes the rest, or
/// there is too little room, the heights grow or shrink in proportion (down to [`STACK_MIN`]) so
/// the open panels fill the stack.
fn stack_bodies(entries: &[StackEntry], avail: f32) -> Vec<f32> {
    let avail = if avail.is_finite() { avail.max(0.0) } else { 0.0 };
    let open = entries.iter().filter(|e| e.open).count();
    let min = STACK_MIN.min(avail / open.max(1) as f32);
    let fixed: Vec<f32> = entries.iter().filter(|e| e.open && !flexible(e)).filter_map(|e| e.height).map(|h| h.max(min)).collect();
    let flex = open.saturating_sub(fixed.len());
    let k = fixed.len() as f32;
    // What the panels with a height may take, and how much of it lies above their minimum.
    let room = avail - flex as f32 * min;
    let sum: f32 = fixed.iter().sum();
    let (excess, target) = (sum - k * min, (room - k * min).max(0.0));
    let fit = flex == 0 || sum > room;
    let size = |h: f32| match (fit, excess > 0.0) {
        (false, _) => h,
        (true, true) => min + (h - min) / excess * target,
        (true, false) => min + target / k.max(1.0),
    };
    let used: f32 = fixed.iter().map(|&h| size(h)).sum();
    let share = (avail - used).max(0.0) / flex.max(1) as f32;
    entries
        .iter()
        .map(|e| match (e.open, flexible(e)) {
            (false, _) => 0.0,
            (true, true) => share,
            (true, false) => size(e.height.unwrap_or(min).max(min)),
        })
        .collect()
}

/// `v` held to `lo..=hi`, never panicking: when the room is too small for both minimums
/// (`hi < lo`), `lo` wins; a non-finite `v` gives `lo`.
#[cfg(test)]
fn clamp_ordered(v: f32, lo: f32, hi: f32) -> f32 {
    let lo = if lo.is_finite() { lo } else { 0.0 };
    let hi = if hi.is_finite() { hi.max(lo) } else { lo };
    if v.is_finite() { v.max(lo).min(hi) } else { lo }
}

/// The size of a split's first side in `avail` points (both sides keep 20 pt when there is room).
/// `f32::clamp` panics when its bounds cross, which a split shorter than 40 pt did (#306).
#[cfg(test)]
fn split_first(size: SplitSize, avail: f32) -> f32 {
    let avail = if avail.is_finite() { avail.max(0.0) } else { 0.0 };
    let first = match size {
        SplitSize::Ratio(r) => avail * r,
        SplitSize::FixedA(px) => px.min(avail - 20.0),
        SplitSize::FixedB(px) => avail - px.min(avail - 20.0),
    };
    let lo = 20.0_f32.min(avail);
    clamp_ordered(first, lo, avail - 20.0).min(avail)
}

/// Drag the gap between the open stacked panels `above` and `below` (laid out at `bodies`) by
/// `d` points: one grows as much as the other shrinks, neither below [`STACK_MIN`]. The new sizes
/// become the panels' heights, except that the last panel without one keeps sharing the rest
/// (so the stack still fills its column when the window is resized).
fn resize_stacked(entries: &mut [StackEntry], bodies: &[f32], above: usize, below: usize, d: f32) {
    let (Some(&a), Some(&b)) = (bodies.get(above), bodies.get(below)) else { return };
    let pair = a + b;
    let lo = STACK_MIN.min(pair / 2.0);
    let na = (a + d).max(lo).min(pair - lo);
    for (i, h) in [(above, na), (below, pair - na)] {
        let last_flexible = entries.iter().filter(|e| flexible(e)).count() == 1;
        if let Some(e) = entries.get_mut(i)
            && !(last_flexible && flexible(e))
        {
            e.height = Some(h);
        }
    }
}

/// Draw a group's frame + tab strip: one tab per panel, or per document for panels that show
/// several (the Timeline's comps). Tab labels may name the comp or layer they show (After
/// Effects style).
pub fn draw_group_chrome(ui: &mut egui::Ui, g: &Group, t: &Tokens, reg: &mut crate::automation::Registry, info: &TabInfo) -> Chrome {
    struct Entry {
        panel: PanelKind,
        doc: Option<u64>,
        label: String,
        deco: Option<TabDeco>,
        /// The group's shown tab.
        active: bool,
        /// The document its panel shows (even behind another tab).
        shown_doc: bool,
    }
    let mut out = Chrome::default();
    let painter = ui.painter().clone();
    painter.rect_filled(g.rect, t.radius, t.panel_bg);
    let active_panel = g.panels.get(g.active).copied();
    let compact = g.panels.len() == 1 && g.panels[0].compact();
    if compact {
        // grip dots
        let c = pos2(g.rect.center().x, g.rect.min.y + 4.0);
        for dx in [-4.0, 0.0, 4.0] {
            painter.circle_filled(c + vec2(dx, 0.0), 1.0, t.text_faint);
        }
    } else {
        let mut entries: Vec<Entry> = vec![];
        for (pi, p) in g.panels.iter().enumerate() {
            let shown = pi == g.active;
            match info.docs.iter().find(|(k, d)| k == p && !d.is_empty()) {
                Some((_, docs)) => entries.extend(docs.iter().map(|d| Entry {
                    panel: *p,
                    doc: Some(d.id),
                    label: d.title.clone(),
                    deco: d.deco,
                    active: shown && d.active,
                    shown_doc: d.active,
                })),
                None => entries.push(Entry {
                    panel: *p,
                    doc: None,
                    label: (info.title)(*p),
                    deco: info.decos.iter().find(|(k, _)| k == p).map(|(_, d)| *d),
                    active: shown,
                    shown_doc: false,
                }),
            }
        }
        let ai = entries.iter().position(|e| e.active).unwrap_or(0);
        let strip = Rect::from_min_size(g.rect.min, vec2(g.rect.width(), t.tab_h));
        if t.gradients {
            // Settings ▸ Appearance ▸ Use Gradients.
            crate::theme::gradient_rect(&painter, strip.shrink2(vec2(t.radius, 0.0)), t.grad_top(t.panel_bg), t.panel_bg);
        }
        let activate = |e: &Entry| match e.doc {
            Some(id) => DockAction::ActivateDoc(e.panel, id),
            None => DockAction::Activate(e.panel),
        };
        let close = |e: &Entry| match e.doc {
            Some(id) => DockAction::CloseDoc(e.panel, id),
            None => DockAction::Close(e.panel),
        };
        let mut x = strip.min.x + 12.0;
        let text_y = strip.min.y + 16.0;
        for (k, e) in entries.iter().enumerate() {
            let p = &e.panel;
            // A collapsed stacked panel's header is plain text (no underline or panel menu).
            let is_active = k == ai && g.stacked != Some(false);
            let galley = painter.layout_no_wrap(e.label.clone(), Tokens::ui(12.0), if is_active { t.tab_text_active } else { t.tab_text });
            let menu_w = if is_active { 20.0 } else { 0.0 };
            // The lock belongs to the panel: on its shown document's tab only.
            let lock = e.deco.is_some_and(|d| d.viewer) && (e.doc.is_none() || is_active);
            // × (active tab only), swatch and lock before the label.
            let deco_w = match e.deco {
                Some(d) if d.viewer => (if is_active { 16.0 } else { 0.0 }) + 14.0 + if lock { 16.0 } else { 0.0 },
                Some(_) => 14.0,
                None => 0.0,
            };
            let w = galley.size().x + 16.0 + menu_w + deco_w;
            if x + w > strip.max.x - 20.0 && k > ai {
                let r = Rect::from_min_size(pos2(strip.max.x - 22.0, strip.min.y + 6.0), vec2(18.0, 20.0));
                let resp = ui.interact(r, egui::Id::new(("tab-overflow", g.path.clone())), Sense::click());
                icons::paint(&painter, r.shrink(4.0).translate(vec2(-2.0, 0.0)), Icon::ChevronRight, t.tab_text);
                icons::paint(&painter, r.shrink(4.0).translate(vec2(2.0, 0.0)), Icon::ChevronRight, t.tab_text);
                crate::widgets::focus_outline(ui, &resp, t);
                reg.add_response(&format!("panel.overflow.{}", g.path), &resp, "More tabs");
                if resp.clicked()
                    && let Some(next) = entries.get((ai + 1) % entries.len())
                {
                    out.actions.push(activate(next));
                }
                break;
            }
            let tab = Rect::from_min_size(pos2(x, strip.min.y), vec2(w, t.tab_h));
            match out.tabs.iter_mut().find(|(q, _)| q == p) {
                Some((_, r)) => *r = r.union(tab),
                None => out.tabs.push((*p, tab)),
            }
            let resp = ui.interact(tab, egui::Id::new(("tab", g.path.clone(), k)), Sense::click_and_drag());
            if resp.drag_started() {
                out.actions.push(DockAction::BeginDrag(*p));
            }
            // A document tab also answers to the panel's id while it is the shown one.
            let auto_id = match e.doc {
                Some(id) => format!("panel.tab.{}.{id}", p.id()),
                None => format!("panel.tab.{}", p.id()),
            };
            reg.add_response(&auto_id, &resp, &e.label);
            if e.shown_doc {
                reg.add_response(&format!("panel.tab.{}", p.id()), &resp, &e.label);
            }
            let mut label_x = tab.min.x + 8.0;
            if let Some(d) = e.deco {
                let mut dx = tab.min.x + 6.0;
                if is_active && d.viewer {
                    let cr = Rect::from_center_size(pos2(dx + 5.0, text_y), vec2(10.0, 10.0));
                    let cresp = ui.interact(cr.expand(2.0), egui::Id::new(("tab-close", g.path.clone(), k)), Sense::click());
                    let cc = if cresp.hovered() { t.tab_text_active } else { t.tab_text };
                    let kk = 3.5;
                    painter.line_segment([cr.center() + vec2(-kk, -kk), cr.center() + vec2(kk, kk)], Stroke::new(1.2, cc));
                    painter.line_segment([cr.center() + vec2(-kk, kk), cr.center() + vec2(kk, -kk)], Stroke::new(1.2, cc));
                    reg.add_response(&format!("panel.tab.{}.close", p.id()), &cresp, "Close");
                    crate::widgets::focus_outline(ui, &cresp, t);
                    if cresp.clicked() {
                        out.actions.push(close(e));
                    }
                    dx += 16.0;
                }
                let sw = Rect::from_center_size(pos2(dx + 5.0, text_y), vec2(9.0, 9.0));
                painter.rect_filled(sw, 1.0, d.swatch);
                dx += 14.0;
                label_x = dx;
                if lock {
                    let lr = Rect::from_center_size(pos2(dx + 6.0, text_y), vec2(12.0, 12.0));
                    let lresp = ui.interact(lr.expand(2.0), egui::Id::new(("tab-lock", g.path.clone(), k)), Sense::click());
                    let lc = if d.locked {
                        t.tab_text_active
                    } else if lresp.hovered() {
                        t.tab_text
                    } else {
                        t.text_faint
                    };
                    icons::paint(&painter, lr, Icon::Lock, lc);
                    reg.add_response(&format!("panel.tab.{}.lock", p.id()), &lresp, if d.locked { "Unlock" } else { "Lock" });
                    crate::widgets::focus_outline(ui, &lresp, t);
                    if lresp.clicked() {
                        out.actions.push(DockAction::ToggleLock(*p));
                    }
                    label_x = dx + 16.0;
                }
            }
            let label_w = galley.size().x;
            let col = if is_active || resp.hovered() { t.tab_text_active } else { t.tab_text };
            painter.galley_with_override_text_color(pos2(label_x, text_y - galley.size().y / 2.0), galley, col);
            if is_active {
                let mr = Rect::from_center_size(pos2(label_x + label_w + 12.0, text_y), vec2(12.0, 10.0));
                let mresp = ui.interact(mr.expand(3.0), egui::Id::new(("tab-menu", g.path.clone())), Sense::click());
                reg.add_response(&format!("panel.menu.{}", p.id()), &mresp, "panel menu");
                let mc = if mresp.hovered() { t.tab_text_active } else { t.tab_text };
                for dy in [-3.5, 0.0, 3.5] {
                    painter.line_segment([pos2(mr.min.x, mr.center().y + dy), pos2(mr.max.x, mr.center().y + dy)], Stroke::new(1.5, mc));
                }
                let uy = strip.min.y + 23.0;
                painter.line_segment([pos2(label_x, uy), pos2(mr.max.x, uy)], Stroke::new(1.0, t.tab_text_active));
                crate::widgets::focus_outline(ui, &mresp, t);
                if mresp.clicked() {
                    out.actions.push(DockAction::PanelMenu(*p, mr.left_bottom()));
                }
            }
            crate::widgets::focus_outline(ui, &resp, t);
            if resp.clicked() {
                // A stacked frame's shown tab expands / collapses it; another tab shows that
                // panel (expanding the frame).
                if g.stacked.is_some() && (k == ai || entries.len() == 1) {
                    out.actions.push(DockAction::ToggleStacked(*p));
                } else {
                    out.actions.push(activate(e));
                }
                out.actions.push(DockAction::Focus(*p));
            }
            if resp.middle_clicked() {
                out.actions.push(close(e));
            }
            x += w + 8.0;
        }
        // A stacked panel's whole header bar expands/collapses it, not just its name (as in After
        // Effects): the frame with its shown tab.
        if g.stacked.is_some()
            && let Some(e) = entries.get(ai).or(entries.first())
        {
            let rest = Rect::from_min_max(pos2((x - 8.0).max(strip.min.x), strip.min.y), strip.max);
            if rest.width() > 0.0 {
                let resp = ui.interact(rest, egui::Id::new(("tab-rest", g.path.clone())), Sense::click());
                reg.add(&format!("panel.header.{}", e.panel.id()), rest, &e.label);
                if resp.clicked() {
                    out.actions.push(DockAction::ToggleStacked(e.panel));
                    out.actions.push(DockAction::Focus(e.panel));
                }
            }
        }
    }
    // clicking anywhere in the panel focuses it
    if let Some(p) = active_panel
        && ui.rect_contains_pointer(g.rect)
        && ui.input(|i| i.pointer.any_pressed())
    {
        out.actions.push(DockAction::Focus(p));
    }
    out
}

/// Placeholder body for panels that are not implemented yet.
pub fn placeholder(ui: &mut egui::Ui, rect: Rect, t: &Tokens, text: &str) {
    ui.painter().text(rect.center(), Align2::CENTER_CENTER, text, Tokens::ui(12.0), t.text_faint);
}

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

    /// The original split clamp panicked whenever 0 < available < 40. Run the actual dock
    /// layout without the app's last-resort panic guard so that regression cannot be hidden.
    #[test]
    fn tiny_split_layouts_stay_inside_their_parent() {
        let ctx = egui::Context::default();
        let tokens = Tokens::for_kind(crate::theme::ThemeKind::Dark);
        for extent in [20.0, 0.0, 1.0, 5.0, 15.0, 35.0, 39.9, 40.0, 80.0] {
            for vertical in [false, true] {
                for size in [SplitSize::Ratio(0.5), SplitSize::FixedA(300.0), SplitSize::FixedB(300.0)] {
                    let rect = Rect::from_min_size(egui::Pos2::ZERO, egui::Vec2::splat(extent));
                    let mut node =
                        DockNode::Split { vertical, size, a: Box::new(tabs(&[PanelKind::Project], 0)), b: Box::new(tabs(&[PanelKind::Composition], 0)) };
                    let mut groups = vec![];
                    let mut registry = crate::automation::Registry::default();
                    let mut output = ctx.run_ui(egui::RawInput::default(), |ui| layout(ui, &mut node, rect, &tokens, "", &mut groups, &mut registry));
                    output.textures_delta.clear();
                    assert_eq!(groups.len(), 2);
                    for group in groups {
                        assert!(rect.contains_rect(group.rect), "{extent}, {vertical}: {:?}", group.rect);
                        assert!(group.rect.width() >= 0.0 && group.rect.height() >= 0.0);
                    }
                }
            }
        }
    }

    #[test]
    fn open_near_in_an_empty_dock_makes_the_panel_the_dock() {
        for p in [PanelKind::Composition, PanelKind::Timeline, PanelKind::Project] {
            let mut d = tabs(&[], 0);
            d.open_near(p, PanelKind::EffectsPresets);
            assert!(d.is_visible(p));
            assert_eq!(d.panel_count(), 1);
        }
    }

    #[test]
    fn open_near_without_any_anchor_uses_the_first_group() {
        let mut d = tabs(&[PanelKind::Composition], 0);
        d.open_near(PanelKind::Timeline, PanelKind::EffectsPresets);
        assert!(d.is_visible(PanelKind::Timeline));
        assert_eq!(d.panel_count(), 2);
    }

    #[test]
    fn stacked_panels_toggle_open_close() {
        use PanelKind::*;
        let mut d = stack(&[(Preview, true, Some(46.0)), (Properties, true, None), (Align, false, None)]);
        assert!(d.is_visible(Properties) && !d.is_visible(Align));
        assert!(d.toggle_stacked(Align));
        assert!(d.is_visible(Align));
        assert!(d.toggle_stacked(Align) && !d.is_visible(Align));
        // Showing a collapsed panel expands it; opening a new panel near one inserts after it.
        assert!(d.activate(Align) && d.is_visible(Align));
        d.open_near(Info, Properties);
        let mut v = vec![];
        d.panels(&mut v);
        assert_eq!(v, [Preview, Properties, Info, Align]);
        d.close(Preview);
        assert!(!d.contains(Preview));
        assert!(!d.toggle_stacked(Timeline));
    }

    fn entry(panel: PanelKind, open: bool, height: Option<f32>) -> StackEntry {
        StackEntry::new(panel, open, height)
    }

    fn close_to(a: &[f32], b: &[f32]) -> bool {
        a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-3)
    }

    #[test]
    fn stacked_panels_fill_their_column() {
        use PanelKind::*;
        // A panel with a height keeps it; the open ones without share the rest.
        let s = [entry(Preview, true, Some(100.0)), entry(Properties, true, None), entry(Align, false, None), entry(Audio, true, None)];
        assert!(close_to(&stack_bodies(&s, 500.0), &[100.0, 200.0, 0.0, 200.0]));
        // Too little room: the heights shrink so the others keep their minimum.
        let s = [entry(Preview, true, Some(500.0)), entry(Properties, true, None)];
        assert!(close_to(&stack_bodies(&s, 300.0), &[260.0, STACK_MIN]));
        // Nothing to take the rest: the heights grow in proportion (above the minimum) to fill.
        let s = [entry(Preview, true, Some(100.0)), entry(Properties, true, Some(300.0)), entry(Align, false, Some(80.0))];
        assert!(close_to(&stack_bodies(&s, 600.0), &[137.5, 462.5, 0.0]));
        let s = [entry(Preview, true, Some(46.0)), entry(Properties, false, None)];
        assert!(close_to(&stack_bodies(&s, 600.0), &[600.0, 0.0]));
        // Hostile sizes never make a body negative or non-finite.
        for avail in [-50.0, 0.0, 10.0, f32::NAN, f32::INFINITY] {
            for h in [None, Some(-5.0), Some(f32::NAN), Some(f32::INFINITY), Some(1e30), Some(f32::MAX)] {
                let s = [entry(Preview, true, h), entry(Properties, true, Some(60.0)), entry(Align, false, h)];
                let b = stack_bodies(&s, avail);
                assert!(b.iter().all(|x| x.is_finite() && *x >= 0.0), "{avail} {h:?}: {b:?}");
            }
        }
        assert!(stack_bodies(&[], 100.0).is_empty());
    }

    #[test]
    fn dragging_a_stack_gap_trades_height_between_its_neighbours() {
        use PanelKind::*;
        let mut s = vec![entry(Preview, true, Some(46.0)), entry(Properties, true, None), entry(Align, false, None)];
        let bodies = stack_bodies(&s, 800.0);
        resize_stacked(&mut s, &bodies, 0, 1, 100.0);
        // Preview keeps its new height; Properties, the only panel without one, takes the rest.
        assert_eq!(s[0].height, Some(146.0));
        assert_eq!(s[1].height, None);
        assert!(close_to(&stack_bodies(&s, 800.0), &[146.0, 654.0, 0.0]));
        // Neither side goes below the minimum.
        for (d, want) in [(-1000.0, STACK_MIN), (1000.0, 800.0 - STACK_MIN)] {
            let bodies = stack_bodies(&s, 800.0);
            resize_stacked(&mut s, &bodies, 0, 1, d);
            assert!(close_to(&stack_bodies(&s, 800.0)[..1], &[want]), "{d}");
        }
        // Two sharing panels: the upper one gets a height, the lower one keeps sharing.
        let mut s = vec![entry(Preview, true, None), entry(Align, false, None), entry(Properties, true, None)];
        let bodies = stack_bodies(&s, 400.0);
        resize_stacked(&mut s, &bodies, 0, 2, 50.0);
        assert_eq!((s[0].height, s[2].height), (Some(250.0), None));
        assert!(close_to(&stack_bodies(&s, 400.0), &[250.0, 0.0, 150.0]));
        // Out-of-range indices change nothing.
        let before = s.clone();
        resize_stacked(&mut s, &bodies, 0, 9, 50.0);
        assert_eq!(s, before);
    }

    #[test]
    fn default_workspace_has_ae_right_column_stack() {
        let d = workspace("Default");
        assert!(d.is_visible(PanelKind::Properties) && d.is_visible(PanelKind::Preview));
        assert!(d.contains(PanelKind::EffectsPresets) && !d.is_visible(PanelKind::EffectsPresets));
    }

    #[test]
    fn workspaces_contain_core_panels() {
        for w in WORKSPACES {
            let d = workspace(w);
            let floating: Vec<PanelKind> = workspace_floating(w).into_iter().flat_map(|f| f.panels).collect();
            assert!(d.contains(PanelKind::Timeline) || floating.contains(&PanelKind::Timeline), "{w}");
            assert!(d.contains(PanelKind::Composition) || d.contains(PanelKind::Layer), "{w}");
            // A panel is in one place only.
            let mut all = vec![];
            d.panels(&mut all);
            all.extend(floating);
            let n = all.len();
            all.sort_by_key(|p| p.id());
            all.dedup();
            assert_eq!(all.len(), n, "{w} has a panel twice");
        }
    }

    #[test]
    fn after_effects_workspaces_exist() {
        // Window ▸ Workspace in After Effects 2026, less Libraries (an Adobe service).
        for w in [
            "Default",
            "Review",
            "Learn",
            "Small Screen",
            "Standard",
            "All Panels",
            "Animation",
            "Essential Graphics",
            "Color",
            "Effects",
            "Minimal",
            "Motion Tracking",
            "Paint",
            "Text",
            "Undocked Panels",
        ] {
            assert!(WORKSPACES.contains(&w), "{w}");
        }
        assert!(!WORKSPACES.contains(&"Libraries"));
        // Layouts differ from Default (except Learn, which is Default plus the Home screen).
        let def = workspace("Default");
        for w in WORKSPACES.iter().filter(|w| !matches!(**w, "Default" | "Learn")) {
            assert_ne!(workspace(w), def, "{w} falls back to Default");
        }
        assert!(workspace("Essential Graphics").contains(PanelKind::Properties));
        assert!(workspace("Color").contains(PanelKind::EffectControls));
        assert!(!workspace_floating("Undocked Panels").is_empty());
        // Every built-in workspace is in Window ▸ Workspace.
        let menu: Vec<String> = effectcraft_engine::menus::entries()
            .into_iter()
            .filter(|(_, e)| e.command == "window.workspace")
            .filter_map(|(_, e)| e.params.get("name").and_then(|v| v.as_str()).map(str::to_string))
            .collect();
        for w in WORKSPACES {
            assert!(menu.iter().any(|m| m == w), "{w} missing from Window > Workspace");
        }
    }

    #[test]
    fn short_splits_lay_out_without_panicking() {
        // #306: a split 0 < avail < 40 pt tall made `f32::clamp` panic (its bounds crossed).
        for avail in [0.0, 5.0, 19.0, 20.0, 30.0, 39.0, 40.0, 41.0, -10.0, f32::NAN, f32::INFINITY] {
            for size in [SplitSize::Ratio(0.5), SplitSize::Ratio(f32::NAN), SplitSize::FixedA(300.0), SplitSize::FixedB(300.0), SplitSize::FixedA(-5.0)] {
                let f = split_first(size, avail);
                assert!(f.is_finite() && f >= 0.0, "{size:?} {avail}: {f}");
                if avail.is_finite() && avail > 0.0 {
                    assert!(f <= avail, "{size:?} {avail}: {f}");
                }
            }
        }
        assert_eq!(split_first(SplitSize::FixedA(300.0), 30.0), 20.0);
        assert_eq!(split_first(SplitSize::Ratio(0.5), 200.0), 100.0);
        assert_eq!(clamp_ordered(5.0, 40.0, -4.0), 40.0);
        // Every workspace, laid out in rects too short and too narrow for its minimums.
        let ctx = egui::Context::default();
        let t = Tokens::for_kind(crate::theme::ThemeKind::Dark);
        for w in WORKSPACES {
            for (wd, ht) in [(30.0, 30.0), (800.0, 36.0), (800.0, 45.0), (36.0, 600.0), (1.0, 1.0), (0.0, 0.0)] {
                let mut node = workspace(w);
                let mut frame = ctx.run_ui(egui::RawInput::default(), |ui| {
                    let mut out = vec![];
                    let mut reg = crate::automation::Registry::default();
                    layout(ui, &mut node, Rect::from_min_size(pos2(0.0, 0.0), vec2(wd, ht)), &t, "", &mut out, &mut reg);
                    assert!(!out.is_empty(), "{w}");
                });
                frame.textures_delta.clear();
            }
        }
    }

    #[test]
    fn drop_zone_math() {
        let r = Rect::from_min_size(pos2(100.0, 100.0), vec2(400.0, 300.0));
        let tab = 28.0;
        assert_eq!(drop_zone(r, tab, pos2(300.0, 110.0)), Zone::Center, "tab strip");
        assert_eq!(drop_zone(r, tab, r.center()), Zone::Center);
        assert_eq!(drop_zone(r, tab, pos2(120.0, 250.0)), Zone::Left);
        assert_eq!(drop_zone(r, tab, pos2(490.0, 250.0)), Zone::Right);
        assert_eq!(drop_zone(r, tab, pos2(300.0, 140.0)), Zone::Top);
        assert_eq!(drop_zone(r, tab, pos2(300.0, 390.0)), Zone::Bottom);
        // Corners go to the nearer edge.
        assert_eq!(drop_zone(r, tab, pos2(105.0, 395.0)), Zone::Left);
        assert_eq!(zone_rect(r, Zone::Right), Rect::from_min_max(pos2(300.0, 100.0), r.max));
        assert_eq!(zone_rect(r, Zone::Top).height(), 150.0);
        assert_eq!(zone_rect(r, Zone::Center), r);
    }

    #[test]
    fn dock_panel_splits_and_inserts_tabs() {
        use PanelKind::*;
        let mut d = workspace("Standard");
        let n = d.panel_count();
        // Tab next to an anchor.
        assert!(d.dock_panel(Info, Timeline, Zone::Center));
        assert_eq!(d.panel_count(), n);
        let p = d.path_of(Timeline).unwrap();
        assert_eq!(d.path_of(Info).unwrap(), p);
        assert!(d.is_visible(Info));
        // Split to the right of the Composition group: a new single-tab group beside it.
        assert!(d.dock_panel(Info, Composition, Zone::Right));
        let comp_path = d.path_of(Composition).unwrap();
        let info_path = d.path_of(Info).unwrap();
        assert_eq!(comp_path.len(), info_path.len());
        assert!(comp_path.ends_with('a') && info_path.ends_with('b'));
        assert!(d.is_visible(Info));
        // Top: the new group comes first in a vertical split.
        assert!(d.dock_panel(Audio, Timeline, Zone::Top));
        assert!(d.path_of(Audio).unwrap().ends_with('a'));
        // Dropping a panel on itself or an undocked anchor changes nothing.
        let before = d.clone();
        assert!(!d.dock_panel(Audio, Audio, Zone::Left));
        assert!(!d.dock_panel(Audio, Tracker, Zone::Left));
        assert_eq!(d, before);
        // Into a stack: a tab of the anchor's frame (#302).
        let mut s = workspace("Default");
        let props = s.path_of(Properties).unwrap();
        assert!(s.dock_panel(Tracker, Properties, Zone::Center));
        assert_eq!(s.path_of(Tracker), Some(props.clone()));
        assert!(s.is_visible(Tracker) && !s.is_visible(Properties));
        assert!(s.activate(Properties) && s.is_visible(Properties));
        // Top / Bottom: a frame of its own above / below the anchor's, not a split column.
        assert!(s.dock_panel(Info, Properties, Zone::Bottom));
        let below = s.path_of(Info).unwrap();
        assert_ne!(below, props);
        assert_eq!(s.path_of(Properties), Some(props.clone()));
        assert!(s.dock_panel(Info, Properties, Zone::Top));
        assert_eq!(s.path_of(Info), Some(props.clone()), "above Properties: its frame's index");
        // Closing a tab keeps the frame; closing the frame's last tab removes it.
        s.close(Tracker);
        assert!(s.contains(Properties) && !s.contains(Tracker));
        // A tab dragged onto a stacked frame's tab strip joins that frame.
        let mut t = workspace("Default");
        assert!(t.insert_tab(Info, Preview, None));
        assert_eq!(t.path_of(Info), t.path_of(Preview));
        // Moving the only panel of a group collapses its split.
        let mut m = hsplit(SplitSize::Ratio(0.5), tabs(&[Project], 0), tabs(&[Composition], 0));
        assert!(m.dock_panel(Project, Composition, Zone::Center));
        assert_eq!(m, tabs(&[Composition, Project], 1));
    }

    /// #302: workspaces saved when each stacked frame held one `panel` still load.
    #[test]
    fn old_stack_entries_load() {
        let e: StackEntry = serde_json::from_str(r#"{"panel":"Preview","open":true,"height":46.0}"#).unwrap();
        assert_eq!(e, StackEntry::new(PanelKind::Preview, true, Some(46.0)));
        let s = serde_json::to_string(&workspace("Default")).unwrap();
        assert_eq!(serde_json::from_str::<DockNode>(&s).unwrap(), workspace("Default"));
    }

    #[test]
    fn floating_layout_round_trips() {
        use PanelKind::*;
        let mut l = Layout { root: workspace("Standard"), floating: vec![] };
        assert!(l.float(Info, [200.0, 150.0, 320.0, 240.0]));
        assert!(!l.root.contains(Info) && l.contains(Info));
        // Tab another panel into the floating group, then dock it back.
        assert!(l.dock(Audio, Info, Zone::Center));
        assert_eq!(l.floating[0].panels, [Info, Audio]);
        assert!(!l.dock(Audio, Info, Zone::Left), "floating groups only take tabs");
        assert!(l.dock(Info, Timeline, Zone::Bottom));
        assert_eq!(l.floating[0].panels, [Audio]);
        assert!(l.root.contains(Info));
        let s = serde_json::to_string(&l).unwrap();
        let back: Layout = serde_json::from_str(&s).unwrap();
        assert_eq!(back, l);
        // A workspace saved before floating panels existed still loads.
        let old: Layout = serde_json::from_str(&format!("{{\"root\": {}}}", serde_json::to_string(&l.root).unwrap())).unwrap();
        assert!(old.floating.is_empty());
        // The last docked panel can't float.
        let mut one = Layout { root: tabs(&[Timeline], 0), floating: vec![] };
        assert!(!one.float(Timeline, [0.0; 4]));
        assert!(l.unfloat(Audio) && l.floating.is_empty());
    }

    #[test]
    fn close_and_open() {
        let mut d = workspace("Default");
        d.close(PanelKind::Paragraph);
        assert!(!d.contains(PanelKind::Paragraph));
        d.open_near(PanelKind::Tracker, PanelKind::EffectsPresets);
        assert!(d.is_visible(PanelKind::Tracker));
        let s = serde_json::to_string(&d).unwrap();
        let back: DockNode = serde_json::from_str(&s).unwrap();
        assert_eq!(back, d);
        assert_eq!(PanelKind::from_name("effects & presets"), Some(PanelKind::EffectsPresets));
    }

    /// Ported from #630 (Ni-zav): the reporter's reproduction on the Minimal workspace.
    #[test]
    fn window_panels_reopen_after_last_panel_is_closed() {
        use PanelKind::*;
        for reopen in [Composition, Timeline, Project] {
            let mut d = workspace("Minimal");
            d.close(Composition);
            d.close(Timeline);
            assert_eq!(d.panel_count(), 0);
            d.open_near(reopen, EffectsPresets);
            assert_eq!(d.panel_count(), 1);
            assert!(d.is_visible(reopen), "{reopen:?} must be visible");
        }
        let mut d = tabs(&[Audio], 0);
        d.open_near(History, Project);
        assert_eq!(d, tabs(&[Audio, History], 1));
        let mut d = workspace("Minimal");
        d.open_near(EffectsPresets, Timeline);
        assert_eq!(d.path_of(EffectsPresets), d.path_of(Timeline));
    }

    #[test]
    fn closing_earlier_inactive_tab_keeps_the_shown_panel() {
        use PanelKind::*;
        let mut d = tabs(&[Properties, Align, EffectsPresets], 1);
        d.close(Properties);
        assert!(d.is_visible(Align), "closing an inactive tab keeps the shown panel");
        assert!(!d.is_visible(EffectsPresets));
        assert_eq!(d.panel_count(), 2);
    }

    #[test]
    fn closing_active_tab_keeps_existing_neighbor_choice() {
        use PanelKind::*;
        for (active, closed, shown) in [(0, Properties, Align), (1, Align, EffectsPresets), (2, EffectsPresets, Align)] {
            let mut d = tabs(&[Properties, Align, EffectsPresets], active);
            d.close(closed);
            assert!(d.is_visible(shown), "active {active}: {closed:?} -> {shown:?}");
        }
    }

    #[test]
    fn close_normalizes_invalid_active_and_collapses_empty_splits() {
        use PanelKind::*;
        let mut d = tabs(&[Properties, Align, EffectsPresets], usize::MAX);
        d.close(History);
        assert!(d.is_visible(EffectsPresets));
        d.close(Properties);
        assert!(d.is_visible(EffectsPresets));
        d.close(EffectsPresets);
        assert!(d.is_visible(Align));
        d.close(Align);
        assert_eq!(d, tabs(&[], 0));
        let mut d = DockNode::Split { vertical: true, size: SplitSize::Ratio(0.5), a: Box::new(tabs(&[Properties], 0)), b: Box::new(tabs(&[Align], 0)) };
        d.close(Properties);
        assert_eq!(d, tabs(&[Align], 0));
        d.close(Align);
        assert_eq!(d, tabs(&[], 0));
    }

    #[test]
    fn removing_earlier_inactive_floating_tab_keeps_the_shown_panel() {
        use PanelKind::*;
        let mut layout = Layout {
            root: tabs(&[Composition], 0),
            floating: vec![Floating { panels: vec![Properties, Align, EffectsPresets], active: 1, rect: [0.0, 0.0, 300.0, 200.0] }],
        };
        assert!(layout.unfloat(Properties));
        let f = &layout.floating[0];
        assert_eq!(f.panels.get(f.active), Some(&Align));
        assert!(layout.root.is_visible(Composition));
    }

    #[test]
    fn floating_removal_keeps_active_neighbor_and_handles_invalid_index() {
        use PanelKind::*;
        for (active, closed, shown) in
            [(0, Properties, Align), (1, Align, EffectsPresets), (2, EffectsPresets, Align), (usize::MAX, Properties, EffectsPresets)]
        {
            let mut layout = Layout {
                root: tabs(&[Composition], 0),
                floating: vec![Floating { panels: vec![Properties, Align, EffectsPresets], active, rect: [0.0, 0.0, 300.0, 200.0] }],
            };
            assert!(layout.unfloat(closed));
            let f = &layout.floating[0];
            assert_eq!(f.panels.get(f.active), Some(&shown));
            for p in [Properties, Align, EffectsPresets] {
                layout.unfloat(p);
            }
            assert!(layout.floating.is_empty());
            assert!(!layout.unfloat(History));
        }
    }
}