#ifndef __DYNAMICAR_H__
#define __DYNAMICAR_H__
#include "stdafx.h"
#include "SdiObject.h"
#include "TypeInfo.h"
#include "MemAlloc.h"

namespace SDICW
{
    // Base Dynamic array
    class CDynamicAr : CSdiObject
    {
    public:
        // constructors
        CDynamicAr(void);
        virtual ~CDynamicAr(void);

        // methods
        sdVoid *GetData();
        const sdVoid *GetData() const;

        sdBool IsValidIndex(sdInt i) const;
        sdInt Count() const;

        sdVoid Insert(sdInt index, sdInt count, sdInt elementSize);
        sdVoid InsertZeroed(sdInt index, sdInt count, sdInt elementSize);

        sdInt Add(sdInt count, sdInt elementSize);
        sdInt AddZeroed(sdInt elementSize, sdInt count = 1);

        sdBool Shrink(sdInt elementSize);

        sdVoid Empty(sdInt elementSize, sdInt slack = 0);

        sdVoid Swap(sdInt elemA, sdInt elemB, sdInt elementSize);

        sdBool Remove(sdInt index, sdInt count, sdInt elementSize);
    protected:
        // reallocates the memory space on m_data
        sdVoid ReAllocate(sdInt elementSize);
        CDynamicAr(sdInt inNum, sdInt elementSize);

        // vars
        sdVoid *m_data; // memory space where we store the elements
        sdInt m_arrayNum; // number of elements in array
        sdInt m_arrayMax; // array capacity
    };

    typedef CDynamicAr ParentClass;

