#ifndef _QUEUE_INTERFACE_H_
#define _QUEUE_INTERFACE_H_
#include "LinkList.hpp"
#include<iostream>

template <typename Type>
class queue_interface
{
    public:
        void push(const Type & val);
        void push(Type&& val);
        Type& front();
        const Type& front() const;
        Type& back();
        const Type& back() const;
        void pop();
        size_t size() const;
        bool empty() const;
        void printQ();
        ~queue_interface() = default;
        template<typename U>
        friend std::ostream& operator<<(std::ostream& os, queue_interface<U>& queue);
    private:
        LinkList<Type> myQueue;
};

template<typename U>
std::ostream& operator<<(std::ostream& os, queue_interface<U>& queue) {
    os << queue.value() << std::endl;
    return os;
}

template<typename T>
void queue_interface<T> :: printQ() {
  for(auto it = myQueue.begin(); it != myQueue.end(); ++it)
    std::cout << *it << std::endl;
}

template<typename Type>
void queue_interface<Type> :: push(const Type& val) {
  myQueue.push_back(val);
}

template<typename Type>
void queue_interface<Type> :: push(Type&& val) {
  myQueue.push_back(val);
}

template<typename Type>
Type& queue_interface<Type> :: front() {
  if(myQueue.size() == 0) throw std::out_of_range("Stack is empty!");
  else {
   auto begin = myQueue.begin();
   return *begin;
   }
}

template<typename Type>
const Type& queue_interface<Type> :: front() const {
  if(myQueue.size() == 0) throw std::out_of_range("Stack is empty!");
  else {
    auto begin = myQueue.begin();
   return *begin;
  }
}

template<typename Type>
Type& queue_interface<Type> :: back() {
  if(myQueue.size() == 0) throw std::out_of_range("Stack is empty!");
  else {
    auto end = myQueue.end();
   return *end;
}
}

template<typename Type>
const Type& queue_interface<Type> :: back() const {
  if(myQueue.size() == 0) throw std::out_of_range("Stack is empty!");
  else {
    auto end = myQueue.end();
   return *end;
  }
}

template<typename Type>
bool queue_interface<Type> :: empty() const {
  if(myQueue.size() == 0)
  return true;
  else return false;
}

template<typename Type>
void queue_interface<Type> :: pop() {
  myQueue.pop();
}

#endif