ain#pragma once
#include <stdexcept>

template <class T>
class Stack
{
public:
	// Constructor and destructor
	// Default constructor
	Stack();
	// Constructor that sets size of stack
	Stack(int n);
	// Copy constructor
	Stack(const Stack & st);
	// Destructor
	~Stack();
	// Overloaded assignment operator
	Stack& operator=(const Stack & st);

	// Mutators
	//PRE: Stack is not full
	//PARAM: value = value to be inserted
	//POST: value is inserted at the top of the stack
	void push(T value);
	//PRE: Stack is not empty
	//POST: removes and returns value at the top of the stack
	T pop();

	// Accessor
	//PRE: Stack is not empty
	//POST: returns value at the top of the stack
	T peek() const;
	//PRE: 
	//POST: returns true if stack is empty, otherwise false
	bool empty() const;

private:
	// Array version
	T* arr;
	int top;
	int arrSize;
	void copyStack(const Stack & st);
};

// Array Version
// Default constructor - creates Stack of size 10
template <class T>
Stack<T>::Stack()
{
	top = 0;
	arrSize = 10;
	arr = new T[arrSize];
}

// Constructor(int) - creates Stack of size n
template <class T>
Stack<T>::Stack(int n)
{
	top = 0;
	arrSize = n;
	arr = new T[arrSize];
}

// Copy constructor
template <class T>
Stack<T>::Stack(const Stack & st)
{
	copyStack(st);
}

// Destructor
template <class T>
Stack<T>::~Stack()
{
	delete[] arr;
}

// Overloaded assignment operator
template <class T>
Stack<T>& Stack<T>::operator=(const Stack & st)
{
	if(this != &st){
		delete[] arr;
		copyStack(st);
	}
	return *this;
}

// Mutators
//PRE: Stack is not full
//PARAM: value = value to be inserted
//POST: value is inserted at the top of the stack
template <class T>
void Stack<T>::push(T value)
{
	if(top == arrSize) throw std::length_error("stack full");
	arr[top++] = value;
}

//PRE: stack is not empty
//POST: removes and returns value at the top of the stack	
template <class T>
T Stack<T>::pop()
{
	if(top == 0) throw std::out_of_range("stack empty");
	return arr[--top];
}

// Helper method for copy constructor and operator=
//PRE: 
//POST: copies st to the calling object
//PARAM: st = stack to be copied
template <class T>
void Stack<T>::copyStack(const Stack & st)
{
	arrSize = st.arrSize;
	top = st.top;
	// Make a new array
	arr = new T[arrSize];
	// Copy content of parameter
	for(int i=0; i < top; i++){
		arr[i] = st.arr[i];
	}
}

// Accessors
//Returns value at the top of the stack
//PRE: stack is not empty
//POST: returns arr[top-1]
template <class T>
T Stack<T>::peek() const
{
	if(top == 0) throw std::out_of_range("stack empty");
	return arr[top-1];
}

// Returns the number of items stored in the stack
//PRE: 
//POST: returns top
template <class T>
bool Stack<T>::empty() const
{
	return top == 0;
}