//
//  variant.hpp
//  variant
//
//  Created by Sam Jaffe on 1/30/16.
//  Copyright © 2016 Sam Jaffe. All rights reserved.
//

#ifndef variant_h
#define variant_h
#pragma once

#include <cstdlib>
#include <utility>
#include <memory>

// Max of a list of values
template <size_t T, size_t... Ts> struct static_max;

template <size_t T>
struct static_max<T> {
  static const constexpr size_t value = T;
};

template <size_t T1, size_t T2, size_t... Ts>
struct static_max<T1, T2, Ts...> {
  static const constexpr size_t value = T1 > T2 ? static_max<T1, Ts...>::value : static_max<T2, Ts...>::value;
};

// Type index in a list
template <typename F, typename... Ts> struct type_index;

template <typename F>
struct type_index<F> {};

template <typename F, typename T, typename... Ts>
struct type_index<F, T, Ts...> {
  static const constexpr size_t value = type_index<F, Ts...>::value;
};

template <typename F, typename... Ts>
struct type_index<F, F, Ts...> {
  static const constexpr size_t value = sizeof...(Ts);
};

template <typename... Ts> struct variant_helper;

template<typename F, typename... Ts>
struct variant_helper<F, Ts...> {
  inline static void destroy(size_t id, void * data)
  {
    if (id == sizeof...(Ts))
      reinterpret_cast<F*>(data)->~F();
    else
      variant_helper<Ts...>::destroy(id, data);
  }
  
  inline static void move(size_t old_t, void * old_v, void * new_v)
  {
    if (old_t == sizeof...(Ts))
      new (new_v) F(std::move(*reinterpret_cast<F*>(old_v)));
    else
      variant_helper<Ts...>::move(old_t, old_v, new_v);
  }
  
  inline static void copy(size_t old_t, const void * old_v, void * new_v)
  {
    if (old_t == sizeof...(Ts))
      new (new_v) F(*reinterpret_cast<const F*>(old_v));
    else
      variant_helper<Ts...>::copy(old_t, old_v, new_v);
  }   
};

template<> struct variant_helper<>  {
  inline static void destroy(size_t, void *) { }
  inline static void move(size_t, void *, void *) { }
  inline static void copy(size_t, const void *, void *) { }
};

template <typename... Ts>
struct variant {
private:
  static const constexpr size_t num_types = sizeof...(Ts);
  static const constexpr size_t data_size = static_max<sizeof(Ts)...>::value;
  static const constexpr size_t data_align = static_max<alignof(Ts)...>::value;
  
  using data_t = typename std::aligned_storage<data_size, data_align>::type;
  
  using helper_t = variant_helper<Ts...>;
  
  static inline size_t invalid_type() {
    return 0xFFFFFFFF;
  }
  
  template <typename T>
  static inline size_t get_type_index() {
    return num_types - type_index<T, Ts...>::value - 1;
  }
  
  size_t type_id;
  data_t data;
public:
  template <size_t I>
  using at = typename std::tuple_element<I, std::tuple<Ts...>>::type;
  
  variant() : type_id(invalid_type()), data() {   }
  
  template <typename T>
  variant(T const & value) : type_id(invalid_type()), data() {
    set<T>(value);
  }
  
  variant(const variant<Ts...>& old) : type_id(old.type_id), data()
  {
    helper_t::copy(num_types - old.type_id - 1, &old.data, &data);
  }
  
  variant(variant<Ts...>&& old) : type_id(old.type_id), data()
  {
    helper_t::move(num_types - old.type_id - 1, &old.data, &data);
  }
  
  // Serves as both the move and the copy asignment operator.
  variant<Ts...>& operator= (variant<Ts...> old)
  {
    std::swap(type_id, old.type_id);
    std::swap(data, old.data);
    
    return *this;
  }
  
  template<typename T>
  inline bool is() const {
    return (type_id == get_type_index<T>());
  }
  
  inline bool valid() const {
    return (type_id != invalid_type());
  }
  
  template<typename T, typename... Args>
  void set(Args&&... args)
  {
    // First we destroy the current contents
    helper_t::destroy(num_types - type_id - 1, &data);
    new (&data) T(std::forward<Args>(args)...);
    type_id = get_type_index<T>();
  }
  
  template<typename T>
  T& get()
  {
    // It is a dynamic_cast-like behaviour
    if (is<T>())
      return *reinterpret_cast<T*>(&data);
    else
      throw std::bad_cast();
  }
  
  template<typename T>
  T const& get() const
  {
    // It is a dynamic_cast-like behaviour
    if (is<T>())
      return *reinterpret_cast<T const*>(&data);
    else
      throw std::bad_cast();
  }
  
  size_t index() const { return type_id; }
  
  template <size_t I>
  auto get() const -> at<I> const & {
    return get<at<I>>();
  }

  template <size_t I>
  auto get() -> at<I> & {
    return get<at<I>>();
  }

  ~variant() {
    helper_t::destroy(num_types - type_id - 1, &data);
  }
};

namespace std {
  template <size_t I, typename... Ts>
  auto get(variant<Ts...> const & var) -> typename variant<Ts...>::template at<I> const & {
    return var.template get<I>();
  }
  
  template <size_t I, typename... Ts>
  auto get(variant<Ts...> & var) -> typename variant<Ts...>::template at<I> & {
    return var.template get<I>();
  }
}

#endif /* variant_h */