/*****************************************
 * Instructions
 *  - Replace 'uwuserid' with your uWaterloo User ID
 *  - Select the current calendar term and enter the year
 *  - List students with whom you had discussions and who helped you
 *
 * uWaterloo User ID:  uwuserid @uwaterloo.ca
 * Submitted for ECE 250
 * Department of Electrical and Computer Engineering
 * University of Waterloo
 * Calender Term of Submission:  (Winter|Spring|Fall) 201N
 *
 * By submitting this file, I affirm that
 * I am the author of all modifications to
 * the provided code.
 *
 * The following is a list of uWaterloo User IDs of those students
 * I had discussions with in preparing this project:
 *    -
 *
 * The following is a list of uWaterloo User IDs of those students
 * who helped me with this project (describe their help; e.g., debugging):
 *    -
 *****************************************/

#ifndef LINKED_DEQUE_H
#define LINKED_DEQUE_H

#ifndef nullptr
#define nullptr 0
#endif

#include "ece250.h"
#include "Single_list.h"
#include "Exception.h"
#include <iostream>

template <typename Type>
class Linked_deque {
	private:
		static int const ARRAY_CAPACITY = 8;

		Single_list<Type *> list;
		int ifront;
		int iback;
		int deque_size;

	public:
		Linked_deque();
		Linked_deque( Linked_deque const & );
		~Linked_deque();

		bool empty() const;
		int size() const;
		int list_size() const;

		Type front() const;

		void swap( Linked_deque & );
		Linked_deque &operator=( Linked_deque );
		void push_front( Type const &obj );
		void push_back( Type const &obj );
		Type pop_front();
		Type pop_back();

	// Friends

	template <typename T>
	friend std::ostream &operator<<( std::ostream &, Linked_deque<T> const & );
};

template <typename Type>
Linked_deque<Type>::Linked_deque():
deque_size( 0 ) {
	// Empty constructor
}

template <typename Type>
Linked_deque<Type>::Linked_deque( Linked_deque const &deque ):
ifront( deque.ifront ),
iback( deque.iback ),
deque_size( deque.deque_size ) {
	// enter your implementation here
}

template <typename Type>
Linked_deque<Type>::~Linked_deque() {
	//
}

template <typename Type>
bool Linked_deque<Type>::empty() const {
	// enter your implementation here
	return true;
}

template <typename Type>
int Linked_deque<Type>::size() const {
	// enter your implementation here
	return 0;
}

// Do not change this implementation

template <typename Type>
int Linked_queue<Type>::list_size() const {
	return list.size();
}

template <typename Type>
Type Linked_deque<Type>::front() const {
	// enter your implementation here
	return Type();
}

template <typename Type>
void Linked_deque<Type>::swap( Linked_deque<Type> &deque ) {
	std::swap( list, deque.list );
	std::swap( deque_size, deque.deque_size );
	std::swap( ifront, deque.ifront );
	std::swap( iback, deque.iback );
}

template <typename Type>
Linked_deque<Type> &Linked_deque<Type>::operator=( Linked_deque<Type> rhs ) {
	swap( rhs );

	return *this;
}

template <typename Type>
void Linked_deque<Type>::push_front( Type const &obj ) {
	// enter your implementation here
}

template <typename Type>
void Linked_deque<Type>::push_back( Type const &obj ) {
	// enter your implementation here
}

template <typename Type>
Type Linked_deque<Type>::pop_front() {
	// enter your implementation here

	return Type();
}

template <typename Type>
Type Linked_deque<Type>::pop_back() {
	// enter your implementation here

	return Type();
}

// Do not modify this function

template <typename T>
std::ostream &operator<<( std::ostream &out, Linked_deque<T> const &deque ) {
	if ( deque.list.size() == 0 ) {
		out << "->0";
	} else if ( deque.list.size() == 1 ) {
		out << "->[ ";

		for ( int i = deque.ifront; i <= deque.iback; ++i ) {
			out << deque.list.front()[i] << " ";
		}

		out << "]->0";
	} else {
		out << "->";

		for ( Single_node<T *> *ptr = deque.list.head(); ptr != nullptr; ptr = ptr->next() ) {
			out << "[ ";

			if ( ptr == deque.list.head() ) {
				for ( int i = deque.ifront; i <= Linked_deque<T>::ARRAY_CAPACITY - 1; ++i ) {
					out << ptr->retrieve()[i] << " ";
				}
			} else if ( ptr == deque.list.tail() ) {
				for ( int i = 0; i <= deque.iback; ++i ) {
					out << ptr->retrieve()[i] << " ";
				}
			} else {
				for ( int i = 0; i <= Linked_deque<T>::ARRAY_CAPACITY - 1; ++i ) {
					out << ptr->retrieve()[i] << " ";
				}
			}

			out << "]->";
		}

		out << "0";
	}

	return out;
}

// Is an error showing up in ece250.h or elsewhere?
// Did you forget a closing '}' ?

#endif