#pragma once

#include <json/json.h>
#include <functional>
#include <stack>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
#include <array>
#include <optional>
#include <limits>
#include <stdexcept>
#include <unordered_map>
#include <unordered_set>
#include "base64.h"

namespace tiniergltf {

static inline void check(bool cond) {
	if (!cond)
		throw std::runtime_error("invalid glTF");
}

template <typename T>
static inline void checkIndex(const std::optional<std::vector<T>> &vec,
		const std::optional<std::size_t> &i) {
	if (!i.has_value()) return;
	check(vec.has_value());
	check(i < vec->size());
}

template <typename T>
static inline void checkIndex(const std::vector<T> &vec,
		const std::optional<std::size_t> &i) {
	if (!i.has_value()) return;
	check(i < vec.size());
}

template <typename T, typename F>
static inline void checkForall(const std::optional<std::vector<T>> &vec, const F &cond) {
	if (!vec.has_value())
		return;
	for (const T &v : vec.value())
		cond(v);
}

template <typename T>
static inline void checkDuplicateFree(const std::vector<T> &vec) {
	check(std::unordered_set<T>(vec.begin(), vec.end()).size() == vec.size());
}

template <typename T>
static inline T as(const Json::Value &o);

template<>
bool as(const Json::Value &o) {
	check(o.isBool());
	return o.asBool();
}

template<>
double as (const Json::Value &o) {
	check(o.isDouble());
	return o.asDouble();
}

template<>
std::size_t as(const Json::Value &o) {
	check(o.isUInt64());
	auto u = o.asUInt64();
	check(u <= std::numeric_limits<std::size_t>::max());
	return u;
}

template<>
std::string as(const Json::Value &o) {
	check(o.isString());
	return o.asString();
}

template<typename U>
std::vector<U> asVec(const Json::Value &o) {
	check(o.isArray());
	std::vector<U> res;
	res.reserve(o.size());
	for (Json::ArrayIndex i = 0; i < o.size(); ++i) {
		res.push_back(as<U>(o[i]));
	}
	return res;
}

template<typename U, std::size_t n>
std::array<U, n> asArr(const Json::Value &o) {
	check(o.isArray());
	check(o.size() == n);
	std::array<U, n> res;
	for (Json::ArrayIndex i = 0; i < n; ++i) {
		res[i] = as<U>(o[i]);
	}
	return res;
}

struct AccessorSparseIndices {
	std::size_t bufferView;
	std::size_t byteOffset;
	enum class ComponentType {
		UNSIGNED_BYTE,
		UNSIGNED_SHORT,
		UNSIGNED_INT,
	};
	static std::size_t componentSize(ComponentType type) {
		switch (type) {
		case ComponentType::UNSIGNED_BYTE:
			return 1;
		case ComponentType::UNSIGNED_SHORT:
			return 2;
		case ComponentType::UNSIGNED_INT:
			return 4;
		}
		throw std::logic_error("invalid component type");
	}
	ComponentType componentType;
	std::size_t elementSize() const {
		return componentSize(componentType);
	}
	AccessorSparseIndices(const Json::Value &o)
		: bufferView(as<std::size_t>(o["bufferView"]))
		, byteOffset(0)
	{
		check(o.isObject());
		if (o.isMember("byteOffset")) {
			byteOffset = as<std::size_t>(o["byteOffset"]);
			check(byteOffset >= 0);
		}
		{
			static std::unordered_map<Json::UInt64, ComponentType> map = {
				{5121, ComponentType::UNSIGNED_BYTE},
				{5123, ComponentType::UNSIGNED_SHORT},
				{5125, ComponentType::UNSIGNED_INT},
			};
			auto v = o["componentType"]; check(v.isUInt64());
			componentType = map.at(v.asUInt64());
		}
	}
};
template<> AccessorSparseIndices as(const Json::Value &o) { return o; }

struct AccessorSparseValues {
	std::size_t bufferView;
	std::size_t byteOffset;
	AccessorSparseValues(const Json::Value &o)
		: bufferView(as<std::size_t>(o["bufferView"]))
		, byteOffset(0)
	{
		check(o.isObject());
		if (o.isMember("byteOffset")) {
			byteOffset = as<std::size_t>(o["byteOffset"]);
			check(byteOffset >= 0);
		}
	}
};
template<> AccessorSparseValues as(const Json::Value &o) { return o; }

struct AccessorSparse {
	std::size_t count;
	AccessorSparseIndices indices;
	AccessorSparseValues values;
	AccessorSparse(const Json::Value &o)
		: count(as<std::size_t>(o["count"]))
		, indices(as<AccessorSparseIndices>(o["indices"]))
		, values(as<AccessorSparseValues>(o["values"]))
	{
		check(o.isObject());
		check(count >= 1);
	}
};
template<> AccessorSparse as(const Json::Value &o) { return o; }

struct Accessor {
	std::optional<std::size_t> bufferView;
	std::size_t byteOffset;
	enum class ComponentType {
		BYTE,
		UNSIGNED_BYTE,
		SHORT,
		UNSIGNED_SHORT,
		UNSIGNED_INT,
		FLOAT,
	};
	ComponentType componentType;
	std::size_t componentSize() const {
		switch (componentType) {
		case ComponentType::BYTE:
		case ComponentType::UNSIGNED_BYTE:
			return 1;
		case ComponentType::SHORT:
		case ComponentType::UNSIGNED_SHORT:
			return 2;
		case ComponentType::UNSIGNED_INT:
		case ComponentType::FLOAT:
			return 4;
		}
		throw std::logic_error("invalid component type");
	}
	std::size_t count;
	std::optional<std::vector<double>> max;
	std::optional<std::vector<double>> min;
	std::optional<std::string> name;
	bool normalized;
	std::optional<AccessorSparse> sparse;
	enum class Type {
		MAT2,
		MAT3,
		MAT4,
		SCALAR,
		VEC2,
		VEC3,
		VEC4,
	};
	std::size_t typeCount() const {
		switch (type) {
		case Type::SCALAR:
			return 1;
		case Type::VEC2:
			return 2;
		case Type::VEC3:
			return 3;
		case Type::MAT2:
		case Type::VEC4:
			return 4;
		case Type::MAT3:
			return 9;
		case Type::MAT4:
			return 16;
		}
		throw std::logic_error("invalid type");
	}
	Type type;
	std::size_t elementSize() const {
		return componentSize() * typeCount();
	}
	Accessor(const Json::Value &o)
		: byteOffset(0)
		, count(as<std::size_t>(o["count"]))
		, normalized(false)
	{
		check(o.isObject());
		if (o.isMember("bufferView")) {
			bufferView = as<std::size_t>(o["bufferView"]);
		}
		{
			static std::unordered_map<Json::UInt64, ComponentType> map = {
				{5120, ComponentType::BYTE},
				{5121, ComponentType::UNSIGNED_BYTE},
				{5122, ComponentType::SHORT},
				{5123, ComponentType::UNSIGNED_SHORT},
				{5125, ComponentType::UNSIGNED_INT},
				{5126, ComponentType::FLOAT},
			};
			auto v = o["componentType"]; check(v.isUInt64());
			componentType = map.at(v.asUInt64());
		}
		if (o.isMember("byteOffset")) {
			byteOffset = as<std::size_t>(o["byteOffset"]);
			check(byteOffset >= 0);
			check(byteOffset % componentSize() == 0);
		}
		check(count >= 1);
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("normalized")) {
			normalized = as<bool>(o["normalized"]);
		}
		if (o.isMember("sparse")) {
			sparse = as<AccessorSparse>(o["sparse"]);
		}
		{
			static std::unordered_map<Json::String, Type> map = {
				{"MAT2", Type::MAT2},
				{"MAT3", Type::MAT3},
				{"MAT4", Type::MAT4},
				{"SCALAR", Type::SCALAR},
				{"VEC2", Type::VEC2},
				{"VEC3", Type::VEC3},
				{"VEC4", Type::VEC4},
			};
			auto v = o["type"]; check(v.isString());
			type = map.at(v.asString());
		}
		if (o.isMember("max")) {
			max = asVec<double>(o["max"]);
			check(max->size() == typeCount());
		}
		if (o.isMember("min")) {
			min = asVec<double>(o["min"]);
			check(min->size() == typeCount());
		}
	}
};
template<> Accessor as(const Json::Value &o) { return o; }

