#include <iostream>
#include <string>
#include "QueueT.h"
#include <exception>

using namespace std;

void DeleteQueue(QueueNodeT * head);

struct QueueNodeT{
      string data;
      QueueNodeT* next;
};

QueueT::QueueT() {
    front = nullptr;
    back = nullptr;
    count =0;
}

void CopyList(QueueNodeT * src, QueueNodeT * & front, QueueNodeT * & back) {
     QueueNodeT * tmp;

     front = nullptr;
     back = nullptr;

     while (src != nullptr) {

          try {
              tmp  = new QueueNodeT;
          } catch (bad_alloc & e) {
              // delete the existing list.
              DeleteQueue(front);
              throw e;
          }
          tmp ->next = nullptr;
          tmp->data = src->data;

          if (back == nullptr) {
              back = tmp;
              front = tmp;
          } else {
              back->next = tmp;
              back = tmp;
          }
          src = src->next;
     }
     return;
}


QueueT::QueueT(QueueT & src){
    front = nullptr;
    back = nullptr;
    // deep copy of all dynamic memory
    CopyList(src.front, front, back);
    // shallow copy of everything else
    count = src.count;

    return;
}



/*
void DeleteQueue(QueueNodeT * head) {
    QueueNodeT * tmp;

    while (head != nullptr) {
        tmp = head;
        head = head->next;
        delete tmp;
    }

    return;
}
*/

void DeleteQueue(QueueNodeT * head) {
    if (head == nullptr) {
        return;
    }
    DeleteQueue(head->next);
    delete head;
}


QueueT::~QueueT(){
    DeleteQueue(front);
    front = nullptr;
    back = nullptr;
    count = 0;

    return;
}

QueueT & QueueT::operator =(QueueT & src){
     // check to make sure we are not doing a = a
     if  ( this != &src) {
             if (front != nullptr) {
                 DeleteQueue(front);
                 front = nullptr;
                 back = nullptr;
             }
             CopyList(src.front, front, back);
             count = src.count;
     }

     return *this;
     // a = b =c = d
}

void QueueT::Enqueue(string s){
     QueueNodeT * tmp = nullptr;

     try {
         tmp = new QueueNodeT;
     } catch (bad_alloc & e) {
         throw e;
     }

     tmp->data = s;
     tmp->next = nullptr;

     if (front == nullptr) {
         front = tmp;
     } else {
         back->next = tmp;
     }
     back = tmp;
     count++;

     return;
}

void QueueT::Dequeue(void){

     QueueNodeT * tmp;

     if (front == nullptr) {
         cout << "The queue is empty, no need to dequeue" << endl;
     } else {
         tmp = front;
         front = front->next;
         if (front == nullptr) {
            back = nullptr;
         }
         delete tmp;
         count--;
     }

     return;
}


string QueueT::Front(void) const{
      if (front != nullptr ) {
          return front->data;
      } else {
          throw logic_error("Attempt to run Front on an empty queue");
          //  try {
          //      data = q.Front();
          //  } catch (logic_error & e){
          //      // right here
          //  }
          //cerr << "The queue is empty, you can't do Front" << endl;
          //return "Can't do a Front on an empty queue";
      }
}

size_t QueueT::Size(void) const{
     return count;
}

bool QueueT::IsEmtpy(void) const{
     return count == 0;
}

bool QueueT::IsFull(void) const{
    return false;
}