#ifndef AGGREGATE_H
#define AGGREGATE_H
///////////////////////////////////////////////////////////
// Aggregate.h - Container for Iterator Skeleton Demo    //
//                                                       //
// Jim Fawcett, CSE776 - Design Patterns, Summer 2009    //
///////////////////////////////////////////////////////////

#include "IAggregate.h"
#include "Iterator.h"
#include <string>

template <typename T>
class ConcreteAggregate : public IAggregate<T>
{
public:
// ConcreteIterator doesn't need friendship because
// ConcreteAggregate defines index operator
  IIterator<T>& CreateIterator();
  ConcreteAggregate(size_t n=5);
  ConcreteAggregate(T* pArr, size_t size);
  ConcreteAggregate(const ConcreteAggregate<T>& agg);
  ~ConcreteAggregate();
  ConcreteAggregate<T>& operator=(const ConcreteAggregate<T>& agg);
  T& operator[](size_t n);
  T operator[](size_t n) const;
  size_t Size() const;
  void Append(const T& t);
  void Insert(IIterator<T>& iter, const T& t);
  void Remove(IIterator<T>& iter);
private:
  size_t count;
  size_t capacity;
  T* pArray;
  void Copy(T* pSrc, T* pDst, size_t SrcCount);
  void Replace(T*& pSrc, T*& pDst);
  void Rotate(size_t pos);
};

template <typename T>
IIterator<T>& ConcreteAggregate<T>::CreateIterator()
{
  return *new ConcreteIterator<T>(this);
}

template <typename T>
ConcreteAggregate<T>::ConcreteAggregate(size_t n) : count(0), capacity(n)
{
  if(n<0)
    throw std::exception("capacity must be non-negative");
  pArray = new T[n];
}

template <typename T>
ConcreteAggregate<T>::~ConcreteAggregate()
{
  delete [] pArray;
}

template <typename T>
void ConcreteAggregate<T>::Copy(T* pSrc, T* pDst, size_t SrcCount)
{
  for(size_t i=0; i<SrcCount; ++i)
    pDst[i] = pSrc[i];
}

template <typename T>
void ConcreteAggregate<T>::Replace(T*& pSrc, T*& pDst)
{
  delete [] pSrc;
  pSrc = pDst;
}

template <typename T>
void ConcreteAggregate<T>::Rotate(size_t pos)
{
  if(pos < 0 || count <= pos)
    throw std::exception("index out of range in rotate");
  T temp = pArray[count-1];
  for(size_t i=count-1; i>pos; --i)
    pArray[i] = pArray[i-1];
  pArray[pos] = temp;
}

template <typename T>
ConcreteAggregate<T>::ConcreteAggregate(T* pArr, size_t size) : count(size), capacity(2*size)
{
  pArray = new T[capacity];
  Copy(pArr, pArray, size);
  // don't delete pArr - we don't own it!
}

template <typename T>
ConcreteAggregate<T>::ConcreteAggregate(const ConcreteAggregate<T>& agg)
{
  size_t capacity = agg.capacity;
  Copy(agg.pArray, pArray=new T[capacity], count=agg.count);
}

template <typename T>
ConcreteAggregate<T>& ConcreteAggregate<T>::operator=(const ConcreteAggregate<T>& agg)
{
  if(this == &agg) 
    return *this;
  if(agg.count <= capacity)
  {
    Copy(agg.pArray, pArray, count=agg.count);
  }
  else
  {
    size_t capacity = 2*agg.count;
    T* pTemp = new T[capacity];
    Copy(agg.pArray, pTemp, count=agg.count);
    Replace(pArray, pTemp);
  }
  return *this;
}

template <typename T>
T& ConcreteAggregate<T>::operator[](size_t n)
{
  if(n<0 || count <= n)
    throw std::exception("index out of range in operator[]");
  return pArray[n];
}

template <typename T>
T ConcreteAggregate<T>::operator[](size_t n) const
{
  if(n<0 || count <= n)
    throw std::exception("index out of range in operator[]");
  return pArray[n];
}

template <typename T>
size_t ConcreteAggregate<T>::Size() const { return count; }

template <typename T>
void ConcreteAggregate<T>::Append(const T& t)
{
  if(count == capacity)
  {
    capacity *= 2;
    T* pTemp = new T[capacity];
    Copy(pArray, pTemp, count);
    Replace(pArray, pTemp);
  }
  pArray[count++] = t;
}

template <typename T>
void ConcreteAggregate<T>::Insert(IIterator<T>& iter, const T& t)
{
  Append(t);
  Rotate(iter.Offset());
}

template <typename T>
void ConcreteAggregate<T>::Remove(IIterator<T>& iter)
{
  size_t pos = iter.Offset();
  for(size_t i=pos; i<count; ++i)
    pArray[i] = pArray[i+1];
  --count;
}

#include <iostream>

template <typename T>
void Show(const std::string& msg, const IAggregate<T>& agg)
{
  std::cout << "\n  " << msg.c_str();
  std::cout << "\n " << std::string(msg.size()+2,'-') << "\n  ";
  for(size_t i=0; i<agg.Size(); ++i)
    std::cout << agg[i] << " ";
  std::cout << "\n";
}

#endif