#include<iostream>
#include <queue>


template <typename T>
class queueArr{
private:
T *q_array;
int q_capacity;
int q_size = 0, q_front = 0, q_back = 0;
public:
queueArr(int newCapacity);
bool isEmpty();
int qSize();
void displayFront();
void displayBack();
void enqueue(T newData);
void dequeue();
void clear();

//big three
};

template <typename T>
queueArr<T>::queueArr(int newCapacity) {
q_capacity = newCapacity;
q_array = new T[q_capacity];
}

template <typename T>
bool queueArr<T>::isEmpty(){
return q_size == 0;
}

template <typename T>
int queueArr<T>::qSize() {
return q_size;
}

template <typename T>
void queueArr<T>::displayFront() {
std::cout << "Front: " << q_array[q_front%q_capacity] << std::endl;
}

template <typename T>
void queueArr<T>::displayBack() {
std::cout << "Back: " << q_array[q_back%q_capacity] << std::endl;
}

template <typename T>
void queueArr<T>::clear() {
q_size = 0;
q_front = 0;
q_back = 0;
}

template <typename T>
void queueArr<T>::enqueue(T newData) {
//check if full
if(q_size==q_capacity){
std::cout << "Queue is Full.\n";
return;
}

//if empty
if(isEmpty()){
q_back = q_front;
q_array[q_front%q_capacity] = newData;
std::cout << newData << " was successfully enqueued.\n";
q_size++;
return;
}

//if normal
q_back++;
q_array[q_back%q_capacity] = newData;
std::cout << newData << " was successfully enqueued.\n";
q_size++;
}

template<typename T>
void queueArr<T>::dequeue() {
T temp;
//check if empty
if(isEmpty()){
std::cout << "Queue is Empty.\n";
return;
}

//check if only one element
if((q_front == q_back) && !(isEmpty())){
temp = q_array[q_front%q_capacity];
std::cout << temp << " was successfully dequeued.\n";
clear();
return;
}
//if normal
temp = q_array[q_front++%q_capacity];
//q_front++;
std::cout << temp << " was successfully dequeued.\n";
q_size--;
}

//6 Separate implementation of class queueArr from main.cpp
//7 create function prototype for display all

int main(){
//1 create an array of students with the names of your favorite classmates
std::string students [5] = {"Christian", "Thirdy", "MJ", "Maverick", "Niemo"};

//2 create a queue

std::queue<std::string> stud;
stud.push("Christian");
stud.push("Thirdy");
stud.push("MJ");
stud.push("Maverick");
stud.push("Niemo");
//3 loop structure to enqueue all students

//4 show front
//5 show end

//9 call display all
}

//8 define display all

#include <queue>

std::queue<std::string> stud;

// ... something ...

//6 Separate implementation of class queueArr from main.cpp
// You do know the #include and what it does?

//7 create function prototype for display all
void displayall( /*???*/ );

int main(){
    //1 create an array of students with the names of your favorite classmates
    std::string students [5] = {"Christian", "Thirdy", "MJ", "Maverick", "Niemo"};

    //2 create a queue
    queueArr<std::string> stud( 42 );

    //3 loop structure to enqueue all students
    // enqueue from students into stud
    for ( auto s : students ) {
        // something
    }

    //4 show front
    //5 show end
    // You have member functions for these

    //9 call display all
    displayall( stud )
}

//8 define display all
void displayall( /*???*/ )
{
    // whatever it takes
}

#include<iostream>

template <typename T>
class queueArr {
private:
	T* q_array {};
	size_t q_capacity {}, q_size {}, q_front {}, q_back {};

public:
	queueArr(size_t newCapacity);
	bool isEmpty() const;
	bool isFull() const;
	size_t qSize() const;
	void displayFront() const;
	void displayBack() const;
	void enqueue(T newData);
	void dequeue();
	void clear();
	void displayAll() const;

	~queueArr() {
		delete[] q_array;
	}

	// These need to be provided if needed
	queueArr(const queueArr&) = delete;
	queueArr& operator=(const queueArr&) = delete;
};

template <typename T>
queueArr<T>::queueArr(size_t newCapacity) : q_capacity { newCapacity }, q_array { new T[newCapacity] } {}

template <typename T>
bool queueArr<T>::isEmpty() const {
	return q_size == 0;
}

template <typename T>
bool queueArr<T>::isFull() const {
	return q_size == q_capacity;
}

template <typename T>
size_t queueArr<T>::qSize() const {
	return q_size;
}

template <typename T>
void queueArr<T>::displayFront() const {
	if (isEmpty())
		std::cout << "Queue is empty\n";
	else
		std::cout << "Front: " << q_array[q_front] << '\n';
}

template <typename T>
void queueArr<T>::displayBack() const {
	if (isEmpty())
		std::cout << "Queue is empty\n";
	else
		std::cout << "Back: " << q_array[q_back ? (q_back - 1): q_capacity - 1] << '\n';
}

template <typename T>
void queueArr<T>::clear() {
	q_size = 0;
	q_front = 0;
	q_back = 0;
}

template <typename T>
void queueArr<T>::enqueue(T newData) {
	if (isFull())
		std::cout << "Queue is Full.\n";
	else {
		q_array[q_back] = newData;
		q_back = (q_back + 1) % q_capacity;
		++q_size;
		std::cout << newData << " was successfully enqueued.\n";
	}
}

template<typename T>
void queueArr<T>::dequeue() {
	if (isEmpty())
		std::cout << "Queue is Empty.\n";
	else {
		const auto temp { q_array[q_front] };

		q_front = (q_front + 1) % q_capacity;
		--q_size;
		std::cout << temp << " was successfully dequeued.\n";
	}
}

template<typename T>
void queueArr<T>::displayAll() const {
	//std::cout << "front: " << q_front << "  back: " << q_back << '\n';
	for (size_t i { q_front }, c {}; c < q_size; i = (i + 1) % q_capacity, ++c)
		std::cout << q_array[i] << '\n';

	std::cout << '\n';
}

int main() {
	//1 create an array of students with the names of your favourite classmates
	const std::string students[] { "Christian", "Thirdy", "MJ", "Maverick", "Niemo" };

	//2 create a queue
	queueArr<std::string> stud(5);

	//3 loop structure to enqueue all students
	for (const auto& s : students)
		stud.enqueue(s);

	//4 show front
	stud.displayFront();

	//5 show end
	stud.displayBack();

	//9 call display all
	stud.displayAll();

	stud.dequeue();
	stud.dequeue();

	stud.enqueue("qwer");
	stud.enqueue("asd");
	stud.dequeue();

	stud.displayAll();
}