use {
    crate::{
        backend::{AXIS_120, AxisSource, ButtonState, ScrollAxis},
        cursor::KnownCursor,
        fixed::Fixed,
        ifs::{
            ipc,
            ipc::wl_data_source::WlDataSource,
            wl_seat::{
                BTN_LEFT, BTN_RIGHT, CHANGE_CURSOR_MOVED, CHANGE_TREE, Dnd, DroppedDnd,
                NodeSeatState, WlSeatError, WlSeatGlobal, wl_pointer::PendingScroll,
            },
            wl_surface::{
                WlSurface,
                dnd_icon::DndIcon,
                xdg_surface::{xdg_popup::XdgPopup, xdg_toplevel::ResizeEdges},
            },
            xdg_toplevel_drag_v1::XdgToplevelDragV1,
        },
        rect::Rect,
        time::Time,
        tree::{
            ContainerNode, ContainerSplit, ContainingNode, FindTreeUsecase, FoundNode, Node,
            PlaceholderNode, TddType, ToplevelNode, WorkspaceDragDestination, WorkspaceNode,
            WsMoveConfig, move_ws_to_output, toplevel_set_workspace,
        },
        utils::{bitflags::BitflagsExt, clonecell::CloneCell, smallmap::SmallMap},
    },
    linearize::LinearizeExt,
    std::{
        cell::Cell,
        rc::{Rc, Weak},
    },
};

pub struct PointerOwnerHolder {
    default: Rc<SimplePointerOwner<DefaultPointerUsecase>>,
    owner: CloneCell<Rc<dyn PointerOwner>>,
    pending_scroll: PendingScroll,
}

pub trait ToplevelSelector: 'static {
    fn set(&self, toplevel: Rc<dyn ToplevelNode>);
}

pub trait WorkspaceSelector: 'static {
    fn set(&self, ws: Rc<WorkspaceNode>);
}

impl Default for PointerOwnerHolder {
    fn default() -> Self {
        let default = Rc::new(SimplePointerOwner {
            usecase: DefaultPointerUsecase,
        });
        Self {
            default: default.clone(),
            owner: CloneCell::new(default.clone()),
            pending_scroll: Default::default(),
        }
    }
}

impl PointerOwnerHolder {
    pub fn button(&self, seat: &Rc<WlSeatGlobal>, time_usec: u64, button: u32, state: ButtonState) {
        self.owner.get().button(seat, time_usec, button, state)
    }

    pub fn axis_source(&self, axis_source: AxisSource) {
        self.pending_scroll.source.set(Some(axis_source as _));
    }

    pub fn axis_120(&self, delta: i32, axis: ScrollAxis, inverted: bool) {
        self.pending_scroll.v120[axis as usize].set(Some(delta));
        self.pending_scroll.inverted[axis as usize].set(inverted);
    }

    pub fn axis_px(&self, delta: Fixed, axis: ScrollAxis, inverted: bool) {
        self.pending_scroll.px[axis as usize].set(Some(delta));
        self.pending_scroll.inverted[axis as usize].set(inverted);
    }

    pub fn axis_stop(&self, axis: ScrollAxis) {
        self.pending_scroll.stop[axis as usize].set(true);
    }

    pub fn frame(&self, px_per_scroll_wheel: f64, seat: &Rc<WlSeatGlobal>, time_usec: u64) {
        self.pending_scroll.time_usec.set(time_usec);
        let pending = self.pending_scroll.take();
        for axis in ScrollAxis::variants() {
            let axis = axis as usize;
            if let Some(dist) = pending.v120[axis].get() {
                let px = (dist as f64 / AXIS_120 as f64) * px_per_scroll_wheel;
                pending.px[axis].set(Some(Fixed::from_f64(px)));
            }
        }
        seat.for_each_ei_seat(|ei_seat| {
            ei_seat.handle_pending_scroll(time_usec, &pending);
        });
        seat.state.for_each_seat_tester(|t| {
            t.send_axis(seat.id, time_usec, &pending);
        });
        if let Some(node) = self.owner.get().axis_node(seat) {
            node.node_on_axis_event(seat, &pending);
        }
    }

    pub fn relative_motion(
        &self,
        seat: &Rc<WlSeatGlobal>,
        time_usec: u64,
        dx: Fixed,
        dy: Fixed,
        dx_unaccelerated: Fixed,
        dy_unaccelerated: Fixed,
    ) {
        if let Some(n) = self.owner.get().axis_node(seat) {
            n.node_on_pointer_relative_motion(
                seat,
                time_usec,
                dx,
                dy,
                dx_unaccelerated,
                dy_unaccelerated,
            );
        }
    }

    pub fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) {
        self.owner.get().apply_changes(seat)
    }

    pub fn start_drag(
        &self,
        seat: &Rc<WlSeatGlobal>,
        origin: &Rc<WlSurface>,
        source: Option<Rc<WlDataSource>>,
        icon: Option<Rc<DndIcon>>,
        serial: u64,
    ) -> Result<(), WlSeatError> {
        self.owner
            .get()
            .start_drag(seat, origin, source, icon, serial)
    }

    pub fn cancel_dnd(&self, seat: &Rc<WlSeatGlobal>) {
        self.owner.get().cancel_dnd(seat)
    }

    pub fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>) {
        self.owner.get().revert_to_default(seat)
    }

    pub fn grab_node_removed(&self, seat: &Rc<WlSeatGlobal>) {
        self.owner.get().grab_node_removed(seat);
    }

    pub fn dnd_target_removed(&self, seat: &Rc<WlSeatGlobal>) {
        self.owner.get().dnd_target_removed(seat);
    }

    pub fn dnd_icon(&self) -> Option<Rc<DndIcon>> {
        self.owner.get().dnd_icon()
    }

    pub fn toplevel_drag(&self) -> Option<Rc<XdgToplevelDragV1>> {
        self.owner.get().toplevel_drag()
    }

    pub fn remove_dnd_icon(&self) {
        self.owner.get().remove_dnd_icon()
    }

    pub fn clear(&self) {
        self.owner.set(self.default.clone());
    }

    fn set_default_pointer_owner(&self, seat: &Rc<WlSeatGlobal>) {
        seat.pointer_owner.owner.set(self.default.clone());
        seat.changes.or_assign(CHANGE_CURSOR_MOVED);
    }

    fn select_element(&self, seat: &Rc<WlSeatGlobal>, usecase: impl SimplePointerOwnerUsecase) {
        self.revert_to_default(seat);
        if let Some(node) = seat.pointer_stack.borrow().last() {
            usecase.node_focus(seat, node);
        }
        self.owner.set(Rc::new(SimplePointerOwner { usecase }));
        seat.trigger_tree_changed(false);
    }

    pub fn select_toplevel(&self, seat: &Rc<WlSeatGlobal>, selector: impl ToplevelSelector) {
        let usecase = Rc::new(SelectToplevelUsecase {
            seat: Rc::downgrade(seat),
            selector,
            latest: Default::default(),
        });
        self.select_element(seat, usecase)
    }

    pub fn select_workspace(&self, seat: &Rc<WlSeatGlobal>, selector: impl WorkspaceSelector) {
        let usecase = Rc::new(SelectWorkspaceUsecase {
            seat: Rc::downgrade(seat),
            selector,
            latest: Default::default(),
        });
        self.select_element(seat, usecase)
    }

    pub fn set_window_management_enabled(&self, seat: &Rc<WlSeatGlobal>, enabled: bool) {
        let owner = self.owner.get();
        if enabled {
            owner.enable_window_management(seat);
        } else {
            owner.disable_window_management(seat);
        }
    }

    pub fn start_tile_drag(&self, seat: &Rc<WlSeatGlobal>, tl: &Rc<dyn ToplevelNode>) {
        self.owner.get().start_tile_drag(seat, tl);
    }

    pub fn start_workspace_drag(&self, seat: &Rc<WlSeatGlobal>, ws: &Rc<WorkspaceNode>) {
        self.owner.get().start_workspace_drag(seat, ws);
    }

    pub fn start_popup_move(&self, seat: &Rc<WlSeatGlobal>, popup: &Rc<XdgPopup>, serial: u64) {
        self.owner.get().start_popup_move(seat, popup, serial);
    }

    pub fn start_popup_resize(
        &self,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        edges: ResizeEdges,
        serial: u64,
    ) {
        self.owner
            .get()
            .start_popup_resize(seat, popup, edges, serial);
    }
}

