monolith

use crate::{Layout, Scratchpad, WindowId, centre_in, centred, translate};

impl Layout {

    /// Adds a window to a named scratchpad, creating it. Scratchpad windows

    /// float and are shown only by summoning.

    pub fn scratchpad_add(&mut self, w: WindowId, name: &str) {

        let Some(win) = self.windows.get(w) else {

            return;

        };

        if let Some(s) = win.scratchpad {

            self.leave_scratchpad(s, w);

        }

        self.unplace(w);

        let s = match self.scratchpads.iter().position(|sp| sp.name == name) {

            Some(s) => s,

            None => {

                self.scratchpads.push(Scratchpad {

                    name: name.into(),

                    windows: Vec::new(),

                    shown: None,

                    output: None,

                });

                self.scratchpads.len() - 1

            }

        };

        self.scratchpads[s].windows.push(w);

        let area = self.windows[w].output.map(|o| self.outputs[o].usable());

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

        win.scratchpad = Some(s);

        win.floating = true;

        if win.float_rect.is_none() {

            win.float_rect = area.map(|a| centred(a, 0.6));

        }

    }

    /// Cycles a scratchpad through off, each window, and off again, on the

    /// active output.

    pub fn summon(&mut self, name: &str) -> Option<WindowId> {

        let s = self.scratchpads.iter().position(|sp| sp.name == name)?;

        let o = self.active?;

        let sp = &mut self.scratchpads[s];

        let mut next = sp.shown.map_or(0, |i| i + 1);

        while sp

            .windows

            .get(next)

            .is_some_and(|&w| self.windows[w].hidden)

        {

            next += 1;

        }

        if next >= sp.windows.len() {

            sp.shown = None;

            return None;

        }

        let from = sp.output.map(|f| self.outputs[f].usable());

        sp.shown = Some(next);

        sp.output = Some(o);

        let w = sp.windows[next];

        self.last_scratchpad = Some(s);

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

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

        if win.output != Some(o) {

            win.float_rect = match (from, win.float_rect) {

                (Some(from), Some(r)) => Some(translate(r, from, usable)),

                _ => Some(centred(usable, 0.6)),

            };

            win.output = Some(o);

        }

        win.float_rect = win.float_rect.map(|r| centre_in(usable, r.w, r.h));

        self.focus_unless_covered(w);

        Some(w)

    }

    /// Hides a scratchpad, by default the last one summoned.

    pub fn dismiss(&mut self, name: Option<&str>) {

        let s = match name {

            Some(name) => self.scratchpads.iter().position(|sp| sp.name == name),

            None => self.last_scratchpad,

        };

        if let Some(sp) = s.and_then(|s| self.scratchpads.get_mut(s)) {

            sp.shown = None;

        }

    }

    pub(crate) fn leave_scratchpad(&mut self, s: usize, w: WindowId) {

        let sp = &mut self.scratchpads[s];

        let Some(i) = sp.windows.iter().position(|&x| x == w) else {

            return;

        };

        sp.windows.remove(i);

        sp.shown = match sp.shown {

            Some(j) if j == i => None,

            Some(j) if j > i => Some(j - 1),

            other => other,

        };

        self.windows[w].scratchpad = None;

    }

}