struct AnimationChannelTarget {
	std::optional<std::size_t> node;
	enum class Path {
		ROTATION,
		SCALE,
		TRANSLATION,
		WEIGHTS,
	};
	Path path;
	AnimationChannelTarget(const Json::Value &o)
	{
		check(o.isObject());
		if (o.isMember("node")) {
			node = as<std::size_t>(o["node"]);
		}
		{
			static std::unordered_map<Json::String, Path> map = {
				{"rotation", Path::ROTATION},
				{"scale", Path::SCALE},
				{"translation", Path::TRANSLATION},
				{"weights", Path::WEIGHTS},
			};
			auto v = o["path"]; check(v.isString());
			path = map.at(v.asString());
		}
	}
};
template<> AnimationChannelTarget as(const Json::Value &o) { return o; }

struct AnimationChannel {
	std::size_t sampler;
	AnimationChannelTarget target;
	AnimationChannel(const Json::Value &o)
		: sampler(as<std::size_t>(o["sampler"]))
		, target(as<AnimationChannelTarget>(o["target"]))
	{
		check(o.isObject());
	}
};
template<> AnimationChannel as(const Json::Value &o) { return o; }

struct AnimationSampler {
	std::size_t input;
	enum class Interpolation {
		CUBICSPLINE,
		LINEAR,
		STEP,
	};
	Interpolation interpolation;
	std::size_t output;
	AnimationSampler(const Json::Value &o)
		: input(as<std::size_t>(o["input"]))
		, interpolation(Interpolation::LINEAR)
		, output(as<std::size_t>(o["output"]))
	{
		check(o.isObject());
		if (o.isMember("interpolation")) {
			static std::unordered_map<Json::String, Interpolation> map = {
				{"CUBICSPLINE", Interpolation::CUBICSPLINE},
				{"LINEAR", Interpolation::LINEAR},
				{"STEP", Interpolation::STEP},
			};
			auto v = o["interpolation"]; check(v.isString());
			interpolation = map.at(v.asString());
		}
	}
};
template<> AnimationSampler as(const Json::Value &o) { return o; }

struct Animation {
	std::vector<AnimationChannel> channels;
	std::optional<std::string> name;
	std::vector<AnimationSampler> samplers;
	Animation(const Json::Value &o)
		: channels(asVec<AnimationChannel>(o["channels"]))
		, samplers(asVec<AnimationSampler>(o["samplers"]))
	{
		check(o.isObject());
		check(channels.size() >= 1);
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		check(samplers.size() >= 1);
	}
};
template<> Animation as(const Json::Value &o) { return o; }