trait PointerOwner {
    fn button(&self, seat: &Rc<WlSeatGlobal>, time_usec: u64, button: u32, state: ButtonState);
    fn axis_node(&self, seat: &Rc<WlSeatGlobal>) -> Option<Rc<dyn Node>> {
        let _ = seat;
        None
    }
    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>);
    fn start_drag(
        &self,
        seat: &Rc<WlSeatGlobal>,
        origin: &Rc<WlSurface>,
        source: Option<Rc<WlDataSource>>,
        icon: Option<Rc<DndIcon>>,
        serial: u64,
    ) -> Result<(), WlSeatError> {
        let _ = origin;
        let _ = icon;
        let _ = serial;
        if let Some(src) = source {
            src.send_cancelled(seat);
        }
        Ok(())
    }
    fn cancel_dnd(&self, seat: &Rc<WlSeatGlobal>) {
        seat.dropped_dnd.borrow_mut().take();
    }
    fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>);
    fn grab_node_removed(&self, seat: &Rc<WlSeatGlobal>) {
        self.revert_to_default(seat);
    }
    fn dnd_target_removed(&self, seat: &Rc<WlSeatGlobal>) {
        self.cancel_dnd(seat);
    }
    fn dnd_icon(&self) -> Option<Rc<DndIcon>> {
        None
    }
    fn toplevel_drag(&self) -> Option<Rc<XdgToplevelDragV1>> {
        None
    }
    fn remove_dnd_icon(&self) {
        // nothing
    }
    fn enable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        let _ = seat;
    }
    fn disable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        let _ = seat;
    }
    fn start_tile_drag(&self, seat: &Rc<WlSeatGlobal>, tl: &Rc<dyn ToplevelNode>) {
        let _ = seat;
        let _ = tl;
    }

    fn start_workspace_drag(&self, seat: &Rc<WlSeatGlobal>, ws: &Rc<WorkspaceNode>) {
        let _ = seat;
        let _ = ws;
    }

    fn start_popup_move(&self, seat: &Rc<WlSeatGlobal>, popup: &Rc<XdgPopup>, serial: u64) {
        let _ = seat;
        let _ = popup;
        let _ = serial;
    }

    fn start_popup_resize(
        &self,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        edges: ResizeEdges,
        serial: u64,
    ) {
        let _ = seat;
        let _ = popup;
        let _ = edges;
        let _ = serial;
    }
}

struct SimplePointerOwner<T> {
    usecase: T,
}

struct SimpleGrabPointerOwner<T> {
    usecase: T,
    buttons: SmallMap<u32, u64, 1>,
    node: Rc<dyn Node>,
    serial: u64,
}

struct DndPointerOwner {
    button: u32,
    dnd: Dnd,
    target: CloneCell<Rc<dyn Node>>,
    icon: CloneCell<Option<Rc<DndIcon>>>,
    pos_x: Cell<Fixed>,
    pos_y: Cell<Fixed>,
}

#[derive(Copy, Clone)]
struct DefaultPointerUsecase;

struct SelectToplevelUsecase<S: ?Sized> {
    seat: Weak<WlSeatGlobal>,
    latest: CloneCell<Option<Rc<dyn ToplevelNode>>>,
    selector: S,
}

struct SelectWorkspaceUsecase<S: ?Sized> {
    seat: Weak<WlSeatGlobal>,
    latest: CloneCell<Option<Rc<WorkspaceNode>>>,
    selector: S,
}

#[derive(Copy, Clone)]
struct WindowManagementUsecase;

impl<T: SimplePointerOwnerUsecase> PointerOwner for SimplePointerOwner<T> {
    fn button(&self, seat: &Rc<WlSeatGlobal>, time_usec: u64, button: u32, state: ButtonState) {
        if state != ButtonState::Pressed {
            return;
        }
        let pn = match seat.pointer_node() {
            Some(n) => n,
            _ => return,
        };
        if self.usecase.default_button(self, seat, button, &pn) {
            return;
        }
        let serial = seat.state.next_serial(pn.node_client().as_deref());
        seat.pointer_owner
            .owner
            .set(Rc::new(SimpleGrabPointerOwner {
                usecase: self.usecase.clone(),
                buttons: SmallMap::new_with(button, serial),
                node: pn.clone(),
                serial,
            }));
        pn.node_restack();
        pn.node_seat_state().add_pointer_grab(seat);
        seat.handle_node_button(pn, time_usec, button, state, serial);
    }

    fn axis_node(&self, seat: &Rc<WlSeatGlobal>) -> Option<Rc<dyn Node>> {
        seat.pointer_node()
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) {
        let (x, y) = seat.pointer_cursor.position();
        let mut found_tree = seat.found_tree.borrow_mut();
        let mut stack = seat.pointer_stack.borrow_mut();
        let x_int = x.round_down();
        let y_int = y.round_down();
        found_tree.push(FoundNode {
            node: seat.state.root.clone(),
            x: x_int,
            y: y_int,
        });
        seat.state
            .root
            .node_find_tree_at(x_int, y_int, &mut found_tree, T::FIND_TREE_USECASE);
        let mut divergence = found_tree.len().min(stack.len());
        for (i, (found, stack)) in found_tree.iter().zip(stack.iter()).enumerate() {
            if found.node.node_id() != stack.node_id() {
                divergence = i;
                break;
            }
        }
        let psm = seat.pointer_stack_modified.replace(false);
        if !psm && (stack.len(), found_tree.len()) == (divergence, divergence) {
            if let Some(node) = found_tree.last() {
                node.node.clone().node_on_pointer_motion(
                    seat,
                    x.apply_fract(node.x),
                    y.apply_fract(node.y),
                );
            }
        } else {
            if let Some(last) = stack.last() {
                last.node_on_pointer_unfocus(seat);
            }
            for old in stack.drain(divergence..).rev() {
                old.node_on_leave(seat);
                old.node_seat_state().leave(seat);
            }
            if found_tree.len() == divergence {
                if let Some(node) = found_tree.last() {
                    node.node.clone().node_on_pointer_motion(
                        seat,
                        x.apply_fract(node.x),
                        y.apply_fract(node.y),
                    );
                }
            } else {
                for new in found_tree.drain(divergence..) {
                    new.node.node_seat_state().enter(seat);
                    new.node.clone().node_on_pointer_enter(
                        seat,
                        x.apply_fract(new.x),
                        y.apply_fract(new.y),
                    );
                    stack.push(new.node);
                }
            }
            if let Some(node) = stack.last() {
                node.node_on_pointer_focus(seat);
                self.usecase.node_focus(seat, node);
            }
        }
        found_tree.clear();
    }

    fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>) {
        if !T::IS_DEFAULT {
            seat.pointer_owner.set_default_pointer_owner(seat);
            seat.trigger_tree_changed(false);
        }
    }

    fn enable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        if !T::IS_DEFAULT {
            return;
        }
        seat.pointer_owner.owner.set(Rc::new(SimplePointerOwner {
            usecase: WindowManagementUsecase,
        }));
        seat.changes.or_assign(CHANGE_TREE);
        seat.apply_changes();
    }

    fn disable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        self.usecase.disable_window_management(seat);
    }
}

impl<T: SimplePointerOwnerUsecase> SimpleGrabPointerOwner<T> {
    fn find_button(&self, serial: u64) -> Option<u32> {
        for (button, s) in self.buttons.iter() {
            if s == serial {
                return Some(button);
            }
        }
        None
    }
}

impl<T: SimplePointerOwnerUsecase> PointerOwner for SimpleGrabPointerOwner<T> {
    fn button(&self, seat: &Rc<WlSeatGlobal>, time_usec: u64, button: u32, state: ButtonState) {
        let serial = seat.state.next_serial(self.node.node_client().as_deref());
        match state {
            ButtonState::Released => {
                if self.buttons.remove(&button).is_none() {
                    return;
                }
                if self.buttons.is_empty() {
                    self.node.node_seat_state().remove_pointer_grab(seat);
                    // log::info!("button");
                    self.usecase.release_grab(seat);
                    seat.tree_changed.trigger();
                }
            }
            ButtonState::Pressed => {
                if self.buttons.insert(button, serial).is_some() {
                    return;
                }
            }
        }
        seat.handle_node_button(self.node.clone(), time_usec, button, state, serial);
    }

    fn axis_node(&self, _seat: &Rc<WlSeatGlobal>) -> Option<Rc<dyn Node>> {
        Some(self.node.clone())
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) {
        let (x, y) = seat.pointer_cursor.position();
        let pos = self.node.node_absolute_position();
        let (x_int, y_int) = pos.translate(x.round_down(), y.round_down());
        // log::info!("apply_changes");
        self.node
            .clone()
            .node_on_pointer_motion(seat, x.apply_fract(x_int), y.apply_fract(y_int));
    }

    fn start_drag(
        &self,
        seat: &Rc<WlSeatGlobal>,
        origin: &Rc<WlSurface>,
        src: Option<Rc<WlDataSource>>,
        icon: Option<Rc<DndIcon>>,
        serial: u64,
    ) -> Result<(), WlSeatError> {
        self.usecase
            .start_drag(self, seat, origin, src, icon, serial)
    }

    fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>) {
        let serial = seat.state.next_serial(self.node.node_client().as_deref());
        let time_usec = Time::now_unchecked().usec();
        for (button, _) in &self.buttons {
            seat.handle_node_button(
                self.node.clone(),
                time_usec,
                button,
                ButtonState::Released,
                serial,
            );
        }
        self.node.node_seat_state().remove_pointer_grab(seat);
        seat.pointer_owner.set_default_pointer_owner(seat);
    }

    fn start_tile_drag(&self, seat: &Rc<WlSeatGlobal>, tl: &Rc<dyn ToplevelNode>) {
        self.usecase.start_tile_drag(self, seat, tl);
    }

    fn start_workspace_drag(&self, seat: &Rc<WlSeatGlobal>, ws: &Rc<WorkspaceNode>) {
        self.usecase.start_workspace_drag(self, seat, ws);
    }

    fn start_popup_move(&self, seat: &Rc<WlSeatGlobal>, popup: &Rc<XdgPopup>, serial: u64) {
        let Some(button) = self.find_button(serial) else {
            return;
        };
        self.usecase.start_popup_move(self, seat, popup, button);
    }

    fn start_popup_resize(
        &self,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        edges: ResizeEdges,
        serial: u64,
    ) {
        let Some(button) = self.find_button(serial) else {
            return;
        };
        self.usecase
            .start_popup_resize(self, seat, popup, edges, button);
    }
}

impl PointerOwner for DndPointerOwner {
    fn button(&self, seat: &Rc<WlSeatGlobal>, _time_usec: u64, button: u32, state: ButtonState) {
        if button != self.button || state != ButtonState::Released {
            return;
        }
        let target = self.target.get();
        target.node_on_dnd_drop(&self.dnd);
        if let Some(src) = &self.dnd.src {
            src.on_drop();
        }
        let should_drop = match &self.dnd.src {
            None => true,
            Some(s) => s.can_drop(),
        };
        if should_drop {
            *seat.dropped_dnd.borrow_mut() = Some(DroppedDnd {
                dnd: self.dnd.clone(),
            });
        }
        target.node_on_dnd_leave(&self.dnd);
        target.node_seat_state().remove_dnd_target(seat);
        if !should_drop && let Some(src) = &self.dnd.src {
            ipc::detach_seat(&**src, seat);
        }
        if let Some(icon) = self.icon.get() {
            icon.disable();
        }
        seat.pointer_owner.set_default_pointer_owner(seat);
        seat.tree_changed.trigger();
        if let Some(src) = &self.dnd.src {
            src.finish_toplevel_drag(seat);
        }
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) {
        let (x, y) = seat.pointer_cursor.position();
        let FoundNode {
            node,
            x: x_int,
            y: y_int,
        } = seat.state.node_at(x.round_down(), y.round_down());
        let (x, y) = (x.apply_fract(x_int), y.apply_fract(y_int));
        let mut target = self.target.get();
        if node.node_id() != target.node_id() {
            target.node_on_dnd_leave(&self.dnd);
            target.node_seat_state().remove_dnd_target(seat);
            target = node;
            target.node_on_dnd_enter(
                &self.dnd,
                x,
                y,
                seat.state.next_serial(target.node_client().as_deref()),
            );
            target.node_seat_state().add_dnd_target(seat);
            self.target.set(target);
        } else if (self.pos_x.get(), self.pos_y.get()) != (x, y) {
            node.node_on_dnd_motion(&self.dnd, seat.pos_time_usec.get(), x, y);
        }
        self.pos_x.set(x);
        self.pos_y.set(y);
    }

