//# This file is a part of toml++ and is subject to the the terms of the MIT license.
//# Copyright (c) 2019-2020 Mark Gillard <mark.gillard@outlook.com.au>
//# See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
// SPDX-License-Identifier: MIT

#pragma once
#include "toml_node.h"
#include "toml_print_to_stream.h"

TOML_PUSH_WARNINGS
TOML_DISABLE_FLOAT_WARNINGS
TOML_DISABLE_PADDING_WARNINGS

namespace toml
{
	template <typename Char, typename T>
	std::basic_ostream<Char>& operator << (std::basic_ostream<Char>&, const value<T>&);

	/// \brief	A TOML value.
	/// 		
	/// \tparam	T	The value's data type. Can be one of:
	/// 			- toml::string
	/// 			- int64_t
	/// 			- double
	/// 			- bool
	/// 			- toml::date
	/// 			- toml::time
	/// 			- toml::date_time
	template <typename T>
	class TOML_API value final : public node
	{
		static_assert(
			impl::is_value<T>,
			"Template type parameter must be one of the TOML value types"
		);

		private:
			friend class TOML_PARSER_TYPENAME;

			template <typename U, typename V>
			[[nodiscard]] TOML_ALWAYS_INLINE
			static auto as_value([[maybe_unused]] V* ptr) noexcept
			{
				if constexpr (std::is_same_v<T, U>)
					return ptr;
				else
					return nullptr;
			}

			T val_;

		public:

			/// \brief	The value's underlying data type.
			using value_type = T;

			/// \brief	A type alias for 'value arguments'.
			/// \details This differs according to the value's type argument:
			/// 		 - ints, floats, booleans: `value_type`
			/// 		 - strings: `string_view`
			/// 		 - everything else: `const value_type&`
			using value_arg = std::conditional_t<
				std::is_same_v<T, string>,
				string_view,
				std::conditional_t<impl::is_one_of<T, double, int64_t, bool>, T, const T&>
			>;

			/// \brief	Constructs a toml value.
			///
			/// \tparam	U	Constructor argument types.
			/// \param 	args	Arguments to forward to the internal value's constructor.
			template <typename... U>
			TOML_NODISCARD_CTOR
			explicit value(U&&... args) noexcept(std::is_nothrow_constructible_v<T, U&&...>)
				: val_{ std::forward<U>(args)... }
			{}

			/// \brief	Move constructor.
			TOML_NODISCARD_CTOR
			value(value&& other) noexcept
				: node{ std::move(other) },
				val_{ std::move(other.val_) }
			{}

			/// \brief	Move-assignment operator.
			value& operator= (value&& rhs) noexcept
			{
				node::operator=(std::move(rhs));
				val_ = std::move(rhs.val_);
				return *this;
			}

			value(const value&) = delete;
			value& operator= (const value&) = delete;

			/// \brief	Returns the value's node type identifier.
			///
			/// \returns	One of:
			/// 			- node_type::string
			/// 			- node_type::integer
			/// 			- node_type::floating_point
			/// 			- node_type::boolean
			/// 			- node_type::date
			/// 			- node_type::time
			/// 			- node_type::date_time
			[[nodiscard]] node_type type() const noexcept override { return impl::node_type_of<T>; }

			/// \brief	Always returns `false` for value nodes.
			[[nodiscard]] bool is_table() const noexcept override { return false; }
			/// \brief	Always returns `false` for value nodes.
			[[nodiscard]] bool is_array() const noexcept override { return false; }
			/// \brief	Always returns `true` for value nodes.
			[[nodiscard]] bool is_value() const noexcept override { return true; }

			[[nodiscard]] bool is_string() const noexcept override { return std::is_same_v<T, string>; }
			[[nodiscard]] bool is_integer() const noexcept override { return std::is_same_v<T, int64_t>; }
			[[nodiscard]] bool is_floating_point() const noexcept override { return std::is_same_v<T, double>; }
			[[nodiscard]] bool is_number() const noexcept override { return impl::is_one_of<T, int64_t, double>; }
			[[nodiscard]] bool is_boolean() const noexcept override { return std::is_same_v<T, bool>; }
			[[nodiscard]] bool is_date() const noexcept override { return std::is_same_v<T, date>; }
			[[nodiscard]] bool is_time() const noexcept override { return std::is_same_v<T, time>; }
			[[nodiscard]] bool is_date_time() const noexcept override { return std::is_same_v<T, date_time>; }

