swaynav/src/act.rs

use std::collections::HashMap;
use std::fs::File;
use std::cell::RefCell;

use super::sway;

#[derive(Default, serde::Serialize, serde::Deserialize)]
pub struct SwayKeyStore {
    pub last_act: Option<String>,
    pub act_map: HashMap<String, String>,
}

impl SwayKeyStore {
    pub fn load() -> Self {
        let f = File::open(format!("{}/swaynav.json", std::env::var("XDG_RUNTIME_DIR").unwrap()));

        if f.is_err() { return Self::default() }

        serde_json::from_reader(f.unwrap()).expect("valid JSON in swaynav temp storage")
    }
    pub fn save(&self) {
        let f = File::create(format!("{}/swaynav.json", std::env::var("XDG_RUNTIME_DIR").unwrap()));

        serde_json::to_writer(f.unwrap(), self).expect("Successful serialization")
    }
}

fn update_act_map(key: &ActivityWorkspace) {
    let mut store = SwayKeyStore::load();
    store.act_map.insert(
        if key.group.as_ref().is_some() {
            key.group.as_ref().unwrap().to_string()
        } else {
            "default".to_string()
        },
        key.index.to_string()
    );
    store.save();
}

#[derive(Clone)]
pub struct ActivityWorkspace {
    pub index: usize,
    pub group: Option<String>
}

impl ActivityWorkspace {
    pub fn from_string(s: &str) -> Self {
        let sep = s.find(":");

        let (index, group) = match sep {
            None => {
                (s, None)
            },
            Some(pos) => {
                let (a, b) = s.split_at(pos);
                (a, Some(b[1..].to_string()))
            }
        };

        Self { index: index.parse().unwrap(), group }
    }

    pub fn to_string(&self) -> String {
        format!("{}{}", self.index,
            match &self.group {
                None => "".to_string(),
                Some(g) => format!(":{}", g)
            })
    }

    pub fn set_index(&mut self, index: usize) {
        self.index = index;
    }

    pub fn shift_index(&mut self, by: isize) {
        self.index = ((self.index + 9).wrapping_add_signed(by) % 10) + 1;
    }
}

pub struct Activity<'a> {
    si: &'a sway::SwayInterface,
    active: RefCell<ActivityWorkspace>
}

impl<'a> Activity<'a> {
    pub fn current(si: &'a sway::SwayInterface) -> Self {
        let current = si.get_current_workspace().unwrap();
        Self { si, active: RefCell::new(ActivityWorkspace::from_string(&current)) }
    }

    pub fn by_name(si: &'a sway::SwayInterface, name: &str) -> Self {
        let store = SwayKeyStore::load();
        let one = "1".to_string();
        let index = store.act_map.get(&name.to_string()).unwrap_or(&one);

        let group = if name == "default" { None } else { Some(name.to_string()) };

        Self { si, active: RefCell::new(ActivityWorkspace { index: index.parse().unwrap(), group }) }
    }

    pub fn group(&self) -> Option<String> {
        self.active.borrow().group.clone()
    }

    pub fn shift_ws(&self, by: isize) {
        self.active.borrow_mut().shift_index(by);
        self.si.switch_to_workspace(self.active.borrow().to_string().as_str()).unwrap();

        update_act_map(&self.active.borrow());
    }

    pub fn set_ws(&self, to: usize) {
        self.active.borrow_mut().set_index(to);
        self.si.switch_to_workspace(self.active.borrow().to_string().as_str()).unwrap();

        update_act_map(&self.active.borrow());
    }

    pub fn move_to_ws(&self, to: usize) {
        let mut k = self.active.borrow().clone();
        k.set_index(to);
        self.si.move_to_workspace(k.to_string().as_str()).unwrap();
    }
}