#ifndef CHILON_VARIANT_HPP

#define CHILON_VARIANT_HPP

#include <chilon/meta/at.hpp>

#include <chilon/meta/index_of.hpp>

#include <chilon/meta/max.hpp>

#include <chilon/meta/return.hpp>

#include <chilon/meta/void.hpp>

#include <chilon/meta/call_type.hpp>

#include <chilon/meta/contains.hpp>

#include <chilon/meta/require.hpp>

#include <chilon/singleton.hpp>

#include <chilon/hash.hpp>

#include <boost/ptr_container/ptr_array.hpp>

#include <utility>

#include <memory>

#include <assert.h>

namespace chilon {

/// Thrown when a variant is initalised from another variant which

/// current stores a type that the lhs variant cannot store.

struct invalid_variant_initalisation {};

/**

 * @brief A simple variant which can store one of any of the types in

 *        T on the heap.

 * @detailed When it is constructed the variant is empty by default.

 *           A verison of the variant that stores data on the stack can be

 *           enabled by defining CHILON_VARIANT_USES_STACK. This version

 *           can never be empty and constructs the first type when default

 *           constructed. This version is less convenient to use in places

 *           where only forward declarations of the variant types are

 *           available.

 * @tparam T pack of valid types the variant may store.

 */

template <class... T>

struct variant {

    enum { n_elements = sizeof...(T) };

#ifdef CHILON_VARIANT_USES_STACK

    enum { max_size = meta::max<sizeof(T)...>::value };

#else

  private:

    struct copier {

        template <class U> void operator()(U& v) const { v_ = v; }

        void operator()() const { v_.set_empty(); }

        copier(variant& v) : v_(v) {}

        variant& v_;

    };

    struct comparator {

        template <class U> bool operator()(U const& v) const {

            return v == v_.at<U>();

        }

        bool operator()() const { return v_.empty(); }

        comparator(variant const& v) : v_(v) {}

        variant const& v_;

    };

  public:

    bool operator==(variant const& rhs) const {

        return type_index_ == rhs.type_index_ &&

               variant_apply(rhs, comparator(*this));

    };

    bool operator!=(variant const& rhs) const {

        return ! (*this == rhs);

    };

    template <class... U>

    variant& operator=(variant<U...> const& rhs) {

        variant_apply(rhs, copier(*this));

        return *this;

    }

    variant& operator=(variant&& rhs) {

        delete_if_not_empty();

        data_ = rhs.data_;

        type_index_ = rhs.type_index_;

        rhs.data_ = 0;

        return *this;

    }

    template <class V>

    variant& operator=(std::auto_ptr<V>& rhs) {

        int const new_index = meta::index_of<V, T...>::value;

        static_assert(

            new_index < n_elements, "type does not exist in variant");

        delete_if_not_empty();

        type_index_ = new_index;

        data_ = rhs.release();

        return *this;

    }

    template <class V>

    variant& operator=(V const& rhs) {

        int const new_index = meta::index_of<V, T...>::value;

        static_assert(

            new_index < n_elements, "type does not exist in variant");

#ifdef CHILON_VARIANT_USES_STACK

        type_index_ = new_index;

        cast<V>() = rhs;

#else

        delete_if_not_empty();

        type_index_ = new_index;

        data_ = new V(rhs);

#endif

        return *this;

    }

    template <class V>

    V *release() {

        int const index = meta::index_of<V, T...>::value;

        static_assert(

            index < n_elements, "type does not exist in variant");

        assert(type_index_ == index);

        V *data = static_cast<V *>(data_);

        data_ = 0;

        return data;

    }

    bool empty() const { return ! data_; }

    void set_empty() {

        if (! empty()) {

            variant_apply(*this, deleter());

            data_ = 0;

            int const void_idx = meta::index_of<void, T...>::value;

            if (void_idx < n_elements) type_index_ = void_idx;

        }

    }

  private:

    void delete_if_not_empty() {

        if (! empty())

            variant_apply(*this, deleter());

    }

  public:

#endif

    typedef typename meta::head<T...>::type head_type;

    /**

     * Change variant to represent a default constructed V

     */

    template <class V>

    V& construct_default() {

        int const new_index = meta::index_of<V, T...>::value;

        static_assert(

            new_index < n_elements, "type does not exist in variant");

#ifdef CHILON_VARIANT_USES_STACK

        type_index_ = new_index;

        return *new (data_) V;

#else

        set_empty();

        type_index_ = new_index;

        data_ = new V();

        return cast<V>();

#endif

    }

    template <class V, CHILON_REQUIRE(meta::is_void<V>)>

    void construct_default() { set_empty(); }

    /**

     * Unsafe access to type at index I.

     */