    fn cancel_dnd(&self, seat: &Rc<WlSeatGlobal>) {
        let target = self.target.get();
        target.node_on_dnd_leave(&self.dnd);
        target.node_seat_state().remove_dnd_target(seat);
        if let Some(src) = &self.dnd.src {
            ipc::detach_seat(&**src, seat);
        }
        if let Some(icon) = self.icon.get() {
            icon.disable();
        }
        seat.pointer_owner.set_default_pointer_owner(seat);
        seat.tree_changed.trigger();
    }

    fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>) {
        self.cancel_dnd(seat)
    }

    fn dnd_target_removed(&self, seat: &Rc<WlSeatGlobal>) {
        self.target.get().node_on_dnd_leave(&self.dnd);
        self.target.set(seat.state.root.clone());
        seat.state.tree_changed();
    }

    fn dnd_icon(&self) -> Option<Rc<DndIcon>> {
        self.icon.get()
    }

    fn toplevel_drag(&self) -> Option<Rc<XdgToplevelDragV1>> {
        if let Some(src) = &self.dnd.src {
            src.toplevel_drag.get()
        } else {
            None
        }
    }

    fn remove_dnd_icon(&self) {
        self.icon.set(None);
    }
}

trait SimplePointerOwnerUsecase: Sized + Clone + 'static {
    const FIND_TREE_USECASE: FindTreeUsecase;
    const IS_DEFAULT: bool;

    fn default_button(
        &self,
        spo: &SimplePointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        button: u32,
        pn: &Rc<dyn Node>,
    ) -> bool;

    fn start_drag(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        origin: &Rc<WlSurface>,
        src: Option<Rc<WlDataSource>>,
        icon: Option<Rc<DndIcon>>,
        serial: u64,
    ) -> Result<(), WlSeatError> {
        let _ = grab;
        let _ = origin;
        let _ = icon;
        let _ = serial;
        if let Some(src) = src {
            src.send_cancelled(seat);
        }
        Ok(())
    }

    fn release_grab(&self, seat: &Rc<WlSeatGlobal>);

    fn node_focus(&self, seat: &Rc<WlSeatGlobal>, node: &Rc<dyn Node>) {
        let _ = seat;
        let _ = node;
    }

    fn disable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        let _ = seat;
    }

    fn start_tile_drag(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        tl: &Rc<dyn ToplevelNode>,
    ) {
        let _ = grab;
        let _ = seat;
        let _ = tl;
    }

    fn start_workspace_drag(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        ws: &Rc<WorkspaceNode>,
    ) {
        let _ = grab;
        let _ = seat;
        let _ = ws;
    }

    fn start_popup_move(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        button: u32,
    ) {
        let _ = grab;
        let _ = seat;
        let _ = popup;
        let _ = button;
    }

    fn start_popup_resize(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        edges: ResizeEdges,
        button: u32,
    ) {
        let _ = grab;
        let _ = seat;
        let _ = popup;
        let _ = edges;
        let _ = button;
    }
}

impl DefaultPointerUsecase {
    fn prepare_new_usecase(&self, grab: &SimpleGrabPointerOwner<Self>, seat: &Rc<WlSeatGlobal>) {
        {
            let mut stack = seat.pointer_stack.borrow_mut();
            for node in stack.drain(1..).rev() {
                node.node_on_leave(seat);
                node.node_seat_state().leave(seat);
            }
        }
        grab.node.node_seat_state().remove_pointer_grab(seat);
    }

    fn start_ui_drag<T: UiDragUsecase>(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        usecase: T,
    ) {
        self.prepare_new_usecase(grab, seat);
        usecase.node_seat_state().add_ui_drag(seat);
        let pointer_owner = Rc::new(UiDragPointerOwner { usecase });
        seat.pointer_owner.owner.set(pointer_owner.clone());
        pointer_owner.apply_changes(seat);
    }

    fn start_popup_usecase<U: PopupPointerOwnerUsecase>(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        button: u32,
        usecase: U,
    ) {
        self.prepare_new_usecase(grab, seat);
        seat.pointer_owner.owner.set(Rc::new(PopupPointerOwner {
            popup: popup.clone(),
            window_management: false,
            button,
            usecase,
        }));
        popup.node_seat_state().add_pointer_grab(seat);
        popup.add_interactive_move(seat);
    }
}

impl SimplePointerOwnerUsecase for DefaultPointerUsecase {
    const FIND_TREE_USECASE: FindTreeUsecase = FindTreeUsecase::None;
    const IS_DEFAULT: bool = true;

    fn default_button(
        &self,
        _spo: &SimplePointerOwner<Self>,
        _seat: &Rc<WlSeatGlobal>,
        _button: u32,
        _pn: &Rc<dyn Node>,
    ) -> bool {
        false
    }

    fn start_drag(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        origin: &Rc<WlSurface>,
        src: Option<Rc<WlDataSource>>,
        icon: Option<Rc<DndIcon>>,
        serial: u64,
    ) -> Result<(), WlSeatError> {
        let button = match grab.buttons.iter().next() {
            Some((b, _)) => b,
            None => return Ok(()),
        };
        if grab.buttons.len() != 1 {
            return Ok(());
        }
        if serial != grab.serial {
            return Ok(());
        }
        if grab.node.node_id() != origin.node_id {
            return Ok(());
        }
        if let Some(icon) = &icon {
            icon.enable();
        }
        if let Some(new) = &src {
            ipc::attach_seat(&**new, seat, ipc::Role::Dnd)?;
            if let Some(drag) = new.toplevel_drag.get() {
                drag.start_drag();
            }
        }
        *seat.dropped_dnd.borrow_mut() = None;
        let pointer_owner = Rc::new(DndPointerOwner {
            button,
            dnd: Dnd {
                seat: seat.clone(),
                client: origin.client.clone(),
                src,
            },
            target: CloneCell::new(seat.state.root.clone()),
            icon: CloneCell::new(icon),
            pos_x: Cell::new(Fixed::from_int(0)),
            pos_y: Cell::new(Fixed::from_int(0)),
        });
        self.prepare_new_usecase(grab, seat);
        // {
        //     let old = seat.keyboard_node.set(seat.state.root.clone());
        //     old.seat_state().unfocus(seat);
        //     old.unfocus(seat);
        // }
        seat.pointer_owner.owner.set(pointer_owner.clone());
        pointer_owner.apply_changes(seat);
        Ok(())
    }

    fn release_grab(&self, seat: &Rc<WlSeatGlobal>) {
        seat.pointer_owner.set_default_pointer_owner(seat);
    }

    fn start_tile_drag(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        tl: &Rc<dyn ToplevelNode>,
    ) {
        self.start_ui_drag(
            grab,
            seat,
            TileDragUsecase {
                tl: tl.clone(),
                destination: Default::default(),
            },
        );
    }

