use super::item::Item;

use std::fmt::Display;
use std::ops::Index;
use std::rc::Rc;

pub struct Node<T>
    where T: Display
{
    pub value: Option<Rc<Item<T>>>,
}

impl<T> Node<T>
    where T: Display
{
    pub fn new(item: Item<T>) -> Self {
        Node { value: Some(Rc::new(item)) }
    }

    pub fn empty() -> Self {
        Node { value: None }
    }

    pub fn val_some(&self) -> bool {
        self.value.is_some()
    }

    pub fn val_none(&self) -> bool {
        self.value.is_none()
    }
}

impl<T> Clone for Node<T>
    where T: Display
{
    fn clone(&self) -> Self {
        Node { value: self.value.clone() }
    }
}

impl<T> Default for Node<T>
    where T: Display
{
    fn default() -> Self {
        Node { value: None }
    }
}

impl<T> Index<usize> for Node<T>
    where T: Display
{
    type Output = Self;

    fn index(&self, n: usize) -> &Self::Output {
        let mut previous;
        let mut current = self;
        let empty = Node::empty();
        for _i in 0..n {
            previous = current;
            current = match previous.value {
                Some(ref x) => &x.next,
                None => &empty,
            };
        }
        unsafe { &*(current as *const Self) }
    }
}