aimx/aim/

workspace.rs

//! Internal workspace spine backed by [`Node`].
//! Provides a process-global workspace root used by path and rule resolution.
//! External users should use higher-level APIs.

use crate::{
    Sheet, aim::{ Rule, Workflow, WorkflowLike}, expressions::Reference, reference::parse_identifier, values::{Instance, Node}
};
use anyhow::{Result, anyhow};
use once_cell::sync::{
    Lazy,
    OnceCell,
};
use std::{
    fs,
    path::{Path, PathBuf},
    sync::{Arc, RwLock},
};

static WORKSPACE_PATH: OnceCell<PathBuf> = OnceCell::new();
pub struct BasePath {}
impl BasePath {
    pub fn init(path: &Path) -> Result<()> {
        let basepath = path.parent().unwrap_or(Path::new("")).to_path_buf();
        fs::create_dir_all(&basepath)?;
        WORKSPACE_PATH.set(basepath)
            .map_err(|_| anyhow!("Workspace path already initialized"))
    }
    
    pub fn convert(locator: &Reference) -> Result<Arc<PathBuf>> {
        let base_path = WORKSPACE_PATH.get()
            .ok_or_else(|| anyhow!("Workspace path not initialized"))?;

        if let Reference::One(one) = locator {
            if one.as_ref() == "_" {
                return Ok(Arc::new(base_path.join("workspace.aim")));
            }
        }
        let root_path = base_path.join("workspace");
        std::fs::create_dir_all(&root_path)?;

        Ok(Arc::new(match locator {
            Reference::One(one) => {
                if !root_path.exists() {
                    fs::create_dir_all(&root_path)?;
                }
                root_path.join(format!("{}.aim", one))
            }
            Reference::Two(one, two) => {
                let branch_path = root_path.join(one.as_ref());
                if !branch_path.exists() {
                    fs::create_dir_all(&branch_path)?;
                }
                branch_path.join(format!("{}.aim", two))
            }
            Reference::Three(one, two, three) => {
                let branch_path = root_path.join(one.as_ref()).join(two.as_ref());
                if !branch_path.exists() {
                    fs::create_dir_all(&branch_path)?;
                }
                branch_path.join(format!("{}.aim", three))
            }
            Reference::Four(one, two, three, four) => {
                let branch_path = root_path.join(one.as_ref()).join(two.as_ref()).join(three.as_ref());
                if !branch_path.exists() {
                    fs::create_dir_all(&branch_path)?;
                }
                branch_path.join(format!("{}.aim", four))
            }
        }))
    }
}

/// Process-global workspace root.
///
/// Holds the root [`Node`] and base filesystem path.
pub struct Workspace {
    node: Node,
}

/// Global workspace singleton used by free functions in this module.
static GLOBAL_WORKSPACE: Lazy<RwLock<Workspace>> =
    Lazy::new(|| RwLock::new(Workspace::new()));

/// Access the global workspace.
fn get_workspace_lock() -> &'static RwLock<Workspace> {
    &GLOBAL_WORKSPACE
}

impl Workspace {
    /// New empty workspace with default paths.
    fn new() -> Self {
        Workspace {
            // This shouldn't fail because no other threads have access yet.
            node: Node::init_default(Reference::workspace()),
        }
    }

    pub fn workflow() -> Result<Arc<Workflow>> {
        let read_guard = get_workspace_lock().read()
            .expect("Lock poisoned in workflow() workspace read.");
        read_guard.node.get_workflow()      
    }

    // -----------------------------------------------------------------------------
    // Workspace Functions
    // -----------------------------------------------------------------------------