    fn start_workspace_drag(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        ws: &Rc<WorkspaceNode>,
    ) {
        self.start_ui_drag(
            grab,
            seat,
            WorkspaceDragUsecase {
                ws: ws.clone(),
                destination: Default::default(),
            },
        );
    }

    fn start_popup_move(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        button: u32,
    ) {
        let (x, y) = seat.pointer_cursor.position();
        let (dx, dy) = popup
            .node_absolute_position()
            .translate(x.round_down(), y.round_down());
        self.start_popup_usecase(
            grab,
            seat,
            popup,
            button,
            PopupPointerOwnerMoveUsecase { dx, dy },
        );
        seat.pointer_cursor.set_known(KnownCursor::Move);
    }

    fn start_popup_resize(
        &self,
        grab: &SimpleGrabPointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        popup: &Rc<XdgPopup>,
        edges: ResizeEdges,
        button: u32,
    ) {
        let cursor = match (edges.top, edges.left, edges.right, edges.bottom) {
            (true, false, false, false) => KnownCursor::NsResize,
            (false, false, false, true) => KnownCursor::NsResize,
            (false, true, false, false) => KnownCursor::EwResize,
            (false, false, true, false) => KnownCursor::EwResize,
            (true, true, false, false) => KnownCursor::NwseResize,
            (false, false, true, true) => KnownCursor::NwseResize,
            (false, true, false, true) => KnownCursor::NeswResize,
            (true, false, true, false) => KnownCursor::NeswResize,
            _ => return,
        };
        let (x, y) = seat.pointer_cursor.position();
        let pos = popup.node_absolute_position();
        let (mut dx, mut dy) = pos.translate(x.round_down(), y.round_down());
        if edges.right {
            dx = pos.width() - dx;
        }
        if edges.bottom {
            dy = pos.height() - dy;
        }
        self.start_popup_usecase(
            grab,
            seat,
            popup,
            button,
            PopupPointerOwnerResizeUsecase { edges, dx, dy },
        );
        seat.pointer_cursor.set_known(cursor);
    }
}

trait NodeSelectorUsecase: Sized + 'static {
    const FIND_TREE_USECASE: FindTreeUsecase;

    fn default_button(
        self: &Rc<Self>,
        spo: &SimplePointerOwner<Rc<Self>>,
        seat: &Rc<WlSeatGlobal>,
        button: u32,
        pn: &Rc<dyn Node>,
    ) -> bool;

    fn node_focus(self: &Rc<Self>, seat: &Rc<WlSeatGlobal>, node: &Rc<dyn Node>);
}

impl<U: NodeSelectorUsecase> SimplePointerOwnerUsecase for Rc<U> {
    const FIND_TREE_USECASE: FindTreeUsecase = <U as NodeSelectorUsecase>::FIND_TREE_USECASE;
    const IS_DEFAULT: bool = false;

    fn default_button(
        &self,
        spo: &SimplePointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        button: u32,
        pn: &Rc<dyn Node>,
    ) -> bool {
        <U as NodeSelectorUsecase>::default_button(self, spo, seat, button, pn)
    }

    fn release_grab(&self, seat: &Rc<WlSeatGlobal>) {
        seat.pointer_owner.owner.set(Rc::new(SimplePointerOwner {
            usecase: self.clone(),
        }));
        seat.changes.or_assign(CHANGE_CURSOR_MOVED);
    }

    fn node_focus(&self, seat: &Rc<WlSeatGlobal>, node: &Rc<dyn Node>) {
        <U as NodeSelectorUsecase>::node_focus(self, seat, node)
    }
}

impl<S: ToplevelSelector> NodeSelectorUsecase for SelectToplevelUsecase<S> {
    const FIND_TREE_USECASE: FindTreeUsecase = FindTreeUsecase::SelectToplevel;

    fn default_button(
        self: &Rc<Self>,
        spo: &SimplePointerOwner<Rc<Self>>,
        seat: &Rc<WlSeatGlobal>,
        button: u32,
        pn: &Rc<dyn Node>,
    ) -> bool {
        let Some(tl) = pn.clone().node_into_toplevel() else {
            return false;
        };
        let selected_toplevel =
            button == BTN_RIGHT || (button == BTN_LEFT && !tl.tl_admits_children());
        if !selected_toplevel {
            return false;
        }
        self.selector.set(tl);
        spo.revert_to_default(seat);
        true
    }

    fn node_focus(self: &Rc<Self>, seat: &Rc<WlSeatGlobal>, node: &Rc<dyn Node>) {
        let tl = node.clone().node_into_toplevel();
        if let Some(tl) = &tl {
            tl.tl_data().render_highlight.fetch_add(1);
            if !tl.tl_admits_children() {
                seat.pointer_cursor().set_known(KnownCursor::Pointer);
            }
            seat.state.damage(tl.node_absolute_position());
        }
        if let Some(prev) = self.latest.set(tl) {
            prev.tl_data().render_highlight.fetch_sub(1);
            seat.state.damage(prev.node_absolute_position());
        }
    }
}

impl<S: ?Sized> Drop for SelectToplevelUsecase<S> {
    fn drop(&mut self) {
        if let Some(prev) = self.latest.take() {
            prev.tl_data().render_highlight.fetch_sub(1);
            if let Some(seat) = self.seat.upgrade() {
                seat.state.damage(prev.node_absolute_position());
            }
        }
    }
}

impl<S: WorkspaceSelector> NodeSelectorUsecase for SelectWorkspaceUsecase<S> {
    const FIND_TREE_USECASE: FindTreeUsecase = FindTreeUsecase::SelectWorkspace;

    fn default_button(
        self: &Rc<Self>,
        spo: &SimplePointerOwner<Rc<Self>>,
        seat: &Rc<WlSeatGlobal>,
        _button: u32,
        pn: &Rc<dyn Node>,
    ) -> bool {
        let Some(ws) = pn.clone().node_into_workspace() else {
            return false;
        };
        self.selector.set(ws);
        spo.revert_to_default(seat);
        true
    }

    fn node_focus(self: &Rc<Self>, seat: &Rc<WlSeatGlobal>, node: &Rc<dyn Node>) {
        let ws = node.clone().node_into_workspace();
        if let Some(ws) = &ws {
            ws.render_highlight.fetch_add(1);
            seat.pointer_cursor().set_known(KnownCursor::Pointer);
            seat.state.damage(ws.position.get());
        }
        if let Some(prev) = self.latest.set(ws) {
            prev.render_highlight.fetch_sub(1);
            seat.state.damage(prev.position.get());
        }
    }
}

impl<S: ?Sized> Drop for SelectWorkspaceUsecase<S> {
    fn drop(&mut self) {
        if let Some(prev) = self.latest.take() {
            prev.render_highlight.fetch_sub(1);
            if let Some(seat) = self.seat.upgrade() {
                seat.state.damage(prev.position.get());
            }
        }
    }
}

impl SimplePointerOwnerUsecase for WindowManagementUsecase {
    const FIND_TREE_USECASE: FindTreeUsecase = FindTreeUsecase::SelectToplevelOrPopup;
    const IS_DEFAULT: bool = false;

