#include <iostream>
#include <ostream>

class Queue
{
public:

  void push(int value)
  {
    head = new Node {value, head};
  }
    
  void pop()
  {
    if ( head == nullptr )
    {
      throw std::runtime_error{"List Empty in pop()"};
    }
            
    Node** last{&head};
        
    while ((*last)->next != nullptr)
    {
      last = &(*last)->next;
    }
        
    delete *last;
    *last = nullptr;
  }

  int front() const
  {
    if ( head == nullptr )
    {
      throw std::runtime_error{"List Empty in front()"};
    }
            
    Node* last{head};
        
    while ( last->next != nullptr )
    {
      last = last->next;
    }
        
    return last->value;
  }
    
  bool empty() const
  {
    return head == nullptr;
  }

// studentkod
  Queue()
    : head{}
  {}

  ~Queue()
  {
    while (!empty())
    {
      pop();
    }
  }

  Queue(Queue const& rhs)
    : head { clone(rhs.head) }
  {}

  Queue(Queue && rhs)
    : head {rhs.head}
  {
    rhs.head = nullptr;
  }

  Queue& operator=(Queue const& rhs)
  {
    Queue tmp {rhs};
    std::swap (tmp.head, head);
    return *this;
  }

  Queue& operator=(Queue && rhs)
  {
    std::swap(head, rhs.head);
    return *this;
  }
// end studentkod
    
private:

  struct Node
  {
    int value;
    Node* next;
  };
  Node* head;

// studentkod
  Node* clone(Node* node) const
  {
    if (node == nullptr)
    {
      return nullptr;
    }
    return new Node{node->value, clone(node->next)};
  }
// end studentkod

};

#define CATCH_CONFIG_MAIN
#include "catch.hpp"

TEST_CASE("all")
{
  Queue A{};
  A.push(2);
  A.push(5);
  A.push(8);
  CHECK( ! A.empty() );
  CHECK( A.front() == 2 );

  Queue B{A};
  CHECK( ! B.empty() );
  CHECK( B.front() == 2 );
    
  // Lägg till testfall här!

  B.pop();
  B.pop();
  CHECK( ! B.empty() );
  CHECK( B.front() == 8 );

  B.push(4);
  CHECK( ! B.empty() );
  CHECK( B.front() == 8 );

  A.pop();
  CHECK( ! A.empty() );
  CHECK( A.front() == 5 );
    
  A.pop();
  A.pop();
  CHECK( A.empty() );

  A = std::move(B);
  CHECK( B.empty() );
  CHECK( ! A.empty() );
  CHECK( A.front() == 8 );
    
  Queue C{std::move(A)};
  CHECK( A.empty() );
  CHECK( ! C.empty() );
  CHECK( C.front() == 8 );

  Queue D;
  D.push(3);
  CHECK( ! D.empty() );
  CHECK( D.front() == 3 );

  C = D;
  CHECK( ! C.empty() );
  CHECK( C.front() == 3 );

  C.pop();
  CHECK( C.empty() );
  CHECK( ! D.empty() );
  CHECK( D.front() == 3 );
    
  D.push(1);
  D.push(2);
  D.push(6);
  D.push(7);
}