//! AbleOS capability tree implementation

use {
    alloc::{
        format,
        string::{String, ToString},
        vec,
    },
    core::fmt,
};

// Seperate
use alloc::vec::Vec;

struct Argument {
    name:  String,
    type_: String,
}

struct Function {
    name: String,
    args: Vec<Argument>,
    ret:  Option<String>,
}

struct Capability {
    name: String,
    functions: Vec<Function>,
    sub_capabilities: Vec<Capability>,
}

impl Capability {
    fn new(name: String) -> Capability {
        Capability {
            name,
            functions: Vec::new(),
            sub_capabilities: Vec::new(),
        }
    }
}

impl fmt::Display for Capability {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Capability: {}\n", self.name)?;
        for function in &self.functions {
            write!(f, "  Function: {}\n", function.name)?;
            for arg in &function.args {
                write!(f, "    Argument: {} (Type: {})\n", arg.name, arg.type_)?;
            }
            if let Some(ret_type) = &function.ret {
                write!(f, "    Return Type: {}\n", ret_type)?;
            } else {
                write!(f, "    Return Type: None\n")?;
            }
        }
        for sub_capability in &self.sub_capabilities {
            write!(f, "{}", sub_capability.to_string_with_indentation(2))?;
        }
        Ok(())
    }
}

impl Capability {
    fn to_string_with_indentation(&self, level: usize) -> String {
        let indent = "  ".repeat(level);
        let mut result = format!("{}Capability: {}\n", indent, self.name);
        for function in &self.functions {
            result.push_str(&format!("{}  Function: {}\n", indent, function.name));
            for arg in &function.args {
                result.push_str(&format!(
                    "{}    Argument: {} (Type: {})\n",
                    indent, arg.name, arg.type_
                ));
            }
            if let Some(ret_type) = &function.ret {
                result.push_str(&format!("{}    Return Type: {}\n", indent, ret_type));
            } else {
                result.push_str(&format!("{}    Return Type: None\n", indent));
            }
        }
        for sub_capability in &self.sub_capabilities {
            result.push_str(&sub_capability.to_string_with_indentation(level + 1));
        }
        result
    }
}

struct CapabilityTree {
    capabilities: Vec<Capability>,
}

impl CapabilityTree {
    fn new() -> CapabilityTree {
        CapabilityTree {
            capabilities: Vec::new(),
        }
    }
}

fn example() {
    let mut capability_tree = Capability::new("VFS".to_string());

    let mut file_management_capability = Capability::new("File Management".to_string());
    file_management_capability.functions.push(Function {
        name: "OpenFile".to_string(),
        args: vec![
            Argument {
                name:  "path".to_string(),
                type_: "String".to_string(),
            },
            Argument {
                name:  "mode".to_string(),
                type_: "String".to_string(),
            },
        ],
        ret:  Some("FileHandle".to_string()),
    });
    file_management_capability.functions.push(Function {
        name: "ReadFile".to_string(),
        args: vec![
            Argument {
                name:  "file".to_string(),
                type_: "FileHandle".to_string(),
            },
            Argument {
                name:  "buffer".to_string(),
                type_: "&mut [u8]".to_string(),
            },
            Argument {
                name:  "length".to_string(),
                type_: "usize".to_string(),
            },
        ],
        ret:  Some("usize".to_string()),
    });
    file_management_capability.functions.push(Function {
        name: "WriteFile".to_string(),
        args: vec![
            Argument {
                name:  "file".to_string(),
                type_: "FileHandle".to_string(),
            },
            Argument {
                name:  "buffer".to_string(),
                type_: "&[u8]".to_string(),
            },
        ],
        ret:  None,
    });

    let mut directory_management_capability = Capability::new("Directory Management".to_string());
    directory_management_capability.functions.push(Function {
        name: "CreateDirectory".to_string(),
        args: vec![Argument {
            name:  "path".to_string(),
            type_: "String".to_string(),
        }],
        ret:  Some("bool".to_string()),
    });
    directory_management_capability.functions.push(Function {
        name: "ListDirectory".to_string(),
        args: vec![Argument {
            name:  "path".to_string(),
            type_: "String".to_string(),
        }],
        ret:  Some("Vec<String>".to_string()),
    });

    capability_tree
        .sub_capabilities
        .push(file_management_capability);
    capability_tree
        .sub_capabilities
        .push(directory_management_capability);

    log::debug!("{}", capability_tree);
}