#pragma once

#include<ostream>
#include<istream>

using std::ostream;
using std::ostream;

template<typename T>
class queue
{
	queue<T> *userQueue;   // Number in the queue
	int numAddBehind; // ++Number in the Behind
	int numDelFront;  // --Number in the Front
	int size;         // Size of the queue
	friend ostream& operator<<(ostream&, const queue<T>&);
	friend istream& operator>>(istream&, queue<T>&);
public:
	queue();
	queue(int);
	queue(const queue&);
	
	void setSize();

	void add(int); // Enqueue
	void del(); // Dequeue
	void display();
	
	int queueSize(); // Check the size of the queue
	queue<T> back(); // Return the last element of the queue
	queue<T> front(); // Return the first element of the queue
	queue<T> random(); // Return random element value specified by user.

	bool isFull();
	bool isEmpty();

	~queue();
};

/* 
1. Read string from user or file
2. Push in to the stack and queue

1. Pop the top of the stack
2. Pop the front of the queue
3. Compare the two chars
4. If they are equal, they are palindrome
*/

/* A Member Function Template 
   may not be Virtual

   template <class T> struct A 
   {
     template <class C> 
	 virtual void f(C);   
     error, virtual template function 
     virtual void g(); //  OK, g is not a template
   };
*/

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

using namespace std;

int main(int argc, char *argv[])
{
	queue<int> first;
	queue<int> second(first);

	while(!first.isFull())
	{
		first.add(10);
	}
	cout << "\nSize of the Queue : "
		<< first.queueSize() << "\n";
	first.display();

	cout << "\n\nThe last element of the queue is " 
		<< first.back() << "\n";
	
	cout << "\nThe First element of the queue is "
		<< first.front() << "\n";
	
	cout <<"\nThe random element of the queue is "
		<< first.random() << "\n";

	return 0;
}
// -----------------------------------------
template<typename T>
queue<T>::queue() : numAddBehind(-1), numDelFront(-1)
{
	cout << "How many the number of queue : ";
	cin >> size;

	setSize();
}
// -----------------------------------------
template<typename T>
queue<T>::queue(int userSize) 
: size(userSize), numAddBehind(-1), numDelFront(-1)
{
	setSize();
}
// -----------------------------------------
template<typename T>
queue<T>::queue(const queue& rhs)
{
	this->size = rhs.size;
	this->numAddBehind = rhs.numAddBehind;
	this->numDelFront = rhs.numDelFront;
	try
	{
		userQueue = new queue<T>[size];
	}
	catch(std::bad_alloc& rhs)
	{
		rhs.what();
	}
	for (int loop=0;loop<size;++loop)
	{
		this->userQueue[loop] = rhs.userQueue[loop];
	}
}
// -----------------------------------------
template<typename T>
queue<T>::~queue()
{
	delete [] userQueue;
}
// -----------------------------------------
template<typename T>
void queue<T>::setSize()
{
	try
	{
		userQueue = new queue<T>[size];
	}
	catch(std::bad_alloc& rhs)
	{
		rhs.what();
	}
	for (int loop=0;loop<size;++loop)
	{
		userQueue[loop] = 0;
	}
}
// -----------------------------------------
template<typename T>
void queue<T>::add(int number)
{
	if (!isFull())
	{
		++numAddBehind;
		++numDelFront;
		
		cout << "The queue[" << numAddBehind
			<< "] : ";

		userQueue[numAddBehind] = number;
	}
	else
	{
		cout << "Queue is Full!!!";
		--numAddBehind;
	}
}

// -----------------------------------------
template<typename T>
void queue<T>::del()
{
	if (!isEmpty())
	{
		for (int loop=0;loop<=size;++loop)
		{
			if (loop<=numAddBehind)
			{
				int temp;
				temp = userQueue[loop+1];
				userQueue[loop] = temp;
			}
			else
			{
				numAddBehind--;
				if (numAddBehind == -1)
				{
					numDelFront = -1;
				}
				else
				{
					numDelFront = 0;
				}// Located at first place
			}
		}
	}
	else
	{
		cout << "Queue is empty!!!";
	}

}

// -----------------------------------------
template<typename T>
void queue<T>::display()
{
	if (!isEmpty())
	{
		for (int loop=0;loop<size;++loop)
		{
			cout << "\nThe queue [" << loop
				<< "] : " << userQueue[loop];
		}
	}
}
// -----------------------------------------
template<typename T>
int queue<T>::queueSize()
{
	return size;
}
// -----------------------------------------
template<typename T>
queue<T> queue<T>::back()
{
	return *(userQueue + numAddBehind);
	// Pointer Notation 
}
// -----------------------------------------
template<typename T>
queue<T> queue<T>::front()
{
	int temp = size - 1;
	int frontPosition = numDelFront - temp;

	return *(userQueue + frontPosition);
}
// -----------------------------------------
template<typename T>
queue<T> queue<T>::random()
{
//	int random;
	cout << "Random Access Position : ";
//	cin >> random;

	int temp = random - 1;
    return *(userQueue + temp);
}
// -----------------------------------------
template<typename T>
bool queue<T>::isFull() // Test whether the queue is full
{
	if (numAddBehind == size-1)
	{
		return true;
	}
	else
	{
		return false;
	}
}
// -----------------------------------------
template<typename T>
bool queue<T>::isEmpty() // Test whether the queue is empty
{
	if (numAddBehind == -1 && numDelFront == -1)
	{
		return true;
	}
	else
	{
		return false;
	}
}
// -----------------------------------------
template<typename T>
ostream& operator<<(ostream& output, const queue<T>& rhs)
{
	output << rhs.userQueue << rhs.numAddBehind
		<< rhs.numDelFront << rhs.size;
	return output;
}
// ------------------------------------------
template<typename T>
istream& operator>>(istream& input, queue<T>& rhs)
{
	input >> rhs.numAddBehind >> rhs.numDelFront
		>> rhs.size;
	return input;
}
// ------------------------------------------

using namespace std;
instead of 
using std::ostream;
using std::ostream; // TYPO HERE (should be istream?)

/* include libraries, declare int main, etc. */

    queue<int> q;
    q.add( 5 );
    cout << q << endl;
/* end main, etc. */

template<typename T>
class queue
{
    queue<T> *userQueue;   // <---- HERE'S THE PROBLEM