    pub fn create(path: Arc<PathBuf>) -> Result<Sheet> {
        match BasePath::init(&path) {
            Ok(_) => {
                // Initialize default workflow structure
                let mut workspace = Workflow::new_from(Reference::workspace(), path);
                workspace.add_node(Arc::from("context"), Node::default())?;
                workspace.add_node(Arc::from("inference"), Node::default())?;
                workspace.add_node(Arc::from("status"), Node::default())?;
                workspace.add_node(Arc::from("tool"), Node::default())?;
                workspace.add_node(Arc::from("workflow"), Node::default())?;
                workspace.save()?;
                // Bind MVCC snapshot
                let write_guard = get_workspace_lock().write()
                    .expect("Lock poisoned in create() workspace write.");
                write_guard.node.set_workflow(workspace);
                Sheet::convert(&write_guard.node)
            }
            _ => {
                let write_guard = get_workspace_lock().write()
                    .expect("Lock poisoned in create() workspace write.");
                Sheet::convert(&write_guard.node)
            }
        }
    }

    /// Initialize the workspace path
    pub fn open(path: &Path) -> Result<Sheet> {
        let _ = BasePath::init(&path);
        let write_guard = get_workspace_lock().write()
            .expect("Lock poisoned in open() workspace write.");
        Sheet::convert(&write_guard.node)
    }

    pub fn save() -> Result<()> {
        // Write workspace and save
        let write_guard = get_workspace_lock().write()
            .expect("Lock poisoned in save() workspace write.");
        let workflow = write_guard.node.get_workflow()?;
        if workflow.is_touched() {
            let mut workspace = write_guard.node.get_workflow_mut()?;
            workspace.save()?;
            write_guard.node.set_workflow(workspace); 
        }
        Ok(())
    }

    pub fn save_all() -> Result<()> {
        {
            let write_guard = get_workspace_lock().write()
                .expect("Lock poisoned in save_all() workspace write.");
            let workspace = write_guard.node.get_workflow()?;
            if workspace.is_touched() {
                let mut workspace = write_guard.node.get_workflow_mut()?;
                workspace.save_all()?;
                write_guard.node.set_workflow(workspace);
                return Ok(());
            }
        }
        {
            let read_guard = get_workspace_lock().read()
                .expect("Lock poisoned in save_all() workspace read.");
            let workspace = read_guard.node.get_workflow()?;
            for rule in workspace.iter_rules() {
                if let Some(node) = rule.get_node() {
                    node.save_all()?;
                } else if let Some(instance) = rule.get_instance() {
                    instance.save_all()?;
                }
            }
            Ok(())
        }
    }

    // Prune open read-only nodes from memory
    pub fn compact() -> Result<()> {
        let read_guard = get_workspace_lock().read()
            .expect("Lock poisoned in compact() workspace read.");
        let workspace = read_guard.node.get_workflow()?;
        for rule in workspace.iter_rules() {
            if let Some(node) = rule.get_node() {
                node.compact();
            } else if let Some(instance) = rule.get_instance() {
                instance.compact();
            }
        }
        Ok(())
    }

    pub fn sheet() -> Result<Sheet> {
        let read_guard = get_workspace_lock().read()
            .expect("Lock poisoned in sheet() workspace read.");
        Sheet::convert(&read_guard.node)
    }

    // -----------------------------------------------------------------------------
    // Workspace Node Functions
    // -----------------------------------------------------------------------------

    pub fn catalog() -> Result<Vec<Arc<Sheet>>> {
        let read_guard = get_workspace_lock().read()
            .expect("Lock poisoned in catalog() workspace read.");
        let workspace = read_guard.node.get_workflow_like()?;
        let mut list = Vec::new();
        for rule in workspace.iter_rules() {
            if let Some(node) = rule.get_node() {
                let sheet = Sheet::convert(&node)?;
                list.push(Arc::new(sheet));
            }
        }
        Ok(list)
    }

    pub fn contains_node(identifier: &str) -> Result<bool> {
        let read_guard = get_workspace_lock().read()
            .expect("Lock poisoned in contains_node() workspace read.");
        let workspace = read_guard.node.get_workflow_like()?;
        Ok(workspace.contains(&identifier))
    }

    fn arc_identifier(input: &str) -> Result<Arc<str>> {
        if input == "" {
            return Err(anyhow!("Empty identifier"));
        }
        match parse_identifier(input) {
            Ok((remain, identifier)) => {
                if remain == "" {
                    if identifier == "_" {
                        Err(anyhow!("Invalid identifier {}", input))
                    } else {
                        Ok(Arc::from(identifier))
                    }
                } else {
                    Err(anyhow!("Invalid identifier {}~{}", input, remain))
                }
            }
            Err(e) => Err(anyhow!("Syntax error ({})", e)),
        }
    }