    // Dynamic array with template
    template<class _T> class TDynamicAr : public CDynamicAr
    {
    public:
        typedef _T ElementType;

        TDynamicAr() : ParentClass()
        {
        }

        TDynamicAr(sdInt num) : ParentClass(num, sizeof(ElementType)), m_iterator(NULL)
        {
        }

        TDynamicAr(const TDynamicAr &another)
            : ParentClass(another.m_arrayNum, sizeof(ElementType)), m_iterator(NULL)
        {
            // if its class type
            if(TTypeInfo<ElementType>::IsDestructorNeeded())
            {
                m_arrayNum = 0;
                for(int i = 0; i < another.Count(); i++)
                {
                    new(*this)ElementType(another[i]);
                }
            }
            else if(sizeof(ElementType) != 1) // if its not class type
            {
                for(int i = 0; i < m_arrayNum; i++)
                {
                    (*this)[i] = another[i];
                }
            }
            else // in another case copy the whole thing, we don't care
            {
                memcpy(&(*this)[0], &another[0], m_arrayNum * sizeof(ElementType));
            }
        }

        ~TDynamicAr()
        {
            Remove(0, m_arrayNum);
        }

        // operator overloads

        ElementType& operator[](sdInt i)
        {
            return ((ElementType *)m_data)[i];
        }

        const ElementType& operator[](sdInt i) const
        {
            return ((ElementType *)m_data)[i];
        }

        // concatenate with another dynamic array. e.g  arrayVar1 + arrayVar2
        TDynamicAr& operator+(const TDynamicAr& another)
        {
            if(this != &another)
            {
                for(sdInt i = 0; i < another.Count(); i++)
                {
                    new(*this)ElementType(another[i]);
                }
            }

            return *this;
        }

        TDynamicAr& operator+=(const TDynamicAr& another)
        {
            if(this != &another)
            {
                *this = *this + another;
            }

            return *this;
        }

        TDynamicAr& operator=(const TDynamicAr& another)
        {
            if(this != &another)
            {
                Empty(another.Count());

                for(sdInt i = 0; i < another.Count(); i++)
                {
                    new(*this)ElementType(another[i]);
                }
            }

            return *this;
        }

        // methods

        sdInt AddItem(const ElementType& element)
        {
            new(*this) ElementType(element);
            return Count() - 1; // return the index of the element
        }

        sdInt AddZeroed(sdInt count = 1)
        {
            return ParentClass::AddZeroed(sizeof(ElementType), count);
        }

        sdInt Add(sdInt count = 1)
        {
            return ParentClass::Add(count, sizeof(ElementType));
        }

        sdInt AddUnique(const ElementType& element)
        {
            for(int i = 0; i < m_arrayNum; i++)
            {
                // if its already in the array, return its index
                if((*this)[i] == element)
                {
                    return i;
                }
            }

            return AddItem(element);
        }

        sdVoid InsertItem(const ElementType& element, sdInt index)
        {
            sdInt idx = Insert(index);
            (*this)[idx] = element; // todo: debug this
        }

        sdVoid Insert(sdInt index, sdInt count = 1)
        {
            return ParentClass::Insert(index, count, sizeof(ElementType));
        }

        sdVoid InsertZeroed(sdInt index, sdInt count = 1)
        {
            return ParentClass::InsertZeroed(index, count, sizeof(ElementType));
        }

        ElementType Pop()
        {
            ElementType result = ((ElementType *)m_data)[m_arrayNum - 1];
            Remove(m_arrayNum - 1);
            return result;
        }

        ElementType& Last(sdInt c = 0)
        {
            return ((ElementType *)m_data)[m_arrayNum - count - 1];
        }

        const ElementType& Last(sdInt c = 0) const
        {
            return ((ElementType *)m_data)[m_arrayNum - count - 1];
        }

        sdVoid Shrink()
        {
            ParentClass::Shrink(sizeof(ElementType));
        }

        sdBool FindItem(const ElementType& item, __out sdInt& index) const
        {
            for(index = 0; index < m_arrayNum; index++)
            {
                if((*this)[index] == item)
                    return TRUE;
            }

            return FALSE;
        }
        sdInt FindItemIndex(const ElementType& item) const
        {
            for(sdInt index = 0; index < m_arrayNum; index++)
            {
                if((*this)[index] == item)
                    return index;
            }

            return INDEX_NONE;
        }

        sdBool Contains(const ElementType& item) const
        {
            return (FindItemIndex(item) != INDEX_NONE);
        }

        sdBool Remove(sdInt index, sdInt count = 1)
        {
            // if its class type, then we need to call its destructor
            if(TTypeInfo<ElementType>::IsDestructorNeeded())
            {
                for(sdInt i = index; i < index + count; i++ )
                {
                    (&(*this)[i])->~ElementType();
                }
            }

            return ParentClass::Remove(index, count, sizeof(ElementType));
        }

        sdBool Remove(const ElementType& element)
        {
            sdInt idx = FindItemIndex(element);
            return Remove(idx);
        }

        sdBool Empty(sdInt slack = 0)
        {
            if(TTypeInfo<ElementType>::IsDestructorNeeded())
            {
                for(sdInt i = 0; i < m_arrayNum; i++ )
                {
                    (&(*this)[i])->~ElementType();
                }
            }

            return ParentClass::Empty(sizeof(ElementType), slack);
        }

        sdVoid SwapItems(sdInt indexA, sdInt indexB)
        {
            ParentClass::Swap(indexA, indexB, sizeof(ElementType));
        }

        class Iterator
        {
        public:
            // constructor
            Iterator(TDynamicAr<ElementType>& inArray)
            {
                ++*this;
            }

            // operator overloads

            sdVoid operator++()
            {
                return m_array[m_index];
            }

            ElementType& operator*()
            {
                return m_array[m_index];
            }

            ElementType* operator->()
            {
                return &m_array[m_index];
            }

            operator sdBool() const
            {
                return m_index < m_array.Count();
            }

            sdVoid RemoveCurrent()
            {
                m_array.Remove(--m_index);
            }

            ElementType& GetCurrent() const
            {
                return m_index;
            }

            sdInt GetIndex() const
            {
                return m_array[m_index];
            }

            ElementType& GetNext() const
            {
                return m_array[m_index < m_array.Count() - 1 ? m_index + 1 : 0];
            }
            ElementType& GetPrev() const
            {
                return m_array[m_index ? m_index - 1 : m_array.Count() - 1];
            }
        private:
            TDynamicAr<ElementType>& m_array;
            sdInt m_index;
        };

        Iterator& GetIterator() const
        {
            if(m_iterator == NULL || !m_iterator)
            {
                m_iterator = new Iterator(this);
            }

            return m_iterator;
        }
    private:
        Iterator *m_iterator;
    };

    template<class T> sdVoid* operator new(size_t size, TDynamicAr<T>& ar)
    {
        int index = ar.CDynamicAr::Add(1, sizeof(T));
        return &ar[index];
    }
    template<class T> sdVoid* operator new(size_t size, TDynamicAr<T>& ar, sdInt index)
    {
        ar.CDynamicAr::Insert(index, 1, sizeof(T));
        return &ar[index];
    }

    // array exchanger
    template<class T> sdVoid ExchangeArray(TDynamicAr<T>& elemA, TDynamicAr<T>& elemB)
    {
        appMemorySwap(&elemA, &elemB, sizeof(CDynamicAr));
    }
}
#endif