use std::collections::HashMap;

#[derive(Debug)]
pub struct NoteBlock {
    // IDs are int64 as this is the datatype of rowids in sqlite
    id: i64,
    first_child_id: Option<i64>,
    next_sibling_id: Option<i64>,
    
    content: String
}

impl NoteBlock {
    pub fn new(id: i64, first_child_id: Option<i64>, next_sibling_id: Option<i64>, content: String) -> Self {
        Self {id, first_child_id, next_sibling_id, content}
    }
}

#[derive(Debug)]
struct BlockTreeNode {
    // a tree of nodes, where each node refers to its block by id.
    // the id is used as the key in a page's block table.
    block_id: i64,
    block_level: Option<usize>,
    first_child_node: Option<Box<BlockTreeNode>>,
    next_sibling_node: Option<Box<BlockTreeNode>>
}

impl BlockTreeNode {
    pub fn new(block_id: i64) -> Self {
        BlockTreeNode {
            block_id,
            block_level: None,
            first_child_node: None,
            next_sibling_node: None
        }
    }
}

#[derive(Debug)]
pub struct NotePage {
    title: String,
    id: i64,
    block_tree_root: BlockTreeNode,
    
    block_table: HashMap<i64, NoteBlock>
}

impl NotePage {
    pub fn new(title: String, id: i64, root_block: NoteBlock) -> Self {
        let mut new_page = Self {
            title, 
            id, 
            block_tree_root: BlockTreeNode::new(root_block.id),
            block_table: HashMap::new()
        };
        new_page.block_tree_root.block_level = Some(0);
        new_page.block_table.insert(root_block.id, root_block);
        new_page
    }
    
    pub fn insert(self: &mut Self, block: NoteBlock) {
        self.block_table.insert(block.id, block);
    }
    
    pub fn build_tree(self: &mut Self) {
        let mut node_stack = Vec::new();
        node_stack.push(&mut self.block_tree_root);
        while !node_stack.is_empty() {
            println!("{:?}", node_stack);
            let current_node = node_stack.pop().unwrap();
            let current_block = self.block_table.get(&current_node.block_id).unwrap();
            if let Some(next_sibling_id) = current_block.next_sibling_id {
                let mut sibling_node = BlockTreeNode::new(next_sibling_id);
                sibling_node.block_level = current_node.block_level;
                current_node.next_sibling_node = Some(Box::new(sibling_node));
                node_stack.push(current_node.next_sibling_node.as_mut().unwrap());
            }
            if let Some(first_child_id) = current_block.first_child_id {
                let mut child_node = BlockTreeNode::new(first_child_id);
                child_node.block_level = Some(current_node.block_level.unwrap() + 1);
                current_node.first_child_node = Some(Box::new(child_node));
                node_stack.push(current_node.first_child_node.as_mut().unwrap());
            }
        }
    }
}