    template <int I>

    typename meta::at<I, T...>::type& at() {

        static_assert(I < n_elements, "index too high");

#ifndef NDEBUG

        assert(type_index_ == I);

#endif

        return cast<typename meta::at<I, T...>::type>();

    }

    /**

     * Unsafe const access to type at index I.

     */

    template <int I>

    typename meta::at<I, T...>::type const& at() const {

        static_assert(I < n_elements, "type not found in variant");

#ifndef NDEBUG

        assert(type_index_ == I);

#endif

        return cast<typename meta::at<I, T...>::type>();

    }

    template <int I,

        CHILON_REQUIRE(meta::is_void<typename meta::at<I, T...>::type >) >

    void at() const {};

    template <class Y>

    Y& at() {

        return at<meta::index_of<Y, T...>::value>();

    }

    template <class Y>

    Y const& at() const {

        return at<meta::index_of<Y, T...>::value>();

    }

    template <class U>

    bool is() const {

        int const index = meta::index_of<U, T...>::value;

        static_assert(index < n_elements, "type does not exist in variant");

        return type_index_ == index;

    }

    int const type_index() const { return type_index_; }

  private:

    // unsafe casts

    template <class Y>

    Y const& cast() const {

        return (*reinterpret_cast<Y const *>(data_));

    }

    template <class Y>

    Y& cast() {

        return (*reinterpret_cast<Y *>(data_));

    }

  public:

    // default constructor constructs the first element in the tuple

#ifdef CHILON_VARIANT_USES_STACK

    variant() : type_index_(0) {

        new (data_) head_type;

    }

  private:

    char data_[max_size];

#else

  private:

    struct initialiser {

        template <class U>

        void operator()(U const& v) const {

            v_.data_ = new U(v);

        }

        void operator()() const {

            v_.set_empty();

        }

        initialiser(variant& v) : v_(v) {}

      protected:

        variant& v_;

    };

    struct careful_initialiser : initialiser {

        template <class U>

        CHILON_RETURN_REQUIRE(void, meta::contains<U, T...>)

        operator()(U const& v) const {

            this->v_.type_index_ = meta::index_of<U, T...>::value;

            initialiser::operator()(v);

        }

        template <class U>

        CHILON_RETURN_NOT_REQUIRE(void, meta::contains<U, T...>)

        operator()(U const& v) const {

            throw invalid_variant_initalisation();

        }

        careful_initialiser(variant& v) : initialiser(v) {}

    };

    struct deleter {

        template <class U> void operator()(U& v) const { delete &v; }

        void operator()() const {}

    };

  public:

    variant() : data_(0), type_index_(0) {

        construct_default< typename meta::head<T...>::type >();

    }

    variant(variant const& rhs) : type_index_(rhs.type_index_) {

        variant_apply(rhs, initialiser(*this));

    }

    variant(variant&& rhs)

      : data_(rhs.data_), type_index_(rhs.type_index_)

    { rhs.data_ = 0; }

    template <class U,

              CHILON_REQUIRE_I(meta::index_of<U, T...>::value < n_elements)>

    variant(U const& u)

      : data_(new U(u)),

        type_index_(meta::index_of<U, T...>::value)

    {}

    template <class U,

              CHILON_REQUIRE_I(meta::index_of<U, T...>::value < n_elements)>

    variant(U&& u)

      : data_(new U(std::move(u))),

        type_index_(meta::index_of<U, T...>::value)

    {}

    // TODO: check variant is not subvariant first, then handle

    //       it like a regular member type

    template <class... U>

    variant(variant<U...> const& rhs) {

        variant_apply(rhs, careful_initialiser(*this));

    }

    ~variant() { set_empty(); }

    template <class U>

    variant(std::auto_ptr<U>& rhs)

      : type_index_(meta::index_of<U, T...>::value)

    {

        static_assert(

             meta::index_of<U, T...>::value < n_elements,

             "type does not exist in variant");

        data_ = rhs.release();

    }

  protected:

    void *data_;

#endif

    int  type_index_;

};

#if 0 && ! defined(CHILON_VARIANT_USES_STACK)

/**

 * @brief If a void entry is used as the first entry in a variant, then

 *        the variant can be empty. The void entry is not considered part

 *        of the variant in the indexing system.

 */

template <class... T>

struct variant<void, T...> : variant<T...> {

    typedef variant<T...> base_t;

    template <class U>

    variant<void, T...>& operator=(U&& rhs) {

        base_t::operator=(std::move<U>(rhs));

    }

    variant() : base_t() {}

    template <class U>

    variant(U&& rhs) : base_t(std::forward<U>(rhs)) {}

};

#endif

namespace detail {