    pub fn add_node(identifier: &str, parameters: &str) -> Result<Arc<Reference>> {
        let arc_identifier = Self::arc_identifier(identifier)?;
        let node = Node::parse(parameters)?;
        // Read workspace
        {
            let read_guard = get_workspace_lock().read()
                .expect("Lock poisoned in add_node() workspace read.");
            let workspace = read_guard.node.get_workflow()?;
            if workspace.contains(&arc_identifier) {
                return Err(anyhow!("Workspace node {} already exists", identifier));
            }
        }
        // Write workspace and save
        {
            let write_guard = get_workspace_lock().write()
                .expect("Lock poisoned in add_node() workspace write.");
            let mut workspace = write_guard.node.get_workflow_mut()?;
            let reference = workspace.add_node(arc_identifier, node)?;
            let _ = workspace.save();
            write_guard.node.set_workflow(workspace);
            Ok(reference)
        }
    }

    pub fn copy_node(from: Arc<str>, to: Arc<str>) -> Result<()> {
        // First check if the target node already exists
        {
            let read_guard = get_workspace_lock().read()
                .expect("Lock poisoned in copy_node() workspace read.");
            let workspace = read_guard.node.get_workflow()?;
            if false == workspace.contains(&from) {
                return Err(anyhow!("Workspace node {} not found", from));
            }
            if workspace.contains(&to) {
                return Err(anyhow!("Workspace node {} already exists", to));
            }
        }

        // Rename the workspace node
        {
            let write_guard = get_workspace_lock().write()
                .expect("Lock poisoned in copy_node() workspace write.");
            let mut workspace = write_guard.node.get_workflow_mut()?;
            let from_node = workspace.get_node(&from)?;
            workspace.copy_node(&from_node, to)?;
            let _ = workspace.save();
            write_guard.node.set_workflow(workspace);
            Ok(())
        }
    }

    pub fn get_node(identifier: &str) -> Result<Node> {
        let read_guard = get_workspace_lock().read()
            .expect("Lock poisoned in get_node() workspace read.");
        let workspace = read_guard.node.get_workflow()?;
        if let Some(rule) = workspace.get_rule(identifier) {
            if let Some(node) = rule.get_node() {
                return Ok(node);
            }
        }
        return Err(anyhow!("Workspace node {} not found", identifier))
    }

    pub fn rename_node(from: &str, to: Arc<str>) -> Result<()> {
        if from == "context" {
            return Err(anyhow!("Cannot rename context node"))
        }
        // First check if the target node already exists
        {
            let read_guard = get_workspace_lock().read()
                .expect("Lock poisoned in rename_node() workspace read.");
            let workspace = read_guard.node.get_workflow()?;
            if false == workspace.contains(from) {
                return Err(anyhow!("Workspace node {} not found", from));
            }
            if workspace.contains(&to) {
                return Err(anyhow!("Workspace node {} already exists", to));
            }
        }

        // Rename the workspace node
        {
            let write_guard = get_workspace_lock().write()
                .expect("Lock poisoned in rename_node() workspace write.");
            let mut workspace = write_guard.node.get_workflow_mut()?;
            workspace.rename_node(from, to)?;
            let _ = workspace.save();
            write_guard.node.set_workflow(workspace);
            Ok(())
        }
    }

    pub fn remove_node(identifier: &str) -> Result<()> {
        if identifier == "context" {
            return Err(anyhow!("Cannot remove context node"))
        }
        // First check if the node exists
        {
            let read_guard = get_workspace_lock().read()
                .expect("Lock poisoned in remove_node() workspace read.");
            let workspace = read_guard.node.get_workflow()?;
            if false == workspace.contains(identifier) {
                return Err(anyhow!("Workspace node {} not found", identifier));
            }
        }
        
        // Remove the node from the workspace
        {
            let write_guard = get_workspace_lock().write()
                .expect("Lock poisoned in remove_node() workspace write.");
            let mut workspace = write_guard.node.get_workflow_mut()?;
            workspace.delete_node(identifier)?;
            let _ = workspace.save();
            write_guard.node.set_workflow(workspace);
            Ok(())
        }
    }

