#include <iostream>
#include "queue.h"

using namespace std;

void QueueInfo(QueueT q);
bool QueueTest(QueueT q, int size,  ItemT compare[]);


// a bad alternative implementation of a queue.
void Add(ItemT l[], int & size, ItemT i);
void Delete(ItemT l[], int & size);

int main() {

    ItemT compareData[QUEUE_MAX]; 
    int compareSize = 0;
    int i;

    QueueT q;

    // test the empty queue
    InitQueue(q);
    QueueTest(q,compareSize,  compareData);
    //QueueInfo(q);

    // check a single item
    Enqueue(q,1);
    Add(compareData, compareSize, 1);
    QueueTest(q,compareSize,  compareData);

   
    // check after the item has been removed again
    Dequeue(q);
    Delete(compareData, compareSize);
    QueueTest(q,compareSize,  compareData);

    // try filling the queue.
    for(i=0;i<QUEUE_MAX;i++) {
        Enqueue(q,i);
        Add(compareData, compareSize, i);
        QueueTest(q,compareSize, compareData);
    }

    // it should be full, let's try an overflow
    cout << "The next thing you see should be an error message " << endl;
    Enqueue(q,999);
    QueueTest(q,compareSize, compareData);
    cout << endl;

    // delete a few
    Dequeue(q);
    Delete(compareData, compareSize);
    QueueTest(q,compareSize, compareData);

    Dequeue(q);
    Delete(compareData, compareSize);
    QueueTest(q,compareSize, compareData);

    // this should make the back wrap back around 0.
    // Try adding a few more
    Enqueue(q,100);
    Add(compareData, compareSize, 100);
    QueueTest(q,compareSize, compareData);

    Enqueue(q,101);
    Add(compareData, compareSize, 101);
    QueueTest(q,compareSize, compareData);

    // it should be full, let's try an overflow
    cout << "The next thing you see should be an error message " << endl;
    Enqueue(q,999);
    cout << endl;

    // let's run it back down to 0
    while(compareSize > 0) {
        Dequeue(q);
        Delete(compareData, compareSize);
        QueueTest(q,compareSize, compareData);
    }
   
    // should not be able to dequeue at this point.
    cout << "The next thing you see should be an error message " << endl;
    if (ITEM_DEFAULT != Dequeue(q)) {
       cout << "Error, default item from empty queue is bad " << endl;
    }
    QueueTest(q,compareSize, compareData);
    cout << endl;

    return 0;
}

bool QueueTest(QueueT q, int size, ItemT compare[]){
    bool fail = false;
    QueueT tmp;

    int i;

    tmp = q;

    // check the status values.
    if (size != Size(q)) {
       cout << "The size is wrong" << endl;
       fail = true;
    }

    if ((size==0) != IsEmpty(q)) {
       cout << "The empty status is wrong " << endl;
       fail = true;
    }

    if ((size==QUEUE_MAX) != IsFull(q)) {
       cout << "The full status is wrong " << endl;
       fail = true;
    }

    for(i=0;i<size;i++) {
       if (Front(tmp) != compare[i] ) {
          fail = true;
	  cout << "Contents not valid " << endl;
	  cout << "\tGot      : " << Front(tmp) << endl;
	  cout << "\tExpected : " << compare[i] << endl;

       }
       Dequeue(tmp);
    }

    if(fail) {
       QueueInfo(q);
    }
    return fail;
}

void YesOrNo(bool test, string word) {
   if (test) {
      cout << "\t" << word << endl;
   } else {
      cout << "\tnot " << word << endl;
   }
}

void QueueInfo(QueueT q) {
   
   cout << "The queue is " << endl;

   YesOrNo(IsEmpty(q), "empty");
   YesOrNo(IsFull(q), "full"); 
   cout <<"\tSize: " << Size(q) << endl;

   cout <<"\tContents: " ;
   while (!IsEmpty(q)) {
      cout << Dequeue(q) << " ";
   }
   cout << endl;
   cout << "  -----------------------------" << endl;

   return;
}

void Add(ItemT l[], int & size, ItemT i){
    if (size < QUEUE_MAX) {
       l[size] = i;
       size++;
    }
    return;
}

void Delete(ItemT l[], int & size){
    int i;
    for(i=1;i<size;i++) {
       l[i-1] = l[i];
    }
    size --;
    return;
}