//
//  maybe_null.hpp
//  pointer
//
//  Created by Sam Jaffe on 9/24/15.
//
//

#pragma once

#include <memory>

#include "detail/compare.hpp"
#include "detail/get_ptr.hpp"
#include "exception.hpp"
#include "pointer_fwd.hpp"

#if defined(DEBUG)
#define set_tested(value) tested_ = value
#else
#define set_tested(_)
#endif

namespace pointers {

  template <typename P> class maybe_null<not_null<P>>; // not permitted

  template <typename P>
  class maybe_null : private detail::get_ptr<P>,
                     public detail::pointer_compare<maybe_null<P>> {
  public:
    using element_type = typename std::pointer_traits<P>::element_type;
    using pointer = element_type *;
    using reference = element_type &;

    maybe_null() noexcept : _ptr(nullptr) {}
    maybe_null(P const & p) noexcept(
        std::is_nothrow_copy_constructible<P>::value)
        : _ptr(p) {}
    maybe_null(P && p) noexcept(std::is_nothrow_move_constructible<P>::value)
        : _ptr(std::move(p)) {}
    template <typename Y, typename = typename std::enable_if<
                              std::is_constructible<P, Y>::value>::type>
    maybe_null(Y const & p) : _ptr(p) {}
    template <typename Y, typename = typename std::enable_if<
                              std::is_constructible<P, Y>::value>::type>
    maybe_null(Y && p) : _ptr(std::forward<Y>(p)) {}
    maybe_null(maybe_null const &) noexcept(
        std::is_nothrow_copy_constructible<P>::value) = default;
    maybe_null(maybe_null &&) noexcept(
        std::is_nothrow_move_constructible<P>::value) = default;
    template <typename Y>
    maybe_null(maybe_null<Y> const & other) noexcept(
        std::is_nothrow_constructible<P, Y>::value)
        : _ptr(other._ptr) {
      set_tested(other.tested_);
    }

    maybe_null & operator=(maybe_null const &) noexcept(
        std::is_nothrow_copy_assignable<P>::value) = default;
    maybe_null & operator=(maybe_null &&) noexcept(
        std::is_nothrow_move_assignable<P>::value) = default;

    operator bool() const noexcept {
      set_tested(true);
      return static_cast<bool>(_ptr);
    }

    pointer get() const noexcept(noexcept(detail::get_ptr<P>::get(_ptr))) {
      return detail::get_ptr<P>::get(_ptr);
    }
    pointer operator->() const /*throw(unchecked_pointer_exception)*/ {
      return std::addressof(operator*());
    }
    reference operator*() const /*throw(unchecked_pointer_exception)*/ {
#if defined(DEBUG)
      if (!tested_) {
        throw unchecked_pointer_exception{
            "did not verify that pointer was non-null"};
      }
#endif
      if (!_ptr) {
        throw null_pointer_exception{"dereferencing maybe_null in null state"};
      }
      return *_ptr;
    }

    void reset(P const & p) { operator=(maybe_null(p)); }
    void reset(P && p = P()) { operator=(maybe_null(std::move(p))); }

  private:
    template <typename Y> friend class maybe_null;
    P _ptr;
#if defined(DEBUG)
    mutable bool tested_ = false;
#endif
  };

}
#undef set_tested