    fn default_button(
        &self,
        _spo: &SimplePointerOwner<Self>,
        seat: &Rc<WlSeatGlobal>,
        button: u32,
        pn: &Rc<dyn Node>,
    ) -> bool {
        let pos = pn.node_absolute_position();
        let (x, y) = seat.pointer_cursor.position();
        let (x, y) = (x.round_down(), y.round_down());
        let (mut dx, mut dy) = pos.translate(x, y);
        let owner: Rc<dyn PointerOwner> = if button == BTN_LEFT {
            if let Some(tl) = pn.clone().node_into_toplevel() {
                if tl.tl_data().is_root_container() {
                    return false;
                }
                seat.pointer_cursor.set_known(KnownCursor::Move);
                if tl.tl_data().is_fullscreen.get() {
                    Rc::new(ToplevelGrabPointerOwner {
                        tl,
                        usecase: MoveFullscreenToplevelGrabPointerOwner,
                    })
                } else if tl.tl_data().float.is_none() {
                    Rc::new(ToplevelGrabPointerOwner {
                        tl: tl.clone(),
                        usecase: TileDragUsecase {
                            tl,
                            destination: Default::default(),
                        },
                    })
                } else {
                    Rc::new(ToplevelGrabPointerOwner {
                        tl,
                        usecase: MoveToplevelGrabPointerOwner { dx, dy },
                    })
                }
            } else if let Some(popup) = pn.clone().node_into_popup() {
                popup.add_interactive_move(seat);
                seat.pointer_cursor.set_known(KnownCursor::Move);
                Rc::new(PopupPointerOwner {
                    popup,
                    window_management: true,
                    button,
                    usecase: PopupPointerOwnerMoveUsecase { dx, dy },
                })
            } else {
                return false;
            }
        } else if button == BTN_RIGHT {
            let mut top = false;
            let mut right = false;
            let mut bottom = false;
            let mut left = false;
            if dx <= pos.width() / 2 {
                left = true;
            } else {
                right = true;
                dx = pos.width() - dx;
            }
            if dy <= pos.height() / 2 {
                top = true;
            } else {
                bottom = true;
                dy = pos.height() - dy;
            }
            let cursor = match (top, right, bottom, left) {
                (true, true, false, false) => KnownCursor::NeResize,
                (false, true, true, false) => KnownCursor::SeResize,
                (false, false, true, true) => KnownCursor::SwResize,
                (true, false, false, true) => KnownCursor::NwResize,
                _ => KnownCursor::Move,
            };
            if let Some(tl) = pn.clone().node_into_toplevel() {
                seat.pointer_cursor.set_known(cursor);
                Rc::new(ToplevelGrabPointerOwner {
                    tl,
                    usecase: ResizeToplevelGrabPointerOwner {
                        top,
                        right,
                        bottom,
                        left,
                        dx,
                        dy,
                    },
                })
            } else if let Some(popup) = pn.clone().node_into_popup() {
                popup.add_interactive_move(seat);
                seat.pointer_cursor.set_known(cursor);
                Rc::new(PopupPointerOwner {
                    popup,
                    window_management: true,
                    button,
                    usecase: PopupPointerOwnerResizeUsecase {
                        edges: ResizeEdges {
                            top,
                            left,
                            right,
                            bottom,
                        },
                        dx,
                        dy,
                    },
                })
            } else {
                return false;
            }
        } else {
            return false;
        };
        seat.pointer_owner.owner.set(owner);
        pn.node_seat_state().add_pointer_grab(seat);
        true
    }

    fn release_grab(&self, seat: &Rc<WlSeatGlobal>) {
        seat.pointer_owner
            .owner
            .set(Rc::new(SimplePointerOwner { usecase: *self }));
        seat.changes.or_assign(CHANGE_CURSOR_MOVED);
    }

    fn disable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        seat.pointer_owner.set_default_pointer_owner(seat);
        seat.apply_changes();
    }
}

trait WindowManagementGrabUsecase {
    const BUTTON: u32;

    fn apply_changes(
        &self,
        seat: &Rc<WlSeatGlobal>,
        parent: Rc<dyn ContainingNode>,
        tl: &Rc<dyn ToplevelNode>,
    ) {
        let _ = seat;
        let _ = parent;
        let _ = tl;
    }

    fn on_drop(&self, seat: &Rc<WlSeatGlobal>, tl: &Rc<dyn ToplevelNode>) {
        let _ = seat;
        let _ = tl;
    }
}

struct ToplevelGrabPointerOwner<T> {
    tl: Rc<dyn ToplevelNode>,
    usecase: T,
}

impl<T> PointerOwner for ToplevelGrabPointerOwner<T>
where
    T: WindowManagementGrabUsecase,
{
    fn button(&self, seat: &Rc<WlSeatGlobal>, _time_usec: u64, button: u32, state: ButtonState) {
        if button != T::BUTTON || state != ButtonState::Released {
            return;
        }
        self.tl.node_seat_state().remove_pointer_grab(seat);
        self.usecase.on_drop(seat, &self.tl);
        self.grab_node_removed(seat);
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) {
        let Some(parent) = self.tl.tl_data().parent.get() else {
            return;
        };
        self.usecase.apply_changes(seat, parent, &self.tl);
    }

    fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>) {
        self.tl.node_seat_state().remove_pointer_grab(seat);
        seat.pointer_owner.set_default_pointer_owner(seat);
    }

    fn grab_node_removed(&self, seat: &Rc<WlSeatGlobal>) {
        if let Some(rect) = seat.ui_drag_highlight.take() {
            seat.state.damage(rect);
        }
        seat.pointer_cursor.set_known(KnownCursor::Default);
        seat.pointer_owner.owner.set(Rc::new(SimplePointerOwner {
            usecase: WindowManagementUsecase,
        }));
        seat.changes.or_assign(CHANGE_CURSOR_MOVED);
        seat.apply_changes();
    }

    fn disable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        self.tl.node_seat_state().remove_pointer_grab(seat);
        seat.pointer_owner.set_default_pointer_owner(seat);
        seat.apply_changes();
    }
}

struct MoveToplevelGrabPointerOwner {
    dx: i32,
    dy: i32,
}

impl WindowManagementGrabUsecase for MoveToplevelGrabPointerOwner {
    const BUTTON: u32 = BTN_LEFT;

    fn apply_changes(
        &self,
        seat: &Rc<WlSeatGlobal>,
        parent: Rc<dyn ContainingNode>,
        tl: &Rc<dyn ToplevelNode>,
    ) {
        let (x, y) = seat.pointer_cursor.position();
        let (x, y) = (x.round_down() - self.dx, y.round_down() - self.dy);
        parent.cnode_set_child_position(&**tl, x, y);
    }
}

#[derive(Debug)]
struct ResizeToplevelGrabPointerOwner {
    top: bool,
    right: bool,
    bottom: bool,
    left: bool,
    dx: i32,
    dy: i32,
}