			/// \brief	Returns a pointer to the value if the data type is a string.
			[[nodiscard]] value<string>* as_string() noexcept override { return as_value<string>(this); }
			/// \brief	Returns a pointer to the value if the data type is an integer.
			[[nodiscard]] value<int64_t>* as_integer() noexcept override { return as_value<int64_t>(this); }
			/// \brief	Returns a pointer to the value if the data type is a floating-point.
			[[nodiscard]] value<double>* as_floating_point() noexcept override { return as_value<double>(this); }
			/// \brief	Returns a pointer to the value if the data type is boolean.
			[[nodiscard]] value<bool>* as_boolean() noexcept override { return as_value<bool>(this); }
			/// \brief	Returns a pointer to the value if the data type is a date.
			[[nodiscard]] value<date>* as_date() noexcept override { return as_value<date>(this); }
			/// \brief	Returns a pointer to the value if the data type is a time.
			[[nodiscard]] value<time>* as_time() noexcept override { return as_value<time>(this); }
			/// \brief	Returns a pointer to the value if the data type is date-time.
			[[nodiscard]] value<date_time>* as_date_time() noexcept override { return as_value<date_time>(this); }

			/// \brief	Returns a const pointer to the value if the data type is a string.
			[[nodiscard]] const value<string>* as_string() const noexcept override { return as_value<string>(this); }
			/// \brief	Returns a const pointer to the value if the data type is an integer.
			[[nodiscard]] const value<int64_t>* as_integer() const noexcept override { return as_value<int64_t>(this); }
			/// \brief	Returns a const pointer to the value if the data type is a floating-point.
			[[nodiscard]] const value<double>* as_floating_point() const noexcept override { return as_value<double>(this); }
			/// \brief	Returns a const pointer to the value if the data type is a boolean.
			[[nodiscard]] const value<bool>* as_boolean() const noexcept override { return as_value<bool>(this); }
			/// \brief	Returns a const pointer to the value if the data type is a date.
			[[nodiscard]] const value<date>* as_date() const noexcept override { return as_value<date>(this); }
			/// \brief	Returns a const pointer to the value if the data type is a time.
			[[nodiscard]] const value<time>* as_time() const noexcept override { return as_value<time>(this); }
			/// \brief	Returns a const pointer to the value if the data type is a date-time.
			[[nodiscard]] const value<date_time>* as_date_time() const noexcept override { return as_value<date_time>(this); }

			/// \brief	Returns a reference to the underlying value.
			[[nodiscard]] T& get() & noexcept { return val_; }
			/// \brief	Returns a reference to the underlying value (rvalue overload).
			[[nodiscard]] T&& get() && noexcept { return std::move(val_); }
			/// \brief	Returns a reference to the underlying value (const overload).
			[[nodiscard]] const T& get() const & noexcept { return val_; }

			/// \brief	Returns a reference to the underlying value.
			[[nodiscard]] T& operator* () & noexcept { return val_; }
			/// \brief	Returns a reference to the underlying value (rvalue overload).
			[[nodiscard]] T&& operator* () && noexcept { return std::move(val_); }
			/// \brief	Returns a reference to the underlying value (const overload).
			[[nodiscard]] const T& operator* () const& noexcept { return val_; }

			/// \brief	Returns a reference to the underlying value.
			[[nodiscard]] explicit operator T& () & noexcept { return val_; }
			/// \brief	Returns a reference to the underlying value (rvalue overload).
			[[nodiscard]] explicit operator T&& () && noexcept { return std::move(val_); }
			/// \brief	Returns a reference to the underlying value (const overload).
			[[nodiscard]] explicit operator const T& () const& noexcept { return val_; }

			template <typename Char, typename U>
			friend std::basic_ostream<Char>& operator << (std::basic_ostream<Char>& lhs, const value<U>& rhs);

