#ifndef ARRAY_CPP
#define ARRAY_CPP

#include <sys/types.h>
#include "Array.h"

#if !defined (__INLINE__)
#define INLINE 
#include "Array.inl"
#endif /* __INLINE__ */

#include <algorithm>
#include <sstream>
#include <iostream>

template <typename T> 
Array<T>::Array (size_t size)
  : max_size_ (size),
    cur_size_ (size),
    next_push_back_index_ (0),
    default_value_ (nullptr),
    array_ (new T[size])
{
  std::cout << "Array(size_t)" << std::endl;  
}

template <typename T> 
Array<T>::Array (size_t size, 
		 const T &default_value)
  : max_size_ (size),
    cur_size_ (size),
    next_push_back_index_ (0),
    default_value_ (new T (default_value)),
    array_ (new T[size])
{
  std::cout << "Array(size_t, const T)" << std::endl;  
  std::fill_n (array_.get (),
               size,
               default_value);
}

// The copy constructor (performs initialization).

template <typename T> 
Array<T>::Array (const Array<T> &rhs)
   : max_size_ (rhs.cur_size_),
     cur_size_ (rhs.cur_size_),
     next_push_back_index_ (rhs.next_push_back_index_),
     default_value_ (rhs.default_value_
                     ? new T (*rhs.default_value_) 
                     : nullptr),
     array_ (new T[rhs.cur_size_])
{
  std::cout << "Array(const Array<T> &)" << std::endl;

  // If an exception is thrown here the destructors of the data
  // members clean everything up.
  std::copy (rhs.array_.get (),
             rhs.array_.get () + rhs.cur_size_,
             array_.get ());
}

// The move constructor (performs moves vs. copying).

#if defined(RVALUE_REFERENCES)

template <typename T> 
Array<T>::Array (Array<T> &&rhs)
  : max_size_ (rhs.max_size_),
    cur_size_ (rhs.cur_size_),
    next_push_back_index_ (rhs.next_push_back_index_),
    default_value_ (rhs.default_value_.release()),
    array_ (rhs.array_.release())
{
  std::cout << "Array(Array<T> &&)" << std::endl;  
}

#endif /* RVALUE_REFERENCES */

template <typename T> void
Array<T>::resize (size_t new_size)
{
  if (new_size > max_size_) 
    {
      // Create a new temp array, copy the old items into the temp
      // array, and delete the old array via the destructor of
      // scoped_array to ensure strong exception handling semantics.
      size_t physical_size = std::max (new_size, max_size_ * 2);

      std::unique_ptr<T> temp_array (new T[physical_size]);

      std::copy (array_.get (),
                 array_.get () + cur_size_,
                 temp_array.get ());

      max_size_ = physical_size;
      // If we're using a default value make sure to initialize the
      // newly resized array properly if that's necessary.
      if (default_value_.get () != nullptr && cur_size_ < new_size)
        std::fill_n (temp_array.get () + cur_size_,
                     new_size - cur_size_,
                     *default_value_);

      temp_array.swap (array_);
    }
  else if (cur_size_ < new_size)
    {
      std::unique_ptr<T> temp_array (new T[new_size]);

      std::copy (array_.get (),
                 array_.get () + cur_size_,
                 temp_array.get ());

      max_size_ = new_size;

      if (default_value_.get () != nullptr)
        std::fill_n (temp_array.get () + cur_size_,
                     new_size - cur_size_,
                     *default_value_);

      temp_array.swap (array_);
    }

  // We always update the cur_size_ to make the call to resize()
  // visible.
  cur_size_ = new_size;
}

template <typename T> void
Array<T>::swap (Array<T> &new_array)
{
  // All these calls have "no throw" exception semantics.
  std::swap (max_size_, new_array.max_size_);
  std::swap (cur_size_, new_array.cur_size_);
  std::swap (next_push_back_index_, new_array.next_push_back_index_);
  std::swap (default_value_, new_array.default_value_);
  array_.swap (new_array.array_);
}

// Move assignment operator (performs assignment). 

template <typename T> Array<T> &
Array<T>::operator= (const Array<T> &rhs)
{
  std::cout << "operator=(const Array<T> &)" << std::endl;  
  // Check for "self-assignment".
  if (this != &rhs) {
    // Create a temp array and then perform a swap to ensure strong
    // exception safety guarantees.
    Array<T>(rhs).swap(*this);
  }
  return *this;
}

#if defined (RVALUE_REFERENCES)
template <typename T> Array<T> &
Array<T>::operator= (Array<T> &&rhs)
{
  std::cout << "operator=(Array<T> &&)" << std::endl;  
  // Simply swap the rsh with this!
  swap(rhs);
}
#endif /* RVALUE_REFERENCES */

template <typename T> 
Array<T>::~Array (void)
{
  // Destructor is a no-op - just print some diagnostics.

  if (array_.get() == 0)
    std::cout << "null ~Array" << std::endl;  
  else
    std::cout << "~Array" << std::endl;  
}

// Set an item in the array at location index.  

template <typename T> void
Array<T>::set (const T &new_item, size_t index)
{
  if (!in_range (index))
    resize (index + 1);

  (*this)[index] = new_item;
}

template <typename T> void
Array<T>::push_back (const T &new_item)
{
  set (new_item, next_push_back_index_++);
}

// Get an item in the array at location index.

template <typename T> void
Array<T>::get (T &item, size_t index) const
{
   if (in_range (index))
     item = (*this)[index];
   else
     {
       std::stringstream index_str;
       index_str << static_cast <int> (index);
       throw std::out_of_range (index_str.str ());
     }
}

// Compare this array with <s> for equality.

template <typename T> bool
Array<T>::operator== (const Array<T> &s) const
{
  return cur_size_ == s.cur_size_
    && std::equal (array_.get (),
                   array_.get () + cur_size_,
                   s.array_.get ());
}

// Compare this array with <s> for inequality.

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

template <typename T>
Array_Iterator<T>::Array_Iterator (Array<T> &array, size_t pos)
  : array_ (array),
    pos_ (pos)
{
}

template <typename T>
Const_Array_Iterator<T>::Const_Array_Iterator (const Array<T> &array, size_t pos)
  : array_ (array),
    pos_ (pos)
{
}

#endif /* ARRAY_CPP */