#ifndef CHILON_KEY_VALUE_HPP

#define CHILON_KEY_VALUE_HPP

#include <chilon/print.hpp>

#include <utility>

namespace chilon {

struct key_unique {};

struct key_merge  {};

// TODO: struct key_overwrite {};

template <class K, class V, class A = key_unique>

struct key_value : std::pair<K, V> {

    typedef std::pair<K, V>  base;

    typedef A                append_handler;

    key_value(key_value<K, V, A>&& rhs)      : base(std::move(rhs)) {}

    key_value(key_value<K, V, A> const& rhs) : base(rhs) {}

    template <class T, class U>

    key_value(T&& k, U&& v)

      : base(std::forward<T>(k), std::forward<U>(v)) {}

    key_value() {}

};

template <class A, class K, class V>

auto make_key_value(K&& k, V&& v) CHILON_RETURN(

    key_value<typename std::remove_reference<K>::type,

              typename std::remove_reference<V>::type, A>(std::forward<K>(k), std::forward<V>(v)))

template <class K, class V>

auto make_key_value(K&& k, V&& v) CHILON_RETURN(

    key_value<typename std::remove_reference<K>::type,

              typename std::remove_reference<V>::type>(std::forward<K>(k), std::forward<V>(v)))

template <class O, class U, class V, class A, class... T>

inline void print_args(int const indent, O&      stream,

                       key_value<U, V, A> const& head)

{

    print_args(indent, stream, head.first, ": ", head.second);

}

template <class T, class D = void>

struct get_key : meta::type_<D> {};

template <class K, class V, class A, class D>

struct get_key<key_value<K,V,A>, D> : meta::type_<K> {};

template <class T, class D = void>

struct get_value : meta::type_<D> {};

template <class K, class V, class A, class D>

struct get_value<key_value<K,V,A>, D> : meta::type_<V> {};

template <class T, class D = void>

struct get_appender : meta::type_<D> {};

template <class K, class V, class A, class D>

struct get_appender<key_value<K,V,A>, D> : meta::type_<A> {};

}

#endif