#ifndef __T_ARRAY_HPP___
#define __T_ARRAY_HPP___

#include <iostream>

template <typename T>
class Array
{
private:
	T* ptr;
	int cap;
	int len;

public:
	Array();
	Array(int size);
	Array(const Array<T>& arr2);	// copy constructor

	~Array();		// destructor

	Array<T>& operator=(const Array<T>& arr2);

	T operator[] (int index) const;	// getter
	T& operator[] (int index);		// setter

	int capacity() const { return cap; }
	int length() const { return len; }

	void swap(Array<T>& arr2);

	void resize(int new_size);

};

template <typename T>
Array<T>::Array()
{
	len = 0;
	cap = 1000;

	ptr = new int[1000];
}

template <typename T>
Array<T>::Array(int size)
{
	len = 0;
	cap = size;

	ptr = new T[cap];
}

template <typename T>
Array<T>::Array(const Array<T>& arr2)
{
	len = arr2.len;
	cap = arr2.cap;

	ptr = new T[cap];

	for (int i = 0; i < len; i++)
	{
		ptr[i] = arr2.ptr[i];
	}

}

template <typename T>
Array<T>::~Array()
{
	if (ptr != NULL)
		delete[] ptr;
}

template <typename T>
Array<T>& Array<T>::operator=(const Array<T>& arr2)
{
	if (ptr != NULL)
		delete[] ptr;
	ptr = NULL;

	len = arr2.len;
	cap = arr2.cap;

	ptr = new T[cap];

	for (int i = 0; i < len; i++)
	{
		ptr[i] = arr2.ptr[i];
	}

	return *this;
}

template <typename T>
T Array<T>::operator[] (int index) const
{
	// check boundary of index
	// ...

	return ptr[index];
}

template <typename T>
T& Array<T>::operator[] (int index)
{
	// check boundary of index
	// ...

	return ptr[index];
}

template <typename T>
void Array<T>::resize(int new_size)
{
	if (cap >= new_size)
		return;

	T* ptr2 = new T[new_size];

	for (int i = 0; i < len; i++)
	{
		ptr2[i] = ptr[i];
	}


	delete[] ptr;
	ptr = ptr2;


	// return;
}

template <typename T>
void Array<T>::swap(Array<T>& arr2)
{
	T* tmp_ptr = ptr;
	ptr = arr2.ptr;
	arr2.ptr = tmp_ptr;

	int tmp = cap;
	cap = arr2.cap;
	arr2.cap = tmp;

	tmp = len;
	len = arr2.len;
	arr2.len = tmp;


}

#endif