#pragma once

#ifndef TCONSTWRAPPER_INCLUDED
#define TCONSTWRAPPER_INCLUDED

#include <cstddef>
#include <cassert>
#include <vector>

#include "tcommon.h"

#undef DVAPI
#undef DVVAR
#ifdef TNZCORE_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

//=========================================================


template<typename T, typename TT>
class TConstArrayWrapperT {
public:
  typedef T value_type;
  typedef TT src_value_type;

  class reverse_iterator;

  class iterator {
  private:
    const src_value_type *pointer;
    friend class TConstArrayWrapperT<value_type, src_value_type>;
    friend class reverse_iterator;

    explicit iterator(const src_value_type *pointer): pointer(pointer) { }
  public:
    iterator(): pointer() { }
    iterator(const iterator &other): pointer(other.pointer) { }
    explicit iterator(const reverse_iterator &other): pointer(other.pointer) { }

    iterator& operator=(const iterator &other) const { pointer = other.pointer; return *this; }

    bool operator==(const iterator &other) const { return pointer == other.pointer; }
    bool operator!=(const iterator &other) const { return pointer != other.pointer; }
    bool operator< (const iterator &other) const { return pointer <  other.pointer; }
    bool operator> (const iterator &other) const { return pointer >  other.pointer; }
    bool operator<=(const iterator &other) const { return pointer <= other.pointer; }
    bool operator>=(const iterator &other) const { return pointer >= other.pointer; }
    ptrdiff_t operator-(const iterator &other) const { return pointer - other.pointer; }
    iterator operator+(ptrdiff_t diff) const { return iterator(pointer + diff); }
    iterator operator-(ptrdiff_t diff) const { return iterator(pointer - diff); }

    iterator& operator++()   { ++pointer; return *this; }
    iterator& operator--()   { --pointer; return *this; }
    iterator operator++(int) { ++pointer; return iterator(pointer-1); }
    iterator operator--(int) { --pointer; return iterator(pointer+1); }
    iterator operator+=(ptrdiff_t diff) { pointer += diff; return *this; }
    iterator operator-=(ptrdiff_t diff) { pointer -= diff; return *this; }

    const value_type* operator->() const { assert(pointer); return cast(pointer); }
    const value_type& operator*()  const { assert(pointer); return *cast(pointer); }
  };

  class reverse_iterator {
  private:
    const src_value_type *pointer;
    friend class TConstArrayWrapperT<value_type, src_value_type>;

    explicit reverse_iterator(const src_value_type *pointer): pointer(pointer) { }
  public:
    reverse_iterator(): pointer() { }
    reverse_iterator(const reverse_iterator &other): pointer(other.pointer) { }
    explicit reverse_iterator(const iterator &other): pointer(other.pointer) { }

    reverse_iterator& operator=(const reverse_iterator &other) const { pointer = other.pointer; return *this; }

    bool operator==(const reverse_iterator &other) const { return pointer == other.pointer; }
    bool operator!=(const reverse_iterator &other) const { return pointer != other.pointer; }
    bool operator< (const reverse_iterator &other) const { return pointer >  other.pointer; }
    bool operator> (const reverse_iterator &other) const { return pointer <  other.pointer; }
    bool operator<=(const reverse_iterator &other) const { return pointer >= other.pointer; }
    bool operator>=(const reverse_iterator &other) const { return pointer <= other.pointer; }
    ptrdiff_t operator-(const reverse_iterator &other) const { return other.pointer - pointer; }
    reverse_iterator operator+(ptrdiff_t diff) const { return reverse_iterator(pointer - diff); }
    reverse_iterator operator-(ptrdiff_t diff) const { return reverse_iterator(pointer + diff); }

    reverse_iterator& operator++()   { --pointer; return *this; }
    reverse_iterator& operator--()   { ++pointer; return *this; }
    reverse_iterator operator++(int) { --pointer; return reverse_iterator(pointer+1); }
    reverse_iterator operator--(int) { ++pointer; return reverse_iterator(pointer-1); }
    reverse_iterator operator+=(ptrdiff_t diff) { pointer -= diff; return *this; }
    reverse_iterator operator-=(ptrdiff_t diff) { pointer += diff; return *this; }

    const value_type* operator->() const { assert(pointer); return cast(pointer); }
    const value_type& operator*()  const { assert(pointer); return *cast(pointer); }
  };

private:
  const src_value_type *m_begin;
  const src_value_type *m_end;
  const src_value_type *m_rbegin;
  const src_value_type *m_rend;
  size_t m_size;

  static const value_type* cast(const src_value_type *pointer)
    { return static_cast<const value_type*>(pointer); }

public:
  TConstArrayWrapperT():
    m_begin(), m_end(), m_rbegin(), m_rend(), m_size() { }
  TConstArrayWrapperT(const src_value_type *data, size_t size):
    m_begin(), m_end(), m_rbegin(), m_rend(), m_size() { set(data, size); }
  TConstArrayWrapperT(const TConstArrayWrapperT &other):
    m_begin(), m_end(), m_rbegin(), m_rend(), m_size() { *this = other; }
  explicit TConstArrayWrapperT(const std::vector<TT> &v):
    m_begin(), m_end(), m_rbegin(), m_rend(), m_size() { set(v); }

  void reset() {
    m_begin  = 0;
    m_end    = 0;
    m_rbegin = 0;
    m_rend   = 0;
    m_size   = 0;
  }

  void set(const src_value_type *data, size_t size) {
    assert((data != 0) == (size != 0));
    if (!data) reset();
    m_begin  = data;
    m_end    = data + size;
    m_rbegin = m_end - 1;
    m_rend   = m_begin - 1;
    m_size   = size;
  }

  void set(const std::vector<TT> &v)
    { if (v.empty()) reset(); else set(&v.front(), v.size()); }

  TConstArrayWrapperT& operator=(const TConstArrayWrapperT &other)
    { set(other.m_begin, other.m_size); return *this; }

  size_t size() const { return m_size; }
  bool empty() const { return m_size != 0; }

  iterator begin() const
    { return iterator(m_begin); }
  iterator end() const
    { return iterator(m_end); }
  reverse_iterator rbegin() const
    { return reverse_iterator(m_rbegin); }
  reverse_iterator rend() const
    { return reverse_iterator(m_rend); }
  const value_type& at (size_t index) const
    { assert(index < m_size); return *cast(m_begin + index); }
  const value_type& operator[] (size_t index) const
    { return at(index); }
  const value_type& front() const
    { assert(!empty()); return *cast(m_begin); }
  const value_type& back() const
    { assert(!empty()); return *cast(m_rbegin); }
};

#endif