struct Asset {
	std::optional<std::string> copyright;
	std::optional<std::string> generator;
	std::optional<std::string> minVersion;
	std::string version;
	Asset(const Json::Value &o)
		: version(as<std::string>(o["version"]))
	{
		check(o.isObject());
		if (o.isMember("copyright")) {
			copyright = as<std::string>(o["copyright"]);
		}
		if (o.isMember("generator")) {
			generator = as<std::string>(o["generator"]);
		}
		if (o.isMember("minVersion")) {
			minVersion = as<std::string>(o["minVersion"]);
		}
	}
};
template<> Asset as(const Json::Value &o) { return o; }

struct BufferView {
	std::size_t buffer;
	std::size_t byteLength;
	std::size_t byteOffset;
	std::optional<std::size_t> byteStride;
	std::optional<std::string> name;
	enum class Target {
		ARRAY_BUFFER,
		ELEMENT_ARRAY_BUFFER,
	};
	std::optional<Target> target;
	BufferView(const Json::Value &o)
		: buffer(as<std::size_t>(o["buffer"]))
		, byteLength(as<std::size_t>(o["byteLength"]))
		, byteOffset(0)
	{
		check(o.isObject());
		check(byteLength >= 1);
		if (o.isMember("byteOffset")) {
			byteOffset = as<std::size_t>(o["byteOffset"]);
			check(byteOffset >= 0);
		}
		if (o.isMember("byteStride")) {
			byteStride = as<std::size_t>(o["byteStride"]);
			check(byteStride.value() >= 4);
			check(byteStride.value() <= 252);
			check(byteStride.value() % 4 == 0);
		}
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("target")) {
			static std::unordered_map<Json::UInt64, Target> map = {
				{34962, Target::ARRAY_BUFFER},
				{34963, Target::ELEMENT_ARRAY_BUFFER},
			};
			auto v = o["target"]; check(v.isUInt64());
			target = map.at(v.asUInt64());
		}
	}
};
template<> BufferView as(const Json::Value &o) { return o; }

struct Buffer {
	std::size_t byteLength;
	std::optional<std::string> name;
	std::vector<unsigned char> data;
	Buffer(const Json::Value &o,
			const std::function<std::vector<unsigned char>(const std::string &uri)> &resolveURI)
		: byteLength(as<std::size_t>(o["byteLength"]))
	{
		check(o.isObject());
		check(byteLength >= 1);
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		check(o.isMember("uri"));
		bool dataURI = false;
		const std::string uri = as<std::string>(o["uri"]);
		for (auto &prefix : std::array<std::string, 2> {
			"data:application/octet-stream;base64,",
			"data:application/gltf-buffer;base64,"
		}) {
			if (std::string_view(uri).substr(0, prefix.length()) == prefix) {
				auto view = std::string_view(uri).substr(prefix.length());
				check(base64_is_valid(view));
				data = base64_decode(view);
				dataURI = true;
				break;
			}
		}
		if (!dataURI)
			data = resolveURI(uri);
		check(data.size() >= byteLength);
		data.resize(byteLength);
	}
};

struct CameraOrthographic {
	double xmag;
	double ymag;
	double zfar;
	double znear;
	CameraOrthographic(const Json::Value &o)
		: xmag(as<double>(o["xmag"]))
		, ymag(as<double>(o["ymag"]))
		, zfar(as<double>(o["zfar"]))
		, znear(as<double>(o["znear"]))
	{
		check(o.isObject());
		check(zfar > 0);
		check(znear >= 0);
	}
};
template<> CameraOrthographic as(const Json::Value &o) { return o; }

struct CameraPerspective {
	std::optional<double> aspectRatio;
	double yfov;
	std::optional<double> zfar;
	double znear;
	CameraPerspective(const Json::Value &o)
		: yfov(as<double>(o["yfov"]))
		, znear(as<double>(o["znear"]))
	{
		check(o.isObject());
		if (o.isMember("aspectRatio")) {
			aspectRatio = as<double>(o["aspectRatio"]);
			check(aspectRatio.value() > 0);
		}
		check(yfov > 0);
		if (o.isMember("zfar")) {
			zfar = as<double>(o["zfar"]);
			check(zfar.value() > 0);
		}
		check(znear > 0);
	}
};
template<> CameraPerspective as(const Json::Value &o) { return o; }

struct Camera {
	std::optional<std::string> name;
	std::optional<CameraOrthographic> orthographic;
	std::optional<CameraPerspective> perspective;
	enum class Type {
		ORTHOGRAPHIC,
		PERSPECTIVE,
	};
	Type type;
	Camera(const Json::Value &o)
	{
		check(o.isObject());
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("orthographic")) {
			orthographic = as<CameraOrthographic>(o["orthographic"]);
		}
		if (o.isMember("perspective")) {
			perspective = as<CameraPerspective>(o["perspective"]);
		}
		{
			static std::unordered_map<Json::String, Type> map = {
				{"orthographic", Type::ORTHOGRAPHIC},
				{"perspective", Type::PERSPECTIVE},
			};
			auto v = o["type"]; check(v.isString());
			type = map.at(v.asString());
		}
	}
};
template<> Camera as(const Json::Value &o) { return o; }

