#ifndef RJP_OBJECT_HPP
#define RJP_OBJECT_HPP

#include <rjp.h>
#include <rexy/string_base.hpp>
#include "value.hpp"
#include "iterator.hpp"
#include "member.hpp"
#include "integral.hpp"
#include "string_val.hpp"
#include "rjp_util.hpp"

namespace rjp{

	class array;

	class object_iterator : protected detail::iterator_base
	{
	protected:
		RJP_object_iterator m_it;

	public:
		object_iterator(void);
		object_iterator(RJP_value* v);
		object_iterator(const object_iterator&) = delete;
		object_iterator(object_iterator&& o);
		~object_iterator(void);
		object_iterator& operator=(const object_iterator&) = delete;
		object_iterator& operator=(object_iterator&& o);

		bool operator==(const object_iterator& o)const;
		bool operator!=(const object_iterator& o)const;
		member<void> operator*(void)const;
		value_wrapper operator->(void)const;

		object_iterator& operator++(void);
	};

	class object : public value
	{
	public:
		using iterator = object_iterator;
		using const_iterator = const iterator;
	public:
		using value::value;
		object(void);
		explicit object(const value& val);
		explicit object(value&& val);

		object(const object&) = default;
		object(object&&) = default;
		~object(void) = default;
		object& operator=(const object&) = default;
		object& operator=(object&&) = default;

		template<class Val>
		member<std::decay_t<Val>> add(const rexy::string_base& key, typename std::decay_t<Val>::underlying_type t){
			RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
			detail::set_to_underlying<std::decay_t<Val>>(newmem, t);
			return create_unmanaged(newmem);
		}
		template<class Val = null>
		member<std::decay_t<Val>> add(const rexy::string_base& key){
			RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
			if constexpr(std::is_same<std::decay_t<Val>,rjp::array>::value)
				rjp_set_array(newmem);
			else if constexpr(std::is_same<std::decay_t<Val>,rjp::object>::value)
				rjp_set_object(newmem);
			else if constexpr(std::is_void<typename std::decay_t<Val>::underlying_type>::value)
				rjp_set_null(newmem);
			else
				detail::set_to_underlying<std::decay_t<Val>>(newmem, 0);
			return create_unmanaged(newmem);
		}
		member<string_val> add(const rexy::string_base& key, const RJP_string&);
		member<string_val> add(const rexy::string_base& key, RJP_string&&);
		member<string_val> add(const rexy::string_base& key, const char*, RJP_index len = 0);
		member<string_val> add(const rexy::string_base& key, const rexy::string_base&);
		member<string_val> add(const rexy::string_base& key, string&&);

		template<class Val>
		member<std::decay_t<Val>> add(string&& key, typename std::decay_t<Val>::underlying_type t){
			auto len = key.length();
			RJP_value* newmem = rjp_new_member_steal_key(m_value, key.release(), len);
			detail::set_to_underlying<std::decay_t<Val>>(newmem, t);
			return create_unmanaged(newmem);
		}
		template<class Val = null>
		member<std::decay_t<Val>> add(string&& key){
			auto len = key.length();
			RJP_value* newmem = rjp_new_member_steal_key(m_value, key.release(), len);
			if constexpr(std::is_same<std::decay_t<Val>,rjp::array>::value)
				rjp_set_array(newmem);
			else if constexpr(std::is_same<std::decay_t<Val>,rjp::object>::value)
				rjp_set_object(newmem);
			else if constexpr(std::is_void<typename std::decay_t<Val>::underlying_type>::value)
				rjp_set_null(newmem);
			else
				detail::set_to_underlying<std::decay_t<Val>>(newmem, 0);
			return create_unmanaged(newmem);
		}
		member<string_val> add(string&& key, const RJP_string&);
		member<string_val> add(string&& key, RJP_string&&);
		member<string_val> add(string&& key, const char*, RJP_index len = 0);
		member<string_val> add(string&& key, const rexy::string_base&);
		member<string_val> add(string&& key, string&&);

		value remove(const rexy::string_base& key);
		value& remove(value& val);

		void destroy(const rexy::string_base& key);
		void destroy(value&& val);

		bool has_child(const value&);

		iterator begin(void);
		const_iterator begin(void)const;
		iterator end(void)const;

		value search(const rexy::string_base& key);

	};

}

#endif