			/// \brief	Value-assignment operator.
			value& operator= (value_arg rhs) noexcept
			{
				if constexpr (std::is_same_v<T, string>)
					val_.assign(rhs);
				else
					val_ = rhs;
				return *this;
			}

			template <typename U = T, typename = std::enable_if_t<std::is_same_v<U, string>>>
			value& operator= (string&& rhs) noexcept
			{
				val_ = std::move(rhs);
				return *this;
			}

			/// \brief	Value equality operator.
			[[nodiscard]] friend bool operator == (const value& lhs, value_arg rhs) noexcept
			{
				if constexpr (std::is_same_v<value_type, double>)
				{
					static constexpr auto pack = [](auto l, auto r) constexpr noexcept
					{
						return ((static_cast<uint64_t>(l) << 32) | static_cast<uint64_t>(r));
					};
					
					switch (pack(std::fpclassify(lhs.val_), std::fpclassify(rhs)))
					{
						case pack(FP_INFINITE, FP_INFINITE): return (lhs.val_ < 0.0) == (rhs < 0.0);
						case pack(FP_NAN, FP_NAN): return true;
						default: return lhs.val_ == rhs;
					}
				}
				else
					return lhs.val_ == rhs;

			}
			TOML_ASYMMETRICAL_EQUALITY_OPS(const value&, value_arg, )

			/// \brief	Value less-than operator.
			[[nodiscard]] friend bool operator <  (const value& lhs, value_arg rhs) noexcept { return lhs.val_ < rhs; }
			/// \brief	Value less-than operator.
			[[nodiscard]] friend bool operator <  (value_arg lhs, const value& rhs) noexcept { return lhs < rhs.val_; }
			/// \brief	Value less-than-or-equal-to operator.
			[[nodiscard]] friend bool operator <= (const value& lhs, value_arg rhs) noexcept { return lhs.val_ <= rhs; }
			/// \brief	Value less-than-or-equal-to operator.
			[[nodiscard]] friend bool operator <= (value_arg lhs, const value& rhs) noexcept { return lhs <= rhs.val_; }

			/// \brief	Value greater-than operator.
			[[nodiscard]] friend bool operator >  (const value& lhs, value_arg rhs) noexcept { return lhs.val_ > rhs; }
			/// \brief	Value greater-than operator.
			[[nodiscard]] friend bool operator >  (value_arg lhs, const value& rhs) noexcept { return lhs > rhs.val_; }
			/// \brief	Value greater-than-or-equal-to operator.
			[[nodiscard]] friend bool operator >= (const value& lhs, value_arg rhs) noexcept { return lhs.val_ >= rhs; }
			/// \brief	Value greater-than-or-equal-to operator.
			[[nodiscard]] friend bool operator >= (value_arg lhs, const value& rhs) noexcept { return lhs >= rhs.val_; }

			/// \brief	Equality operator.
			///
			/// \param 	lhs	The LHS value.
			/// \param 	rhs	The RHS value.
			///
			/// \returns	True if the values were of the same type and contained the same value.
			template <typename U>
			[[nodiscard]] friend bool operator == (const value& lhs, const value<U>& rhs) noexcept
			{
				if constexpr (std::is_same_v<T, U>)
					return lhs == rhs.val_; //calls asymmetrical value-equality operator defined above
				else
					return false;
			}

			/// \brief	Inequality operator.
			///
			/// \param 	lhs	The LHS value.
			/// \param 	rhs	The RHS value.
			///
			/// \returns	True if the values were not of the same type, or did not contain the same value.
			template <typename U>
			[[nodiscard]] friend bool operator != (const value& lhs, const value<U>& rhs) noexcept
			{
				return !(lhs == rhs);
			}

			/// \brief	Less-than operator.
			///
			/// \param 	lhs	The LHS toml::value.
			/// \param 	rhs	The RHS toml::value.
			///
			/// \returns	<strong><em>Same value types:</em></strong> `lhs.get() < rhs.get()` <br>
			/// 			<strong><em>Different value types:</em></strong> `lhs.type() < rhs.type()`
			template <typename U>
			[[nodiscard]] friend bool operator < (const value& lhs, const value<U>& rhs) noexcept
			{
				if constexpr (std::is_same_v<T, U>)
					return lhs.val_ < rhs.val_;
				else
					return impl::node_type_of<T> < impl::node_type_of<U>;
			}

