#![feature(nll)]

// A simple binary tree built with structs
#[derive(Clone)]
pub struct Tree<'a, T: PartialOrd + Clone> {
    left: Option<Box<Tree<'a, T>>>,
    right: Option<Box<Tree<'a, T>>>,
    pub value: T,
    id: &'a u32,
}

impl<'a, T: PartialOrd + Clone> Tree<'a, T> {
    pub fn new(value: T) -> Tree<'a, T> {
        let tree = Tree {
            left: None,
            right: None,
            value: value,
            id: &15,
        };
        return tree;
    }

    // Finds closeset node to the value
    fn find_closest_mut(&mut self, value: T) -> &mut Tree<'a, T> {
        if value == self.value {
            return self;
        }

        if value < self.value {
            if self.left.is_none() {
                return self
            }
        } else {
            if self.right.is_none() {
                return self
            }
        }

        let sub_tree = if value < self.value {
            &mut self.left
        } else {
            &mut self.right
        };

        sub_tree.as_mut().unwrap().find_closest_mut(value)
    }

    pub fn insert(&mut self, value: T) -> &mut Tree<'a, T> {
        let node = self.find_closest_mut(value.clone());
        if value == node.value {
            return self;
        } else if value < node.value {
            node.left = None
        }
        return self;
    }
}

fn main () {

}