impl WindowManagementGrabUsecase for ResizeToplevelGrabPointerOwner {
    const BUTTON: u32 = BTN_RIGHT;

    fn apply_changes(
        &self,
        seat: &Rc<WlSeatGlobal>,
        parent: Rc<dyn ContainingNode>,
        tl: &Rc<dyn ToplevelNode>,
    ) {
        let (x, y) = seat.pointer_cursor.position();
        let (x, y) = (x.round_down(), y.round_down());
        let pos = tl.node_absolute_position();
        let mut x1 = None;
        let mut x2 = None;
        let mut y1 = None;
        let mut y2 = None;
        if self.top {
            let new_v = y - self.dy;
            if new_v != pos.y1() {
                y1 = Some(new_v);
            }
        }
        if self.right {
            let new_v = x + self.dx;
            if new_v != pos.x2() {
                x2 = Some(new_v);
            }
        }
        if self.bottom {
            let new_v = y + self.dy;
            if new_v != pos.y2() {
                y2 = Some(new_v);
            }
        }
        if self.left {
            let new_v = x - self.dx;
            if new_v != pos.x1() {
                x1 = Some(new_v);
            }
        }
        if x1.is_some() || x2.is_some() || y1.is_some() || y2.is_some() {
            parent.cnode_resize_child(&**tl, x1, y1, x2, y2);
        }
    }
}

struct MoveFullscreenToplevelGrabPointerOwner;

impl WindowManagementGrabUsecase for MoveFullscreenToplevelGrabPointerOwner {
    const BUTTON: u32 = BTN_LEFT;

    fn on_drop(&self, seat: &Rc<WlSeatGlobal>, tl: &Rc<dyn ToplevelNode>) {
        let data = tl.tl_data();
        if !data.is_fullscreen.get() {
            return;
        }
        let output = 'output: {
            let (x, y) = seat.pointer_cursor.position_int();
            let outputs = seat.state.root.outputs.lock();
            for output in outputs.values() {
                let pos = output.global.pos.get();
                if pos.contains(x, y) {
                    break 'output output.clone();
                }
            }
            return;
        };
        let ws = output.ensure_workspace();
        toplevel_set_workspace(&seat.state, tl.clone(), &ws);
    }
}

trait UiDragUsecase: 'static {
    fn node_seat_state(&self) -> &NodeSeatState;
    fn left_button_up(&self, seat: &Rc<WlSeatGlobal>);
    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) -> Option<Rect>;
}

struct UiDragPointerOwner<T> {
    usecase: T,
}

impl<T> UiDragPointerOwner<T>
where
    T: UiDragUsecase,
{
    fn do_revert_to_default(&self, seat: &Rc<WlSeatGlobal>, needs_layout: bool) {
        self.usecase.node_seat_state().remove_ui_drag(seat);
        if let Some(rect) = seat.ui_drag_highlight.take() {
            seat.state.damage(rect);
        }
        seat.pointer_owner.set_default_pointer_owner(seat);
        seat.trigger_tree_changed(needs_layout);
    }
}

impl<T> PointerOwner for UiDragPointerOwner<T>
where
    T: UiDragUsecase,
{
    fn button(&self, seat: &Rc<WlSeatGlobal>, _time_usec: u64, button: u32, state: ButtonState) {
        if button == BTN_RIGHT {
            self.do_revert_to_default(seat, false);
            return;
        }
        if button != BTN_LEFT || state != ButtonState::Released {
            return;
        }
        self.apply_changes(seat);
        self.usecase.left_button_up(seat);
        self.do_revert_to_default(seat, true);
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) {
        let new_highlight = self.usecase.apply_changes(seat);
        handle_ui_drag_highlight(seat, new_highlight);
    }

    fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>) {
        self.do_revert_to_default(seat, false);
    }
}

fn handle_ui_drag_highlight(seat: &Rc<WlSeatGlobal>, new_highlight: Option<Rect>) {
    let prev_highlight = seat.ui_drag_highlight.replace(new_highlight);
    if prev_highlight != new_highlight {
        if let Some(rect) = prev_highlight {
            seat.state.damage(rect);
        }
        if let Some(rect) = new_highlight {
            seat.state.damage(rect);
        }
    }
}

struct TileDragUsecase {
    tl: Rc<dyn ToplevelNode>,
    destination: Cell<Option<TddType>>,
}

impl UiDragUsecase for TileDragUsecase {
    fn node_seat_state(&self) -> &NodeSeatState {
        self.tl.node_seat_state()
    }

    fn left_button_up(&self, seat: &Rc<WlSeatGlobal>) {
        let Some(dest) = self.destination.take() else {
            return;
        };
        let src = self.tl.clone();
        let Some(src_parent) = src.tl_data().parent.get() else {
            return;
        };
        let detach = || {
            let placeholder = Rc::new_cyclic(|weak| PlaceholderNode::new_empty(&seat.state, weak));
            src_parent
                .clone()
                .cnode_replace_child(&*src, placeholder.clone());
            placeholder
        };
        let new_container = |workspace: &Rc<WorkspaceNode>| {
            src_parent.clone().cnode_remove_child2(&*src, true);
            let cn = ContainerNode::new(
                &seat.state,
                &workspace,
                src.clone(),
                ContainerSplit::Horizontal,
            );
            workspace.set_container(&cn);
        };
        match dest {
            TddType::Replace(dst) => {
                let Some(dst_parent) = dst.tl_data().parent.get() else {
                    return;
                };
                let placeholder = detach();
                dst_parent.cnode_replace_child(&*dst, src);
                src_parent.cnode_replace_child(&*placeholder, dst);
            }
            TddType::Split {
                node,
                split,
                before,
            } => {
                let data = node.tl_data();
                let Some(pn) = data.parent.get() else {
                    return;
                };
                let Some(ws) = data.workspace.get() else {
                    return;
                };
                let placeholder = detach();
                let cn = ContainerNode::new(&seat.state, &ws, node.clone(), split);
                pn.cnode_replace_child(&*node, cn.clone());
                match before {
                    true => cn.add_child_before(&*node, src),
                    false => cn.add_child_after(&*node, src),
                }
                src_parent.cnode_remove_child(&*placeholder);
            }
            TddType::Insert {
                container,
                neighbor,
                before,
            } => {
                let placeholder = detach();
                match before {
                    true => container.add_child_before(&*neighbor, src),
                    false => container.add_child_after(&*neighbor, src),
                };
                src_parent.cnode_remove_child(&*placeholder);
            }
            TddType::NewWorkspace { output } => {
                new_container(&output.ensure_workspace());
            }
            TddType::NewContainer { workspace } => {
                new_container(&workspace);
            }
            TddType::MoveToWorkspace { workspace } => {
                src_parent.cnode_remove_child(&*src);
                seat.state.map_tiled_on(src, &workspace);
            }
            TddType::MoveToNewWorkspace { output } => {
                let ws = output.generate_workspace();
                src_parent.cnode_remove_child(&*src);
                seat.state.map_tiled_on(src, &ws);
            }
        }
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) -> Option<Rect> {
        if self.tl.tl_data().is_root_container() {
            self.destination.take();
            return None;
        }
        let (x, y) = seat.pointer_cursor.position();
        let dest = seat.state.root.tile_drag_destination(
            self.tl.node_id(),
            x.round_down(),
            y.round_down(),
        );
        match dest {
            None => {
                self.destination.take();
                None
            }
            Some(d) => {
                self.destination.set(Some(d.ty));
                Some(d.highlight)
            }
        }
    }
}

