#include "BasicValues.hpp"

#include <charconv>
#include <limits>

bool NumericValue::IsInstance(const BaseValue* value) {
	return value->GetKind() == KD_Numeric;
}

NumericValue::NumericValue()
	: BaseValue(BaseValue::KD_Numeric) {
}

template <class T>
static std::string NumberToString(T value) {
	constexpr auto kSize = std::numeric_limits<T>::max_digits10;
	char buf[kSize];

	auto res = std::to_chars(buf, buf + kSize, value);
	if (res.ec == std::errc()) {
		return std::string(buf, res.ptr);
	} else {
		return "<err>";
	}
}

std::string NumericValue::GetTruncatedString() const {
	return ::NumberToString((int64_t)mValue);
}

std::string NumericValue::GetRoundedString() const {
	return ::NumberToString((int64_t)std::round(mValue));
}

std::string NumericValue::GetString() const {
	return ::NumberToString(mValue);
}

int64_t NumericValue::GetInt() const {
	return static_cast<int64_t>(mValue);
}

double NumericValue::GetValue() const {
	return mValue;
}

void NumericValue::SetValue(double value) {
	mValue = value;
}

bool TextValue::IsInstance(const BaseValue* value) {
	return value->GetKind() == KD_Text;
}

TextValue::TextValue()
	: BaseValue(BaseValue::KD_Text) {
}

const std::string& TextValue::GetValue() const {
	return mValue;
}

void TextValue::SetValue(const std::string& value) {
	mValue = value;
}

bool DateTimeValue::IsInstance(const BaseValue* value) {
	return value->GetKind() == KD_DateTime;
}

DateTimeValue::DateTimeValue()
	: BaseValue(BaseValue::KD_DateTime) {
}

std::string DateTimeValue::GetString() const {
	namespace chrono = std::chrono;
	auto t = chrono::system_clock::to_time_t(mValue);

	char data[32];
	std::strftime(data, sizeof(data), "%Y-%m-%d %H:%M:%S", std::localtime(&t));

	return std::string(data);
}

const std::chrono::time_point<std::chrono::system_clock>& DateTimeValue::GetValue() const {
	return mValue;
}

void DateTimeValue::SetValue(const std::chrono::time_point<std::chrono::system_clock>& value) {
	mValue = value;
}