    template <class T, class F>

    struct variant_apply_helper {};

    template <class F, class T>

    struct variant_call_type;

    template <class F, class... T>

    struct variant_call_type<F, variant<T...> > :

        meta::call_type_ref<F, typename meta::at<0, T...>::type> {};

    template <class F, class... T>

    struct variant_apply_lookup_table {

        typedef variant<T...> type;

        struct apply {

            virtual typename variant_call_type<F, type>::type

            operator()(type const& v, F const& f) =0;

            virtual typename variant_call_type<F, type>::type

            operator()(type& v, F const& f) =0;

        };

        boost::ptr_array<apply, type::n_elements> appliers_;

        template <int I, class U>

        struct apply_idx : apply {

            virtual auto operator()(type const& v, F const& f)

                CHILON_RETURN(f(v.template at<I>()))

            virtual auto operator()(type& v, F const& f)

                CHILON_RETURN(f(v.template at<I>()))

        };

        template <int I>

        struct apply_idx<I, void> : apply {

            virtual auto operator()(type const& v, F const& f)

                CHILON_RETURN(f())

            virtual auto operator()(type& v, F const& f)

                CHILON_RETURN(f())

        };

        template <int I, int L>

        struct create_applier {

            static void exec(decltype(appliers_)& appliers) {

                appliers.replace(

                    I,

                    new apply_idx<I, typename meta::at<I, T...>::type >()

                );

                create_applier<I + 1, L>::exec(appliers);

            }

        };

        template <int I>

        struct create_applier<I, I> {

            static void exec(decltype(appliers_)& appliers) {}

        };

        variant_apply_lookup_table() {

            create_applier<0, type::n_elements>::exec(appliers_);

        }

    };

    template <class... T, class F>

    struct variant_apply_helper< variant<T...>, F > {

        typedef variant<T...> type;

        inline static typename variant_call_type<F, type>::type

        exec(type const& v, F const& f) {

            return chilon::singleton<

                variant_apply_lookup_table<F, T...>

            >::instance().appliers_[v.type_index()](v, f);

        }

        inline static typename variant_call_type<F, type>::type

        exec(type& v, F const& f) {

            return chilon::singleton<

                variant_apply_lookup_table<F, T...>

            >::instance().appliers_[v.type_index()](v, f);

        }

        inline static typename variant_call_type<F, type>::type

        exec(int const idx, type const& v, F const& f) {

            return chilon::singleton<

                variant_apply_lookup_table<F, T...>

            >::instance().appliers_[idx](v, f);

        }

        inline static typename variant_call_type<F, type>::type

        exec(int const idx, type& v, F const& f) {

            return chilon::singleton<

                variant_apply_lookup_table<F, T...>

            >::instance().appliers_[idx](v, f);

        }

    };

}

template <class F, class T>

inline auto variant_apply(T& v, F const& f)

    CHILON_RETURN(detail::variant_apply_helper<T, F>::exec(v, f))

template <class F, class T>

inline auto variant_apply(T const& v, F const& f)

    CHILON_RETURN(detail::variant_apply_helper<T, F>::exec(v, f))

template <class F, class T>

inline auto variant_construct_apply(int const idx, T const& v, F const& f)

    CHILON_RETURN(detail::variant_apply_helper<T, F>::exec(idx, v, f))

template <class F, class T>

inline auto variant_construct_apply(int const idx, T& v, F const& f)

    CHILON_RETURN(detail::variant_apply_helper<T, F>::exec(idx, v, f))

template <class T, class... Y>

inline T& variant_as(variant<Y...>& v) {

    return v.template at<T>();

}

template <class T, class... Y>

inline T& variant_as(variant<Y...> const& v) {

    return v.template at<T>();

}

template <class T>

inline T& variant_as(T& v) { return v; }

template <class T>

inline T const& variant_as(T const& v) { return v; }

/**

 * call construct_default on a variant.

 */

template <class T, class... Y>

inline void construct_default(variant<Y...>& v) {

    v.template construct_default<T>();

}

/**

 * construct_default on non-variant does nothing

 */

template <class T>

inline void construct_default(T const& v) {}

struct hash_variant {

    size_t operator()() const { return 0; }

    template <class T>

    size_t operator()(T const& t) const { return chilon::hash(t); }

};

/**

 * register with boost::hash

 */

template <class... T>

std::size_t inline hash_value(variant<T...> const& t) {

    return variant_apply(t, hash_variant());

}

}

namespace std {

    template <class... T>

    struct hash<chilon::variant<T...>> {

        std::size_t operator()(chilon::variant<T...> const& arg) const {

            return chilon::hash_value(arg);

        }

    };

}

#endif