impl WindowManagementGrabUsecase for TileDragUsecase {
    const BUTTON: u32 = BTN_LEFT;

    fn apply_changes(
        &self,
        seat: &Rc<WlSeatGlobal>,
        _parent: Rc<dyn ContainingNode>,
        _tl: &Rc<dyn ToplevelNode>,
    ) {
        let dest = UiDragUsecase::apply_changes(self, seat);
        handle_ui_drag_highlight(seat, dest);
    }

    fn on_drop(&self, seat: &Rc<WlSeatGlobal>, _tl: &Rc<dyn ToplevelNode>) {
        UiDragUsecase::left_button_up(self, seat);
    }
}

struct WorkspaceDragUsecase {
    ws: Rc<WorkspaceNode>,
    destination: Cell<Option<WorkspaceDragDestination>>,
}

impl UiDragUsecase for WorkspaceDragUsecase {
    fn node_seat_state(&self) -> &NodeSeatState {
        self.ws.node_seat_state()
    }

    fn left_button_up(&self, _seat: &Rc<WlSeatGlobal>) {
        let Some(dest) = self.destination.take() else {
            return;
        };
        let ws = self.ws.clone();
        let output = dest.output.clone();
        if ws.is_dummy || output.is_dummy {
            return;
        }
        let link = match &*ws.output_link.borrow() {
            None => return,
            Some(l) => l.to_ref(),
        };
        let config = WsMoveConfig {
            make_visible_always: true,
            make_visible_if_empty: true,
            source_is_destroyed: false,
            before: dest.before.clone(),
        };
        move_ws_to_output(&link, &output, config);
        ws.desired_output.set(output.global.output_id.clone());
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) -> Option<Rect> {
        let (x, y) = seat.pointer_cursor.position();
        let dest =
            seat.state
                .root
                .workspace_drag_destination(self.ws.id, x.round_down(), y.round_down());
        match dest {
            None => {
                self.destination.take();
                None
            }
            Some(d) => {
                let hl = d.highlight;
                self.destination.set(Some(d));
                Some(hl)
            }
        }
    }
}

struct PopupPointerOwner<T> {
    popup: Rc<XdgPopup>,
    window_management: bool,
    button: u32,
    usecase: T,
}

trait PopupPointerOwnerUsecase: Sized + 'static {
    fn apply_changes(&self, popup: &Rc<XdgPopup>, seat: &Rc<WlSeatGlobal>);
}

impl<T> PopupPointerOwner<T>
where
    T: PopupPointerOwnerUsecase,
{
    fn revert_to_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        self.popup.remove_interactive_move(seat);
        self.popup.node_seat_state().remove_pointer_grab(seat);
        seat.pointer_cursor.set_known(KnownCursor::Default);
        seat.pointer_owner.owner.set(Rc::new(SimplePointerOwner {
            usecase: WindowManagementUsecase,
        }));
        seat.changes.or_assign(CHANGE_CURSOR_MOVED);
        seat.apply_changes();
    }

    fn revert_to_previous(&self, seat: &Rc<WlSeatGlobal>) {
        if self.window_management {
            self.revert_to_window_management(seat);
        } else {
            self.revert_to_default(seat);
        }
    }
}

impl<T> PointerOwner for PopupPointerOwner<T>
where
    T: PopupPointerOwnerUsecase,
{
    fn button(&self, seat: &Rc<WlSeatGlobal>, _time_usec: u64, button: u32, state: ButtonState) {
        if button != self.button || state != ButtonState::Released {
            return;
        }
        self.revert_to_previous(seat);
    }

    fn apply_changes(&self, seat: &Rc<WlSeatGlobal>) {
        if seat.changes.get().not_contains(CHANGE_CURSOR_MOVED) {
            return;
        }
        self.usecase.apply_changes(&self.popup, seat);
    }

    fn revert_to_default(&self, seat: &Rc<WlSeatGlobal>) {
        self.popup.remove_interactive_move(seat);
        self.popup.node_seat_state().remove_pointer_grab(seat);
        seat.pointer_owner.set_default_pointer_owner(seat);
        seat.tree_changed.trigger();
    }

    fn grab_node_removed(&self, seat: &Rc<WlSeatGlobal>) {
        self.revert_to_previous(seat);
    }

    fn disable_window_management(&self, seat: &Rc<WlSeatGlobal>) {
        if self.window_management {
            self.revert_to_default(seat);
        }
    }
}

struct PopupPointerOwnerMoveUsecase {
    dx: i32,
    dy: i32,
}

impl PopupPointerOwnerUsecase for PopupPointerOwnerMoveUsecase {
    fn apply_changes(&self, popup: &Rc<XdgPopup>, seat: &Rc<WlSeatGlobal>) {
        let (x, y) = seat.pointer_cursor.position();
        let (x, y) = (x.round_down(), y.round_down());
        let pos = popup.node_absolute_position();
        let (x, y) = pos.translate(x, y);
        if (x, y) != (self.dx, self.dy) {
            popup.move_(x - self.dx, y - self.dy);
            seat.tree_changed.trigger();
        }
    }
}

struct PopupPointerOwnerResizeUsecase {
    edges: ResizeEdges,
    dx: i32,
    dy: i32,
}

impl PopupPointerOwnerUsecase for PopupPointerOwnerResizeUsecase {
    fn apply_changes(&self, popup: &Rc<XdgPopup>, seat: &Rc<WlSeatGlobal>) {
        let (x, y) = seat.pointer_cursor.position();
        let (x, y) = (x.round_down(), y.round_down());
        let pos = popup.node_absolute_position();
        let (x, y) = pos.translate(x, y);
        let mut dx1 = 0;
        let mut dx2 = 0;
        let mut dy1 = 0;
        let mut dy2 = 0;
        if self.edges.left {
            dx1 = x - self.dx;
            dx1 = dx1.min(pos.width().saturating_sub(1));
        } else if self.edges.right {
            dx2 = self.dx - (pos.width() - x);
            dx2 = dx2.max(-pos.width().saturating_sub(1));
        }
        if self.edges.top {
            dy1 = y - self.dy;
            dy1 = dy1.min(pos.height().saturating_sub(1));
        } else if self.edges.bottom {
            dy2 = self.dy - (pos.height() - y);
            dy2 = dy2.max(-pos.height().saturating_sub(1));
        }
        if dx1 != 0 || dx2 != 0 || dy1 != 0 || dy2 != 0 {
            popup.resize(dx1, dy1, dx2, dy2);
            seat.tree_changed.trigger();
        }
    }
}