#pragma once

template<typename T>
class TArray {

public:
    // Add a constructor with initializer_list
    TArray() : // Default constructor
        m_Size{ 0 },
        m_pElements{ nullptr }
    {

    }

    TArray(size_t size):
        m_Size{ size },
        m_pElements{new T[m_Size]}
    {

    }
    ~TArray()       // Default destructor
    {
        // Maybe we should delete all resources. But right now, just delete the array.
        delete[] m_pElements;
    }

    int GetQuantity() { return m_Size; }
    T* GetArray() { return m_pElements; }
    const T* GetArray() const { return m_pElements; }
    T& operator[](int i) { return m_pElements[i]; }
    const T& operator[](int i) const { return m_pElements[i]; }

    // Insert an element to the end of the array m_size is incremented by 1.
    void Append(const T& element)
    {
        T* pElements = new T[m_Size + 1];
        for (int i = 0; i < m_Size; i++)
        {
            pElements[i] = m_pElements[i];
        }
        pElements[m_Size] = element;
        delete[] m_pElements;
        m_pElements = pElements;
        m_Size++;
    }

    // Insert an element into index i so if i >= m_Size m_Size = i+1;
    // if i < m_Size m_pElements[i] = element;
    void SetElement(size_t i, const T& element)
    {
        if (i < m_Size)
        {
            m_pElements[i] = element;
        }
        else
        {
            T* pTempElements = new T[i +1];
            for (size_t aux = 0; aux < i; aux++)
            {
                pTempElements[aux] = m_pElements[aux];
            }
            pTempElements[i] = element;
            delete[] m_pElements;
            m_pElements = pTempElements;
            m_Size = i;

        }
    }

    // Remove the element with index i and shift the rest.
    void Remove(int i)
    {

    }

    // Clean all the elements into the array.
    void RemoveAll()
    {
        delete m_pElements;
        m_Size = 0;
    }

private:
    T* m_pElements;
    size_t m_Size;
};