			/// \brief	Less-than-or-equal-to operator.
			///
			/// \param 	lhs	The LHS toml::value.
			/// \param 	rhs	The RHS toml::value.
			///
			/// \returns	<strong><em>Same value types:</em></strong> `lhs.get() <= rhs.get()` <br>
			/// 			<strong><em>Different value types:</em></strong> `lhs.type() <= rhs.type()`
			template <typename U>
			[[nodiscard]] friend bool operator <= (const value& lhs, const value<U>& rhs) noexcept
			{
				if constexpr (std::is_same_v<T, U>)
					return lhs.val_ <= rhs.val_;
				else
					return impl::node_type_of<T> <= impl::node_type_of<U>;
			}

			/// \brief	Greater-than operator.
			///
			/// \param 	lhs	The LHS toml::value.
			/// \param 	rhs	The RHS toml::value.
			///
			/// \returns	<strong><em>Same value types:</em></strong> `lhs.get() > rhs.get()` <br>
			/// 			<strong><em>Different value types:</em></strong> `lhs.type() > rhs.type()`
			template <typename U>
			[[nodiscard]] friend bool operator > (const value& lhs, const value<U>& rhs) noexcept
			{
				if constexpr (std::is_same_v<T, U>)
					return lhs.val_ > rhs.val_;
				else
					return impl::node_type_of<T> > impl::node_type_of<U>;
			}

			/// \brief	Greater-than-or-equal-to operator.
			///
			/// \param 	lhs	The LHS toml::value.
			/// \param 	rhs	The RHS toml::value.
			///
			/// \returns	<strong><em>Same value types:</em></strong> `lhs.get() >= rhs.get()` <br>
			/// 			<strong><em>Different value types:</em></strong> `lhs.type() >= rhs.type()`
			template <typename U>
			[[nodiscard]] friend bool operator >= (const value& lhs, const value<U>& rhs) noexcept
			{
				if constexpr (std::is_same_v<T, U>)
					return lhs.val_ >= rhs.val_;
				else
					return impl::node_type_of<T> >= impl::node_type_of<U>;
			}
	};

	#if !TOML_ALL_INLINE
		TOML_PUSH_WARNINGS
		TOML_DISABLE_VTABLE_WARNINGS
		extern template class TOML_API value<string>;
		extern template class TOML_API value<int64_t>;
		extern template class TOML_API value<double>;
		extern template class TOML_API value<bool>;
		extern template class TOML_API value<date>;
		extern template class TOML_API value<time>;
		extern template class TOML_API value<date_time>;
		TOML_POP_WARNINGS
	#endif

	template <size_t N> value(const string_char(&)[N]) -> value<string>;
	template <size_t N> value(const string_char(&&)[N]) -> value<string>;
	value(const string_char*) -> value<string>;
	template <size_t N> value(string_char(&)[N]) -> value<string>;
	template <size_t N> value(string_char(&&)[N]) -> value<string>;
	value(string_char*) -> value<string>;
	value(string_view) -> value<string>;
	value(string) -> value<string>;
	value(bool) -> value<bool>;
	value(float) -> value<double>;
	value(double) -> value<double>;
	value(int8_t) -> value<int64_t>;
	value(int16_t) -> value<int64_t>;
	value(int32_t) -> value<int64_t>;
	value(int64_t) -> value<int64_t>;
	value(uint8_t) -> value<int64_t>;
	value(uint16_t) -> value<int64_t>;
	value(uint32_t) -> value<int64_t>;
	value(date) -> value<date>;
	value(time) -> value<time>;
	value(date_time) -> value<date_time>;
	#ifdef TOML_SMALL_FLOAT_TYPE
		value(TOML_SMALL_FLOAT_TYPE) -> value<double>;
	#endif
	#ifdef TOML_SMALL_INT_TYPE
		value(TOML_SMALL_INT_TYPE) -> value<int64_t>;
	#endif

