monolith

use crate::{Insets, Layout, Output, OutputId, Rect, TagId, Tree, WindowId, translate};

#[derive(Clone, Debug)]

pub(crate) struct Parked {

    tree: Tree<WindowId>,

    viewed: Vec<TagId>,

    floating: Vec<WindowId>,

}

impl Layout {

    /// Adds an output. One that was unplugged before gets back its tree,

    /// views and the windows that had to leave it.

    pub fn add_output(&mut self, name: &str, area: Rect) -> OutputId {

        let id = self.outputs.insert(Output {

            name: name.into(),

            area,

            reserved: Insets::default(),

            tree: Tree::default(),

            viewed: Vec::new(),

            floating: Vec::new(),

        });

        if let Some(parked) = self.parked.remove(name) {

            self.restore(id, parked);

        }

        self.active.get_or_insert(id);

        let detached: Vec<WindowId> = self

            .windows

            .iter()

            .filter(|(_, w)| w.output.is_none())

            .map(|(id, _)| id)

            .collect();

        for w in detached {

            self.windows[w].output = Some(id);

            self.place(w);

        }

        id

    }

    fn restore(&mut self, id: OutputId, parked: Parked) {

        let name = self.outputs[id].name.clone();

        let ours = |l: &Self, w: WindowId| {

            l.windows

                .get(w)

                .is_some_and(|x| x.evicted_from.as_deref() == Some(&name) && x.scratchpad.is_none())

        };

        let mut tree = parked.tree;

        tree.retain(|w| ours(self, w) && !self.windows[w].floating);

        let floating: Vec<WindowId> = parked

            .floating

            .into_iter()

            .filter(|&w| ours(self, w) && self.windows[w].floating)

            .collect();

        for w in tree

            .windows()

            .chain(floating.iter().copied())

            .collect::<Vec<_>>()

        {

            self.unplace(w);

            let win = &mut self.windows[w];

            if let (Some(from), Some(rect)) = (win.output, win.float_rect) {

                win.float_rect = Some(translate(

                    rect,

                    self.outputs[from].usable(),

                    self.outputs[id].usable(),

                ));

            }

            win.output = Some(id);

            win.evicted_from = None;

        }

        let out = &mut self.outputs[id];

        out.tree = tree;

        out.floating = floating;

        out.viewed = parked

            .viewed

            .into_iter()

            .filter(|&t| self.tags.contains_key(t))

            .collect();

    }

    /// Removes an output. Its windows move to an output viewing their tag,

    /// or the active one, and remember where they came from.

    pub fn remove_output(&mut self, o: OutputId) {

        let Some(out) = self.outputs.remove(o) else {

            return;

        };

        let left_usable = out.usable();

        self.parked.insert(

            out.name.clone(),

            Parked {

                tree: out.tree,

                viewed: out.viewed,

                floating: out.floating,

            },

        );

        if self.active == Some(o) {

            self.active = self.outputs.keys().next();

        }

        for sp in &mut self.scratchpads {

            if sp.output == Some(o) {

                sp.output = self.active;

            }

        }

        let leaving: Vec<WindowId> = self

            .windows

            .iter()

            .filter(|(_, w)| w.output == Some(o))

            .map(|(id, _)| id)

            .collect();

        for w in leaving {

            let tag = self.windows[w].tag;

            let target = self

                .outputs

                .keys()

                .find(|&t| self.is_viewed(t, tag))

                .or(self.active);

            let win = &mut self.windows[w];

            if let (Some(t), Some(rect)) = (target, win.float_rect) {

                win.float_rect = Some(translate(rect, left_usable, self.outputs[t].usable()));

            }

            win.output = target;

            if win.scratchpad.is_some() {

                continue;

            }

            win.evicted_from.get_or_insert_with(|| out.name.clone());

            if target.is_some() {

                self.place(w);

            }

        }

    }

    pub fn set_output_area(&mut self, o: OutputId, area: Rect) {

        let Some(out) = self.outputs.get_mut(o) else {

            return;

        };

        let before = out.usable();

        out.area = area;

        self.rescale_floats(o, before);

    }

    /// Returns whether anything changed.

    pub fn set_reserved(&mut self, o: OutputId, reserved: Insets) -> bool {

        let Some(out) = self.outputs.get_mut(o) else {

            return false;

        };

        if out.reserved == reserved {

            return false;

        }

        let before = out.usable();

        out.reserved = reserved;

        self.rescale_floats(o, before);

        true

    }

    /// Carries floating windows along when the usable area of o changes.

    fn rescale_floats(&mut self, o: OutputId, before: Rect) {

        let after = self.outputs[o].usable();

        if after == before {

            return;

        }

        for win in self.windows.values_mut().filter(|w| w.output == Some(o)) {

            if let Some(rect) = win.float_rect {

                win.float_rect = Some(translate(rect, before, after));

            }

        }

    }

}