#include "Array.h"


template <typename T>
DynamicArray<T>::DynamicArray(){
	arr = NULL;
	size = 0;
	capacity = 0;
}

template <typename T>
DynamicArray<T>::DynamicArray(T* const a, int s)
{
	size = s;
	capacity = s;
	arr = new T[s];
	for (int i = 0; i < s; i++)
		arr[i] = a[i];
}

template <typename T>
DynamicArray<T>::DynamicArray(int _capacity) {
	capacity = _capacity;
	if (capacity > 0)
		arr = new T[capacity];
	else
		arr = NULL;
	size = 0;
}

template <typename T>
DynamicArray<T>::DynamicArray(DynamicArray<T> const & o)
{
	
	capacity = o.capacity;
	size = o.size;
	arr = NULL;
	if (capacity > 0)
	{
		arr = new T[o.capacity];
		for (int i = 0; i < size; i++)
			arr[i] = o.arr[i];
	}
}
template<typename T>
DynamicArray<T>& DynamicArray<T>::operator=(DynamicArray<T> const & o)
{
	if (this != &o)
	{
		delete[] arr;
		capacity = o.capacity;
		size = o.size;
		if (capacity > 0)
			arr = new T[capacity];
		else
			arr = NULL;
		for (int i = 0; i < size; i++)
			arr[i] = o.arr[i];
	}
	return *this;
}

template<typename T>
DynamicArray<T>::~DynamicArray()
{
	delete[] arr;
	size = capacity = 0;
}

template <typename T>
T& DynamicArray<T>::operator[](int i){
	if (i>=0 && i<size)
		return arr[i];
	return arr[0];
}

template <typename T>
DynamicArray<T>& DynamicArray<T>::operator+=(const DynamicArray<T> &f) {
	T *tmp;
	int a = size;
	if (size + f.size >= capacity) {
		tmp = arr;
		capacity += f.capacity;
		arr = new T[capacity];
		for (a = 0; a < size; a++) {
			arr[a] = tmp[a];
		}
		delete[] tmp;
	}
	for (; a < size + f.size; a++) {
		arr[a] = f.arr[a - size];
	}
	size += f.size;
	return *this;
}

template <typename T>
DynamicArray<T> DynamicArray<T>::operator+(DynamicArray<T> const& o) const
{
	DynamicArray<T> tmp = *this;
	tmp += o;
	return tmp;
}

template <typename T>
bool DynamicArray<T>::operator==(const DynamicArray<T> &o) const
{
	if (size != o.size)  
		return 0;
	int i = 0, j = 0;
	while (i < size && j < o.size)
	{
		if (arr[i] != o.arr[i])  
			break;
		i++, j++;
	}
	if (i == size && j == o.size)  
		return 1;
	return 0;
}
template <typename T>
bool DynamicArray<T>::operator<(const DynamicArray<T> & o) const{
	if (*this == o)
		return 0;
	int i =0 , j = 0;
	while (arr[i] == o.arr[j] && i < size && j < o.size)
	{
		i++;
		j++;

	}
	if (i < size && j < o.size)
		return arr[i] < o.arr[i];
	if (i == size && j < o.size)
		return 1;
	return 0;

}

template<typename T>
bool DynamicArray<T>::operator>(DynamicArray<T> const& other) const
{
	return !*this == other && !*this < other;
}

template<typename T>
bool DynamicArray<T>::operator<=(DynamicArray<T> const& other) const
{
	return *this == other || *this < other;
}

template<typename T>
bool DynamicArray<T>::operator>=(DynamicArray<T> const& other) const
{
	return ! *this < other;
}

template<typename T>
bool DynamicArray<T>::operator!=(DynamicArray<T> const & other) const
{
	return !*this == other;
}

template <typename T>
void DynamicArray<T> ::addItemAtIndex(T const & x, int index)
{
	if (index >= 0 && index < capacity)
	{
		if (index < size)
		{
			for (int i = size; i > index; i--)
			{
				arr[i] = arr[i - 1];
			}
			arr[index] = x;
			++size;
		}

		else
		{
			arr[index] = x;
			for (int i = size; i < index; i++)
				arr[i] = T();
			size = index + 1;
		}
	}
}

template <typename T>
void DynamicArray<T>::deleteItemAtIndex(int index)
{
	if (index >= 0 && index < size)
	{
		for (int i = index; i < size  - 1; i++)
		{
			arr[index] = arr[index + 1]
		}
		--size;
	}
}


template <typename T>
ostream& operator<< (ostream& o, DynamicArray<T> const & x)
{
	DynamicArray<T>();
	if (x.size > 0)
	{
		o << "[" << x.arr[0];
		for (int i = 1; i < x.size; i++)
			o << ", " << x.arr[i];
		return o << "]\n";
	}
	
	return o << "[]\n";
}



template <typename T>
istream& operator >> (istream & i, DynamicArray<T>& x)
{
	int s;
	i >> s;
	if (s <= 0)
	{
		x = DynamicArray<T>();
		return i;
	}
	T* arr = new T[s];
	for (int j = 0; j < s; j++)
		i >> arr[j];
	x = DynamicArray<T>(arr, s);
	delete[] arr;
	return i;
}

template <typename T>
T DynamicArray<T> ::min() const
{
	if (size > 0)
	{
		T m = arr[0];
		for (int i = 1; i < size; i++)
		if (arr[i] < m)
			m = arr[i];
	}
	else
		m = T();

	return m;
}

template <typename T>
T DynamicArray<T> ::max() const
{
	if (size > 0)
	{
		T m = arr[0];
		for (int i = 1; i < size; i++)
		if (arr[i] > m)
			m = arr[i];
	}
	else
		m = T();

	return m;
}

template <typename T>
void DynamicArray<T> ::sort()
{
	if (size >= 2)
	{
		for (int i = 0; i < size; i++)
		{
			int index = i;
			for (int j = i + 1; j < size; j++)
				if (arr[j] < arr[index])
					index = j;
			swap(arr[i], arr[index]);

		}
	}

}