    // -----------------------------------------------------------------------------
    // Workspace Tree Functions
    // -----------------------------------------------------------------------------

    /// Resolve a [`Node`] from a hierarchical [`Reference`].
    pub fn locate_node(locator: &Reference) -> Result<Node> {
        match locator {
            Reference::One(one) => {
                // Try workspace
                if let Ok(node) = Self::get_node(one) {
                    return Ok(node);
                }
            }
            Reference::Two(one, two) => {
                if let Ok(node) = Self::get_node(one) {
                    if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                        if let Some(node) = rule.get_node() {
                            return Ok(node);
                        }
                    }
                }
            }
            Reference::Three(one, two, three) => {
                if let Ok(node) = Self::get_node(one) {
                    if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                        if let Some(node) = rule.get_node() {
                            if let Some(rule) = &node.get_workflow()?.get_rule(three) {
                                if let Some(node) = rule.get_node() {
                                    return Ok(node);
                                }
                            }
                        }
                    }
                }
            }
            _ => {}
        }
        Err(anyhow!("Node {} not found", locator))
    }

    /// Resolve a [`Node`] from a hierarchical [`Reference`].
    pub fn locate_instance(locator: &Reference, identifier: &str) -> Result<Instance> {
        match locator {
            Reference::One(one) => {
                // Try workspace
                if let Ok(node) = Self::get_node(one) {
                    if let Some(rule) = &node.get_workflow()?.get_rule(identifier) {
                        if let Some(instance) = rule.get_instance() {
                            return Ok(instance);
                        }
                    }
                }
            }
            Reference::Two(one, two) => {
                if let Ok(node) = Self::get_node(one) {
                    if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                        if let Some(node) = rule.get_node() {
                            if let Some(rule) = &node.get_workflow()?.get_rule(identifier) {
                                if let Some(instance) = rule.get_instance() {
                                    return Ok(instance);
                                }
                            }
                        }
                    }
                }
            }
            Reference::Three(one, two, three) => {
                if let Ok(node) = Self::get_node(one) {
                    if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                        if let Some(node) = rule.get_node() {
                            if let Some(rule) = &node.get_workflow()?.get_rule(three) {
                                if let Some(node) = rule.get_node() {
                                    if let Some(rule) = &node.get_workflow()?.get_rule(identifier) {
                                        if let Some(instance) = rule.get_instance() {
                                            return Ok(instance);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            _ => {}
        }
        Err(anyhow!("Instance {} not found", locator))
    }

    /// Resolve the [`Rule`] addressed by a hierarchical [`Reference`].
    pub fn locate_rule(reference: &Reference) -> Result<Option<Arc<Rule>>> {
        match reference {
            Reference::Two(one, two) => {
                // Try workspace
                if let Ok(node) = Self::get_node(one) {
                    return Ok(node.get_workflow_like()?.get_rule(two));
                }
            }
            Reference::Three(one, two, three) => {
            // Try workspace
                if let Ok(node) = Self::get_node(one) {
                    if let Some(rule) = &node.get_workflow_like()?.get_rule(two) {
                        if let Some(node) = rule.get_node() {
                            return Ok(node.get_workflow_like()?.get_rule(three));
                        }
                    }
                }
            }
            Reference::Four(one, two, three, four) => {
                if let Ok(node) = Self::get_node(one) {
                    if let Some(rule) = &node.get_workflow_like()?.get_rule(two) {
                        if let Some(node) = rule.get_node() {
                            if let Some(rule) = &node.get_workflow_like()?.get_rule(three) {
                                if let Some(node) = rule.get_node() {
                                    return Ok(node.get_workflow_like()?.get_rule(four));
                                }
                            }
                        }
                    }
                }
            }
            _ => {}
        }
        Ok(None)
    }
}