struct Image {
	std::optional<std::size_t> bufferView;
	enum class MimeType {
		IMAGE_JPEG,
		IMAGE_PNG,
	};
	std::optional<MimeType> mimeType;
	std::optional<std::string> name;
	std::optional<std::string> uri;
	Image(const Json::Value &o)
	{
		check(o.isObject());
		if (o.isMember("bufferView")) {
			bufferView = as<std::size_t>(o["bufferView"]);
		}
		if (o.isMember("mimeType")) {
			static std::unordered_map<Json::String, MimeType> map = {
				{"image/jpeg", MimeType::IMAGE_JPEG},
				{"image/png", MimeType::IMAGE_PNG},
			};
			auto v = o["mimeType"]; check(v.isString());
			mimeType = map.at(v.asString());
		}
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("uri")) {
			uri = as<std::string>(o["uri"]);
		}
	}
};
template<> Image as(const Json::Value &o) { return o; }

struct TextureInfo {
	std::size_t index;
	std::size_t texCoord;
	TextureInfo(const Json::Value &o)
		: index(as<std::size_t>(o["index"]))
		, texCoord(0)
	{
		check(o.isObject());
		if (o.isMember("texCoord")) {
			texCoord = as<std::size_t>(o["texCoord"]);
			check(texCoord >= 0);
		}
	}
};
template<> TextureInfo as(const Json::Value &o) { return o; }

struct MaterialNormalTextureInfo {
	std::size_t index;
	double scale;
	std::size_t texCoord;
	MaterialNormalTextureInfo(const Json::Value &o)
		: index(as<std::size_t>(o["index"]))
		, scale(1)
		, texCoord(0)
	{
		check(o.isObject());
		if (o.isMember("scale")) {
			scale = as<double>(o["scale"]);
		}
		if (o.isMember("texCoord")) {
			texCoord = as<std::size_t>(o["texCoord"]);
		}
	}
};
template<> MaterialNormalTextureInfo as(const Json::Value &o) { return o; }

struct MaterialOcclusionTextureInfo {
	std::size_t index;
	double strength;
	std::size_t texCoord;
	MaterialOcclusionTextureInfo(const Json::Value &o)
		: index(as<std::size_t>(o["index"]))
		, strength(1)
		, texCoord(0)
	{
		check(o.isObject());
		if (o.isMember("strength")) {
			strength = as<double>(o["strength"]);
			check(strength >= 0);
			check(strength <= 1);
		}
		if (o.isMember("texCoord")) {
			texCoord = as<std::size_t>(o["texCoord"]);
		}
	}
};
template<> MaterialOcclusionTextureInfo as(const Json::Value &o) { return o; }

struct MaterialPbrMetallicRoughness {
	std::array<double, 4> baseColorFactor;
	std::optional<TextureInfo> baseColorTexture;
	double metallicFactor;
	std::optional<TextureInfo> metallicRoughnessTexture;
	double roughnessFactor;
	MaterialPbrMetallicRoughness(const Json::Value &o)
		: baseColorFactor{1, 1, 1, 1}
		, metallicFactor(1)
		, roughnessFactor(1)
	{
		check(o.isObject());
		if (o.isMember("baseColorFactor")) {
			baseColorFactor = asArr<double, 4>(o["baseColorFactor"]);
			for (auto v: baseColorFactor) {
				check(v >= 0);
				check(v <= 1);
			}
		}
		if (o.isMember("baseColorTexture")) {
			baseColorTexture = as<TextureInfo>(o["baseColorTexture"]);
		}
		if (o.isMember("metallicFactor")) {
			metallicFactor = as<double>(o["metallicFactor"]);
			check(metallicFactor >= 0);
			check(metallicFactor <= 1);
		}
		if (o.isMember("metallicRoughnessTexture")) {
			metallicRoughnessTexture = as<TextureInfo>(o["metallicRoughnessTexture"]);
		}
		if (o.isMember("roughnessFactor")) {
			roughnessFactor = as<double>(o["roughnessFactor"]);
			check(roughnessFactor >= 0);
			check(roughnessFactor <= 1);
		}
	}
};
template<> MaterialPbrMetallicRoughness as(const Json::Value &o) { return o; }

struct Material {
	double alphaCutoff;
	enum class AlphaMode {
		BLEND,
		MASK,
		OPAQUE,
	};
	AlphaMode alphaMode;
	bool doubleSided;
	std::array<double, 3> emissiveFactor;
	std::optional<TextureInfo> emissiveTexture;
	std::optional<std::string> name;
	std::optional<MaterialNormalTextureInfo> normalTexture;
	std::optional<MaterialOcclusionTextureInfo> occlusionTexture;
	std::optional<MaterialPbrMetallicRoughness> pbrMetallicRoughness;
	Material(const Json::Value &o)
		: alphaCutoff(0.5)
		, alphaMode(AlphaMode::OPAQUE)
		, doubleSided(false)
		, emissiveFactor{0, 0, 0}
	{
		check(o.isObject());
		if (o.isMember("alphaCutoff")) {
			alphaCutoff = as<double>(o["alphaCutoff"]);
			check(alphaCutoff >= 0);
		}
		if (o.isMember("alphaMode")){
			static std::unordered_map<Json::String, AlphaMode> map = {
				{"BLEND", AlphaMode::BLEND},
				{"MASK", AlphaMode::MASK},
				{"OPAQUE", AlphaMode::OPAQUE},
			};
			auto v = o["alphaMode"]; check(v.isString());
			alphaMode = map.at(v.asString());
		}
		if (o.isMember("doubleSided")) {
			doubleSided = as<bool>(o["doubleSided"]);
		}
		if (o.isMember("emissiveFactor")) {
			emissiveFactor = asArr<double, 3>(o["emissiveFactor"]);
			for (auto v: emissiveFactor) {
				check(v >= 0);
				check(v <= 1);
			}
		}
		if (o.isMember("emissiveTexture")) {
			emissiveTexture = as<TextureInfo>(o["emissiveTexture"]);
		}
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("normalTexture")) {
			normalTexture = as<MaterialNormalTextureInfo>(o["normalTexture"]);
		}
		if (o.isMember("occlusionTexture")) {
			occlusionTexture = as<MaterialOcclusionTextureInfo>(o["occlusionTexture"]);
		}
		if (o.isMember("pbrMetallicRoughness")) {
			pbrMetallicRoughness = as<MaterialPbrMetallicRoughness>(o["pbrMetallicRoughness"]);
		}
	}
};
template<> Material as(const Json::Value &o) { return o; }