	/// \brief	Prints the value out to a stream.
	template <typename Char, typename T>
	TOML_EXTERNAL_LINKAGE
	std::basic_ostream<Char>& operator << (std::basic_ostream<Char>& lhs, const value<T>& rhs)
	{
		// this is the same behaviour as default_formatter, but it's so simple that there's
		// no need to spin up a new instance of it just for individual values.

		if constexpr (std::is_same_v<T, string>)
		{
			impl::print_to_stream('"', lhs);
			impl::print_to_stream_with_escapes(rhs.val_, lhs);
			impl::print_to_stream('"', lhs);
		}
		else
			impl::print_to_stream(rhs.val_, lhs);
				
		return lhs;
	}

	#if !TOML_ALL_INLINE
		extern template TOML_API std::ostream& operator << (std::ostream&, const value<toml::string>&);
		extern template TOML_API std::ostream& operator << (std::ostream&, const value<int64_t>&);
		extern template TOML_API std::ostream& operator << (std::ostream&, const value<double>&);
		extern template TOML_API std::ostream& operator << (std::ostream&, const value<bool>&);
		extern template TOML_API std::ostream& operator << (std::ostream&, const value<toml::date>&);
		extern template TOML_API std::ostream& operator << (std::ostream&, const value<toml::time>&);
		extern template TOML_API std::ostream& operator << (std::ostream&, const value<toml::date_time>&);
	#endif

	TOML_PUSH_WARNINGS
	TOML_DISABLE_INIT_WARNINGS

	template <typename T>
	inline optional<T> node::value() const noexcept
	{
		static_assert(
			impl::is_value<T> || std::is_same_v<T, string_view>,
			"Value type must be one of the TOML value types (or string_view)"
		);

		switch (type())
		{
			case node_type::none:	[[fallthrough]];
			case node_type::table:	[[fallthrough]];
			case node_type::array:
				return {};

			case node_type::string:
			{
				if constexpr (std::is_same_v<T, string> || std::is_same_v<T, string_view>)
					return { T{ ref_cast<string>().get() } };
				else
					return {};
			}

			case node_type::integer:
			{
				if constexpr (std::is_same_v<T, int64_t>)
					return ref_cast<int64_t>().get();
				else if constexpr (std::is_same_v<T, double>)
					return static_cast<double>(ref_cast<int64_t>().get());
				else
					return {};
			}

			case node_type::floating_point:
			{
				if constexpr (std::is_same_v<T, double>)
					return ref_cast<double>().get();
				else if constexpr (std::is_same_v<T, int64_t>)
					return static_cast<int64_t>(ref_cast<double>().get());
				else
					return {};
			}

			case node_type::boolean:
			{
				if constexpr (std::is_same_v<T, bool>)
					return ref_cast<bool>().get();
				else
					return {};
			}

			case node_type::date:
			{
				if constexpr (std::is_same_v<T, date>)
					return ref_cast<date>().get();
				else
					return {};
			}

			case node_type::time:
			{
				if constexpr (std::is_same_v<T, time>)
					return ref_cast<time>().get();
				else
					return {};
			}

			case node_type::date_time:
			{
				if constexpr (std::is_same_v<T, date_time>)
					return ref_cast<date_time>().get();
				else
					return {};
			}

			TOML_NO_DEFAULT_CASE;
		}

		TOML_UNREACHABLE;
	}

	TOML_POP_WARNINGS

	template <typename T>
	inline auto node::value_or(T&& default_value) const noexcept
	{
		static_assert(
			impl::is_value_or_promotable<impl::remove_cvref_t<T>>,
			"Default value type must be (or be promotable to) one of the TOML value types"
		);

		using value_type = impl::promoted<impl::remove_cvref_t<T>>;
		using return_type = std::conditional_t<
			std::is_same_v<value_type, string>,
			std::conditional_t<std::is_same_v<impl::remove_cvref_t<T>, string>, string, string_view>,
			value_type
		>;

		if (auto val = this->value<return_type>())
			return *val;
		return return_type{ std::forward<T>(default_value) };
	}
}

TOML_POP_WARNINGS // TOML_DISABLE_FLOAT_WARNINGS, TOML_DISABLE_PADDING_WARNINGS