#include <Arduino.h>
#include <tiny-collections.h>

using namespace tc; // Import tc::* into the global namespace

// Create a const int array and wrap it in a useful interface.
// This is similar to declaring `const int myFixedArray[4] = { 1, 2, 3, 4 };`
// but lets you use methods like `size()`.
constexpr const_array<int, 4> myFixedArray = { 1, 2, 3, 4 };

void useImmutableArray() {
  // This prints the following to the terminal:
  //
  //   Fixed array includes 4 items:
  //   1 2 3 4

  Serial.print("Fixed array includes ");
  Serial.print(myFixedArray.size());
  Serial.println(" items:");

  // const_array<T, N> supports the iterator interface:
  for (int *it = myFixedArray.begin(); it != myFixedArray.end(); it++) {
    Serial.print(*it);
    Serial.print(" ");
  }
  Serial.println("");

}

// Create an expandable array of Strings.
// const_array<T, N>, vector<T> work with any basic scalar types or classes.
vector<String> someStrings;

void setup() {
  // Add strings to the `someStrings` vector.
  someStrings.push_back(String("foo")); // appends the string
  someStrings.push_back("bar"); // invokes String(const char*) constructor and appends it.

  Serial.print("Number of strings: ");
  Serial.println(someStrings.size()); // number of dereferenceable items

  Serial.print("Capacity: ");
  Serial.println(someStrings.capacity()); // total backing array size, may be larger.

  Serial.print("First string: ");
  Serial.println(someStrings[0]); // dereference works like an array.

  // Alternate iteration interface using 'foreach' syntax.
  Serial.println("All strings:");
  for (auto str: someStrings) {
    Serial.println(str);
  }

  useImmutableArray();
}

void loop() {
  delay(10);
}

template<typename T, size_t N> class const_array {
public:
  // note: all constructors are implicit defaults since this is an aggregate.

  /** Default copy constructor. */
  constexpr const_array(const_array<T, N> &other) = default;
  /** Move constructor; essentially the same as "copy" since `other` remains immutable. */
  constexpr const_array(const_array<T> &&other) noexcept = default;

  // No receive-copy operator; array components are fixed.
  const_array<T, N> &operator=(const_array<T, N> &copy_src) = delete;

  // No receive-move operator; array components are fixed.
  const_array<T, N> &operator=(const_array<T, N> &&move_src) = delete;

  // Indexed dereference to `const` elements.
  const T& operator[](size_t idx) const;

  size_t size() const; // number of valid elements.
  size_t capacity() const; // same as size().
  bool empty() const; // true if size() == 0.

  /** Return true if you can use this subscript index safely. */
  bool in_range(size_t idx) const;

  // C++ iterator interface.
  const T* begin() const;
  const T* end() const;
};

template<typename T> class vector {
public:
  vector();
  vector(size_t initial_cap);
  vector(const vector<T> &other); /** Copy constructor. */
  template<size_t N> vector(const T (&arr)[N]); /** Copy constructor from explicit array. */
  vector(const const_array<T> &arr); /** Copy constructor from const_array<T>. */
  vector(std::initializer_list<T> lst); /** Copy constructor from brace-initialized list. */
  vector(vector<T> &&other) noexcept; /** Move constructor. */
  ~vector();

  // Move operator; assume move_src's data.
  vector<T> &operator=(vector<T> &&move_src) noexcept;
  // Copy operator: duplicate the elements of another vector<T>.
  vector<T> &operator=(const vector<T> &copy_src);
  // Copy operator: duplicate the elements of a const_array<T>
  vector<T> &operator=(const const_array<T> &copy_src);

  // Indexed dereference
  const T& operator[](size_t idx) const;
  T& operator[](size_t idx);

  size_t size() const; // number of valid elements.
  size_t capacity() const; // number of memory slots provisioned in array.
  bool empty() const; // true if size() == 0
  void reserve(size_t minCapacity); // Ensure minimum size of backing array.
  void clear(); // discard elements so size() == 0

  // Return true if you can use this subscript index safely.
  // tc::vector<T> does not include the `at(size_t i)` function from std::vector,
  // since it never throws exceptions.
  bool in_range(size_t idx) const;

  // Append item to the vector, allocating more space if necessary. Returns the
  // index where the item was stored.
  size_t push_back(const T& item);

  // Insert item at position `pos`, moving `pos`..`_count-1` down by 1.
  size_t insert_at(const T& item, size_t pos);

  // C++ iterator interface.
  const T* begin() const;
  T* begin();
  const T* end() const;

  // Erase the value at the iterator location.
  void erase(T* atIter);
};