struct MeshPrimitive {
	static void enumeratedProps(const Json::Value &o, const std::string &name, std::optional<std::vector<std::size_t>> &attr) {
		for (std::size_t i = 0;; ++i) {
			const std::string s = name + "_" + std::to_string(i);
			if (!o.isMember(s)) break;
			if (i == 0) {
				attr = std::vector<std::size_t>();
			}
			attr->push_back(as<std::size_t>(o[s]));
		}
	}
	struct Attributes {
		std::optional<std::size_t> position, normal, tangent;
		std::optional<std::vector<std::size_t>> texcoord, color, joints, weights;
		Attributes(const Json::Value &o) {
			if (o.isMember("POSITION"))
				position = as<std::size_t>(o["POSITION"]);
			if (o.isMember("NORMAL"))
				normal = as<std::size_t>(o["NORMAL"]);
			if (o.isMember("TANGENT"))
				tangent = as<std::size_t>(o["TANGENT"]);
			enumeratedProps(o, "TEXCOORD", texcoord);
			enumeratedProps(o, "COLOR", color);
			enumeratedProps(o, "JOINTS", joints);
			enumeratedProps(o, "WEIGHTS", weights);
			check(joints.has_value() == weights.has_value());
			if (joints.has_value()) {
				check(joints->size() == weights->size());
			}
			check(position.has_value()
					|| normal.has_value()
					|| tangent.has_value()
					|| texcoord.has_value()
					|| color.has_value()
					|| joints.has_value()
					|| weights.has_value());
		}
	};
	Attributes attributes;
	std::optional<std::size_t> indices;
	std::optional<std::size_t> material;
	enum class Mode {
		POINTS,
		LINES,
		LINE_LOOP,
		LINE_STRIP,
		TRIANGLES,
		TRIANGLE_STRIP,
		TRIANGLE_FAN,
	};
	Mode mode;
	struct MorphTargets {
		std::optional<std::size_t> position, normal, tangent;
		std::optional<std::vector<std::size_t>> texcoord, color;
		MorphTargets(const Json::Value &o) {
			if (o.isMember("POSITION"))
				position = as<std::size_t>(o["POSITION"]);
			if (o.isMember("NORMAL"))
				normal = as<std::size_t>(o["NORMAL"]);
			if (o.isMember("TANGENT"))
				tangent = as<std::size_t>(o["TANGENT"]);
			enumeratedProps(o, "TEXCOORD", texcoord);
			enumeratedProps(o, "COLOR", color);
			check(position.has_value()
					|| normal.has_value()
					|| tangent.has_value()
					|| texcoord.has_value()
					|| color.has_value());
		}
	};
	std::optional<std::vector<MorphTargets>> targets;
	MeshPrimitive(const Json::Value &o)
		: attributes(Attributes(o["attributes"]))
		, mode(Mode::TRIANGLES)
	{
		check(o.isObject());
		if (o.isMember("indices")) {
			indices = as<std::size_t>(o["indices"]);
		}
		if (o.isMember("material")) {
			material = as<std::size_t>(o["material"]);
		}
		if (o.isMember("mode")) {
			static std::unordered_map<Json::UInt64, Mode> map = {
				{0, Mode::POINTS},
				{1, Mode::LINES},
				{2, Mode::LINE_LOOP},
				{3, Mode::LINE_STRIP},
				{4, Mode::TRIANGLES},
				{5, Mode::TRIANGLE_STRIP},
				{6, Mode::TRIANGLE_FAN},
			};
			auto v = o["mode"]; check(v.isUInt64());
			mode = map.at(v.asUInt64());
		}
		if (o.isMember("targets")) {
			targets = asVec<MorphTargets>(o["targets"]);
			check(targets->size() >= 1);
		}
	}
};
template<> MeshPrimitive::MorphTargets as(const Json::Value &o) { return o; }
template<> MeshPrimitive as(const Json::Value &o) { return o; }

struct Mesh {
	std::optional<std::string> name;
	std::vector<MeshPrimitive> primitives;
	std::optional<std::vector<double>> weights;
	Mesh(const Json::Value &o)
		: primitives(asVec<MeshPrimitive>(o["primitives"]))
	{
		check(o.isObject());
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		check(primitives.size() >= 1);
		if (o.isMember("weights")) {
			weights = asVec<double>(o["weights"]);
			check(weights->size() >= 1);
		}
	}
};
template<> Mesh as(const Json::Value &o) { return o; }

