#include "value.hpp"

#include <ikarus/values/data.h>
#include <ikarus/values/data.hpp>
#include <ikarus/values/schema.h>
#include <ikarus/values/schema.hpp>
#include <ikarus/values/shared.hpp>
#include <ikarus/values/value.h>

auto IkarusValue::from_json(nlohmann::json const & json)
	-> cppbase::Result<IkarusValue, IkarusValueParseError> {
	if (!json.is_object()) {
		return cppbase::err(IkarusJsonError{IkarusJsonInvalidTypeError{}});
	}

	IkarusValue value{};

	VTRY(value.schema, IkarusValueSchema::from_json(json["schema"]));
	VTRY(value.data, IkarusValueData::from_json(json["data"]));

	if (!value.schema.validate(value.data)) {
		return cppbase::err(IkarusValueParseErrorDataSchemaMismatch{});
	}

	return cppbase::ok(std::move(value));
}

auto IkarusValue::to_json(nlohmann::json & json, IkarusValue const & value)
	-> void {
	IkarusValueSchema::to_json(json["schema"], value.schema);
	IkarusValueData::to_json(json["data"], value.data);
}

auto IkarusValues::from_json(nlohmann::json const & json)
	-> cppbase::Result<IkarusValues, IkarusValuesParseError> {
	IkarusValues values{};

	for (auto const & json_entry : json) {
		VTRY(auto name_json, get_key(json_entry, "name"));

		if (!name_json->is_string()) {
			return cppbase::err(IkarusJsonInvalidTypeError{});
		}

		VTRY(auto value_json, get_key(json_entry, "value"));

		VTRY(auto value, IkarusValue::from_json(*value_json));

		values.values.emplace_back(
			std::make_pair(
				std::move(name_json->get<std::string_view>()),
				std::move(value)
			)
		);
	}

	return cppbase::ok(std::move(values));
}