#ifndef _LINKLIST_HPP_
#define _LINKLIST_HPP_
#include<iostream>
#include "Node.hpp"
#include<stdexcept>

template<typename T>
class LinkList {
  private:
    Node<T>* head_{nullptr};
    Node<T>* tail_{nullptr};
    size_t size_;
  public:
    LinkList() = default;
    LinkList(Node<T>* head, Node<T>* tail, size_t size) : head_{head}, tail_{tail}, size_{size} {}
    LinkList(const LinkList<T>& o);
    LinkList(LinkList<T>&& o);
    LinkList<T>& operator=(const LinkList<T>& o);
    LinkList<T>& operator=(const LinkList<T>&& o);
    size_t size() { return size_; }
    void push_back(const T&);
    void push_back(const T&&);
    void pop();
 //   void print(LinkList<T>& queue);
    class Iterator;
    Iterator begin();
    Iterator end();
};

template<typename T>
LinkList<T> :: LinkList(const LinkList<T>& o) {
  *(this) = o;
}

template<typename T>
LinkList<T> :: LinkList(LinkList<T>&& o) {
  *(this) = std::move(o);
}

template<typename T>
LinkList<T>& LinkList<T> :: operator=(const LinkList<T>& o) {
  delete head_;
  head_ = nullptr;
  head_ = o.head;
  tail_ = o.tail_;
  size_ = o.size_;
  o.head_ = nullptr;
  o.tail_ = nullptr;
  o.size_ = 0;
  return *this;
}

template<typename T>
LinkList<T>& LinkList<T> :: operator=(const LinkList<T>&& o) {
  delete head_;
  head_ = nullptr;
  head_ = o.head_;
  tail_ = o.tail_;
  size_ = o.size_;
  o.head_ = nullptr;
  o.tail_ = nullptr;
  o.size_ = 0;
  return *this;
}

template<typename T>
void LinkList<T> :: push_back(const T& value) {
  if(head_ == nullptr) {
    Node<T>* newNode = new Node<T>(value);
    head_ = newNode;
    tail_ = head_;
    size_++;
  }
  else {
    tail_ = makeAndLinkNode(tail_, value);
    ++size_;
  }
}

template<typename T>
void LinkList<T> :: push_back(const T&& value) {
  if(head_ == nullptr) {
    Node<T>* newNode = new Node<T>(value);
    head_ = newNode;
    tail_ = head_;
    size_++;
  }
  else {
   tail_ = makeAndLinkNode(tail_, value);
    ++size_;
  }
}

template<typename T>
void LinkList<T> :: pop() {
  if(head_ == nullptr) throw std::out_of_range("List is empty!");
  else {
    Node<T>* current = head_;
    while(current->advance() && current -> advance() -> advance() != nullptr) {
      current = current -> advance();
    }
    delete current->advance();
    current -> linkTo(nullptr);
    --size_;
  }
}

template<typename T>
class LinkList<T> :: Iterator {
  private:
    Node<T>* myNode_{nullptr};
    Node<T>* prevNode_{nullptr};
  public:
    Iterator() = default;
    Iterator(Node<T>* prevNode, Node<T>* myNode) : prevNode_{prevNode}, myNode_{myNode} {}

    Iterator& operator++() {
      prevNode_ = myNode_;
      if(myNode_)
        myNode_ = myNode_ -> advance();
      return *this;
    }

    Iterator operator++(int) {
      auto oldThis = *this;
      ++(*this);
      return oldThis;
    }

    T& operator*() { return **myNode_; }

    bool operator==(const Iterator& o) const {
      return myNode_ == o.myNode_;
    }

    bool operator!=(const Iterator& o) const {
      return !operator == (o);
    }

    friend class LinkList<T>;
};

template<typename T>
typename LinkList<T> :: Iterator LinkList<T> :: begin() {
  return Iterator(nullptr, head_);
}

template<typename T>
typename LinkList<T> :: Iterator LinkList<T> :: end() {
  return Iterator(tail_, nullptr);
}
#endif