struct Node {
	std::optional<std::size_t> camera;
	std::optional<std::vector<std::size_t>> children;
	typedef std::array<double, 16> Matrix;
	struct TRS {
		std::array<double, 3> translation = {0, 0, 0};
		std::array<double, 4> rotation = {0, 0, 0, 1};
		std::array<double, 3> scale = {1, 1, 1};
	};
	std::variant<Matrix, TRS> transform;
	std::optional<std::size_t> mesh;
	std::optional<std::string> name;
	std::optional<std::size_t> skin;
	std::optional<std::vector<double>> weights;
	Node(const Json::Value &o)
		: transform(Matrix {
			1, 0, 0, 0,
			0, 1, 0, 0,
			0, 0, 1, 0,
			0, 0, 0, 1
		})
	{
		check(o.isObject());
		if (o.isMember("camera")) {
			camera = as<std::size_t>(o["camera"]);
		}
		if (o.isMember("children")) {
			children = asVec<std::size_t>(o["children"]);
			check(children->size() >= 1);
			checkDuplicateFree(*children);
		}
		bool hasTRS = o.isMember("translation") || o.isMember("rotation") || o.isMember("scale");
		if (o.isMember("matrix")) {
			check(!hasTRS);
			transform = asArr<double, 16>(o["matrix"]);
		} else if (hasTRS) {
			TRS trs;
			if (o.isMember("translation")) {
				trs.translation = asArr<double, 3>(o["translation"]);
			}
			if (o.isMember("rotation")) {
				trs.rotation = asArr<double, 4>(o["rotation"]);
				for (auto v: trs.rotation) {
					check(v >= -1);
					check(v <= 1);
				}
			}
			if (o.isMember("scale")) {
				trs.scale = asArr<double, 3>(o["scale"]);
			}
			transform = std::move(trs);
		}
		if (o.isMember("mesh")) {
			mesh = as<std::size_t>(o["mesh"]);
		}
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("skin")) {
			check(mesh.has_value());
			skin = as<std::size_t>(o["skin"]);
		}
		if (o.isMember("weights")) {
			weights = asVec<double>(o["weights"]);
			check(weights->size() >= 1);
		}
	}
};
template<> Node as(const Json::Value &o) { return o; }

struct Sampler {
	enum class MagFilter {
		NEAREST,
		LINEAR,
	};
	std::optional<MagFilter> magFilter;
	enum class MinFilter {
		NEAREST,
		LINEAR,
		NEAREST_MIPMAP_NEAREST,
		LINEAR_MIPMAP_NEAREST,
		NEAREST_MIPMAP_LINEAR,
		LINEAR_MIPMAP_LINEAR,
	};
	std::optional<MinFilter> minFilter;
	std::optional<std::string> name;
	enum class WrapS {
		REPEAT,
		CLAMP_TO_EDGE,
		MIRRORED_REPEAT,
	};
	WrapS wrapS;
	enum class WrapT {
		REPEAT,
		CLAMP_TO_EDGE,
		MIRRORED_REPEAT,
	};
	WrapT wrapT;
	Sampler(const Json::Value &o)
		: wrapS(WrapS::REPEAT)
		, wrapT(WrapT::REPEAT)
	{
		check(o.isObject());
		if (o.isMember("magFilter")) {
			static std::unordered_map<Json::UInt64, MagFilter> map = {
				{9728, MagFilter::NEAREST},
				{9729, MagFilter::LINEAR},
			};
			auto v = o["magFilter"]; check(v.isUInt64());
			magFilter = map.at(v.asUInt64());
		}
		if (o.isMember("minFilter")) {
			static std::unordered_map<Json::UInt64, MinFilter> map = {
				{9728, MinFilter::NEAREST},
				{9729, MinFilter::LINEAR},
				{9984, MinFilter::NEAREST_MIPMAP_NEAREST},
				{9985, MinFilter::LINEAR_MIPMAP_NEAREST},
				{9986, MinFilter::NEAREST_MIPMAP_LINEAR},
				{9987, MinFilter::LINEAR_MIPMAP_LINEAR},
			};
			auto v = o["minFilter"]; check(v.isUInt64());
			minFilter = map.at(v.asUInt64());
		}
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("wrapS")) {
			static std::unordered_map<Json::UInt64, WrapS> map = {
				{10497, WrapS::REPEAT},
				{33071, WrapS::CLAMP_TO_EDGE},
				{33648, WrapS::MIRRORED_REPEAT},
			};
			auto v = o["wrapS"]; check(v.isUInt64());
			wrapS = map.at(v.asUInt64());
		}
		if (o.isMember("wrapT")) {
			static std::unordered_map<Json::UInt64, WrapT> map = {
				{10497, WrapT::REPEAT},
				{33071, WrapT::CLAMP_TO_EDGE},
				{33648, WrapT::MIRRORED_REPEAT},
			};
			auto v = o["wrapT"]; check(v.isUInt64());
			wrapT = map.at(v.asUInt64());
		}
	}
};
template<> Sampler as(const Json::Value &o) { return o; }

struct Scene {
	std::optional<std::string> name;
	std::optional<std::vector<std::size_t>> nodes;
	Scene(const Json::Value &o)
	{
		check(o.isObject());
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("nodes")) {
			nodes = asVec<std::size_t>(o["nodes"]);
			check(nodes->size() >= 1);
			checkDuplicateFree(*nodes);
		}
	}
};
template<> Scene as(const Json::Value &o) { return o; }

struct Skin {
	std::optional<std::size_t> inverseBindMatrices;
	std::vector<std::size_t> joints;
	std::optional<std::string> name;
	std::optional<std::size_t> skeleton;
	Skin(const Json::Value &o)
		: joints(asVec<std::size_t>(o["joints"]))
	{
		check(o.isObject());
		if (o.isMember("inverseBindMatrices")) {
			inverseBindMatrices = as<std::size_t>(o["inverseBindMatrices"]);
		}
		check(joints.size() >= 1);
		checkDuplicateFree(joints);
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("skeleton")) {
			skeleton = as<std::size_t>(o["skeleton"]);
		}
	}
};
template<> Skin as(const Json::Value &o) { return o; }

