use std::mem;

struct Node<T> {
    data: T,
    next: Option<Box<Node<T>>>,
}

pub struct SimpleLinkedList<T> {
    head: Option<Box<Node<T>>>,
}

impl<T> SimpleLinkedList<T> {
    pub fn new() -> Self {
        SimpleLinkedList {head: None}
    }

    pub fn len(&self) -> usize {
        let mut l = 0;
        let mut temp = self.head.as_ref();
        while temp.is_some() {
            l+=1;
            temp = temp.unwrap().next.as_ref();
        }
        l
    }

    pub fn push(&mut self, _element: T) {
        let new_node = Box::new(Node {
            data: _element,
            next: mem::replace(&mut self.head, None),
        });

        self.head = Some(new_node);
    }

    pub fn pop(&mut self) -> Option<T> {
        match mem::replace(&mut self.head, None) {
            None => None,
            Some(node) => {
                self.head = node.next;
                Some(node.data)
            }
        }
    }

    pub fn peek(&self) -> Option<&T> {
        Some(&self.head.as_ref().unwrap().data)
    }
}

impl<T: Clone> SimpleLinkedList<T> {
    pub fn rev(&self) -> SimpleLinkedList<T> {
        let mut temp = SimpleLinkedList {head: None};
        while self.head.is_some() {
            let t = self.pop().unwrap();
            let new_node = Box::new(Node {
                data: t.clone(),
                next: mem::replace(&mut temp.head, None),
            });

            temp.head = Some(new_node);
        }
        temp
    }
}

impl<'a, T: Clone> From<&'a [T]> for SimpleLinkedList<T> {
    fn from(_item: &[T]) -> Self {
        let mut temp = SimpleLinkedList::new();
        for i in _item {
            temp.push(i.clone());
        }
        temp
    }
}

impl<T> Into<Vec<T>> for SimpleLinkedList<T> {
    fn into(self) -> Vec<T> {
        vec![]
    }
}