struct Texture {
	std::optional<std::string> name;
	std::optional<std::size_t> sampler;
	std::optional<std::size_t> source;
	Texture(const Json::Value &o)
	{
		check(o.isObject());
		if (o.isMember("name")) {
			name = as<std::string>(o["name"]);
		}
		if (o.isMember("sampler")) {
			sampler = as<std::size_t>(o["sampler"]);
		}
		if (o.isMember("source")) {
			source = as<std::size_t>(o["source"]);
		}
	}
};
template<> Texture as(const Json::Value &o) { return o; }

struct GlTF {
	std::optional<std::vector<Accessor>> accessors;
	std::optional<std::vector<Animation>> animations;
	Asset asset;
	std::optional<std::vector<BufferView>> bufferViews;
	std::optional<std::vector<Buffer>> buffers;
	std::optional<std::vector<Camera>> cameras;
	std::optional<std::vector<std::string>> extensionsRequired;
	std::optional<std::vector<std::string>> extensionsUsed;
	std::optional<std::vector<Image>> images;
	std::optional<std::vector<Material>> materials;
	std::optional<std::vector<Mesh>> meshes;
	std::optional<std::vector<Node>> nodes;
	std::optional<std::vector<Sampler>> samplers;
	std::optional<std::size_t> scene;
	std::optional<std::vector<Scene>> scenes;
	std::optional<std::vector<Skin>> skins;
	std::optional<std::vector<Texture>> textures;
	static std::vector<unsigned char> uriError(const std::string &uri) {
		// only base64 data URI support by default
		throw std::runtime_error("unsupported URI: " + uri);
	}
	GlTF(const Json::Value &o,
			const std::function<std::vector<unsigned char>(const std::string &uri)> &resolveURI = uriError)
		: asset(as<Asset>(o["asset"]))
	{
		check(o.isObject());
		if (o.isMember("accessors")) {
			accessors = asVec<Accessor>(o["accessors"]);
			check(accessors->size() >= 1);
		}
		if (o.isMember("animations")) {
			animations = asVec<Animation>(o["animations"]);
			check(animations->size() >= 1);
		}
		if (o.isMember("bufferViews")) {
			bufferViews = asVec<BufferView>(o["bufferViews"]);
			check(bufferViews->size() >= 1);
		}
		if (o.isMember("buffers")) {
			auto b = o["buffers"];
			check(b.isArray());
			std::vector<Buffer> bufs;
			bufs.reserve(b.size());
			for (Json::ArrayIndex i = 0; i < b.size(); ++i) {
				bufs.push_back(Buffer(b[i], resolveURI));
			}
			check(bufs.size() >= 1);
			buffers = std::move(bufs);
		}
		if (o.isMember("cameras")) {
			cameras = asVec<Camera>(o["cameras"]);
			check(cameras->size() >= 1);
		}
		if (o.isMember("extensionsRequired")) {
			extensionsRequired = asVec<std::string>(o["extensionsRequired"]);
			check(extensionsRequired->size() >= 1);
			checkDuplicateFree(*extensionsRequired);
		}
		if (o.isMember("extensionsUsed")) {
			extensionsUsed = asVec<std::string>(o["extensionsUsed"]);
			check(extensionsUsed->size() >= 1);
			checkDuplicateFree(*extensionsUsed);
		}
		if (o.isMember("images")) {
			images = asVec<Image>(o["images"]);
			check(images->size() >= 1);
		}
		if (o.isMember("materials")) {
			materials = asVec<Material>(o["materials"]);
			check(materials->size() >= 1);
		}
		if (o.isMember("meshes")) {
			meshes = asVec<Mesh>(o["meshes"]);
			check(meshes->size() >= 1);
		}
		if (o.isMember("nodes")) {
			nodes = asVec<Node>(o["nodes"]);
			check(nodes->size() >= 1);
			// Nodes must be a forest:
			// 1. Each node should have indegree 0 or 1:
			std::vector<std::size_t> indeg(nodes->size());
			for (std::size_t i = 0; i < nodes->size(); ++i) {
				auto children = nodes->at(i).children;
				if (!children.has_value()) continue;
				for (auto child : children.value()) {
					++indeg.at(child);
				}
			}
			for (const auto deg : indeg) {
				check(deg <= 1);
			}
			// 2. There should be no cycles:
			std::vector<bool> visited(nodes->size());
			std::stack<std::size_t, std::vector<std::size_t>> toVisit;
			for (std::size_t i = 0; i < nodes->size(); ++i) {
				// Only start DFS in roots.
				if (indeg[i] > 0)
					continue;

				toVisit.push(i);
				do {
					std::size_t j = toVisit.top();
					check(!visited.at(j));
					visited[j] = true;
					toVisit.pop();
					auto children = nodes->at(j).children;
					if (!children.has_value())
						continue;
					for (auto child : *children) {
						toVisit.push(child);
					}
				} while (!toVisit.empty());
			}
		}
		if (o.isMember("samplers")) {
			samplers = asVec<Sampler>(o["samplers"]);
			check(samplers->size() >= 1);
		}
		if (o.isMember("scene")) {
			scene = as<std::size_t>(o["scene"]);
		}
		if (o.isMember("scenes")) {
			scenes = asVec<Scene>(o["scenes"]);
			check(scenes->size() >= 1);
		}
		if (o.isMember("skins")) {
			skins = asVec<Skin>(o["skins"]);
			check(skins->size() >= 1);
		}
		if (o.isMember("textures")) {
			textures = asVec<Texture>(o["textures"]);
			check(textures->size() >= 1);
		}

		// Validation

		checkForall(bufferViews, [&](const BufferView &view) {
			check(buffers.has_value());
			const Buffer &buf = buffers->at(view.buffer);
			// Be careful because of possible integer overflows.
			check(view.byteOffset < buf.byteLength);
			check(view.byteLength <= buf.byteLength);
			check(view.byteOffset <= buf.byteLength - view.byteLength);
		});

		checkForall(accessors, [&](const Accessor &accessor) {
			checkIndex(bufferViews, accessor.bufferView);
			if (accessor.bufferView.has_value()) {
				const BufferView &view = bufferViews->at(accessor.bufferView.value());
				if (view.byteStride.has_value())
					check(view.byteStride.value() % accessor.componentSize() == 0);
				check(accessor.byteOffset < view.byteLength);
				// Use division to avoid overflows.
				// TODO this should be (but written in such a way that overflows are avoided):
				// `accessor.byteOffset + EFFECTIVE_BYTE_STRIDE * (accessor.count - 1) + SIZE_OF_COMPONENT * NUMBER_OF_COMPONENTS`
				check(accessor.count <= view.byteLength / view.byteStride.value_or(accessor.elementSize()));
			}
			if (accessor.sparse.has_value()) {
				// Again be careful because of possible integer overflows.
				{
					const auto &indices = accessor.sparse->indices;
					checkIndex(bufferViews, indices.bufferView);
					const BufferView &view = bufferViews->at(indices.bufferView);
					check(indices.byteOffset < view.byteLength);
					// TODO take byte stride into account
					check(accessor.sparse->count <= (view.byteLength - indices.byteOffset) / indices.elementSize());
				}
				{
					const auto &values = accessor.sparse->values;
					checkIndex(bufferViews, values.bufferView);
					const BufferView &view = bufferViews->at(values.bufferView);
					check(values.byteOffset < view.byteLength);
					// TODO take byte stride into account
					check(accessor.sparse->count <= (view.byteLength - values.byteOffset) / accessor.elementSize());
				}
			}
		});

		checkForall(images, [&](const Image &image) {
			checkIndex(bufferViews, image.bufferView);
		});

		checkForall(meshes, [&](const Mesh &mesh) {
			for (const auto &primitive : mesh.primitives) {
				checkIndex(accessors, primitive.indices);
				checkIndex(materials, primitive.material);
				checkIndex(accessors, primitive.attributes.normal);
				checkIndex(accessors, primitive.attributes.position);
				checkIndex(accessors, primitive.attributes.tangent);
				checkForall(primitive.attributes.texcoord, [&](const std::size_t &i) {
					checkIndex(accessors, i);
				});
				checkForall(primitive.attributes.color, [&](const std::size_t &i) {
					checkIndex(accessors, i);
				});
				checkForall(primitive.attributes.joints, [&](const std::size_t &i) {
					checkIndex(accessors, i);
				});
				checkForall(primitive.attributes.weights, [&](const std::size_t &i) {
					checkIndex(accessors, i);
				});
				if (primitive.material.has_value()) {
					const Material &material = materials->at(primitive.material.value());
					if (material.emissiveTexture.has_value()) {
						check(primitive.attributes.texcoord.has_value());
						check(material.emissiveTexture->texCoord < primitive.attributes.texcoord->size());
					}
					if (material.normalTexture.has_value()) {
						check(primitive.attributes.texcoord.has_value());
						check(material.normalTexture->texCoord < primitive.attributes.texcoord->size());
					}
					if (material.occlusionTexture.has_value()) {
						check(primitive.attributes.texcoord.has_value());
						check(material.occlusionTexture->texCoord < primitive.attributes.texcoord->size());
					}
				}
				checkForall(primitive.targets, [&](const MeshPrimitive::MorphTargets &target) {
					checkIndex(accessors, target.normal);
					checkIndex(accessors, target.position);
					checkIndex(accessors, target.tangent);
					checkForall(target.texcoord, [&](const std::size_t &i) {
						checkIndex(accessors, i);
					});
					checkForall(target.color, [&](const std::size_t &i) {
						checkIndex(accessors, i);
					});
				});
			}
		});

		checkForall(nodes, [&](const Node &node) {
			checkIndex(cameras, node.camera);
			checkIndex(meshes, node.mesh);
			checkIndex(skins, node.skin);
		});

		checkForall(scenes, [&](const Scene &scene) {
			checkForall(scene.nodes, [&](const size_t &i) {
				checkIndex(nodes, i);
			});
		});

		checkForall(skins, [&](const Skin &skin) {
			checkIndex(accessors, skin.inverseBindMatrices);
			for (const std::size_t &i : skin.joints)
				checkIndex(nodes, i);
			checkIndex(nodes, skin.skeleton);
		});

		checkForall(textures, [&](const Texture &texture) {
			checkIndex(samplers, texture.sampler);
			checkIndex(images, texture.source);
		});

		checkForall(animations, [&](const Animation &animation) {
			for (const auto &sampler : animation.samplers) {
				checkIndex(accessors, sampler.input);
				const auto &accessor = accessors->at(sampler.input);
				check(accessor.type == Accessor::Type::SCALAR);
				check(accessor.componentType == Accessor::ComponentType::FLOAT);
				checkIndex(accessors, sampler.output);
			}
			for (const auto &channel : animation.channels) {
				checkIndex(nodes, channel.target.node);
				checkIndex(animation.samplers, channel.sampler);
			}
		});

		checkIndex(scenes, scene);
	}
};

}