#include "../../../include/assets/data_parsers"

#include "../../../include/assets/read_buffers"

#include <fstream>
#include <glm/ext/matrix_transform.hpp>
#include <glm/gtx/euler_angles.hpp>

#include "util/logger.hpp"



inline std::error_code threedtk_pose_loader::parse_transform_info(
	std::ifstream& in,
	std::string& line,
	std::array<glm::vec3, 2>& transform_info
) {

	for (std::size_t row{}; row != 2; ++row) {

		std::getline(in, line);

		auto it = line.cbegin().base();
		auto end = line.cend().base();

		for (glm::vec3::length_type col{}; col != 3; ++col) {

			const auto [ ptr, ec ] = std::from_chars(
				it, end,
				transform_info[row][col],
				std::chars_format::general
			);

			if (ec != std::errc{}) {
				return std::make_error_code(ec);
			}

			it = ptr + 1; // skip space in between components
		}
	}
}

inline ztu::result<pose_prefetch_lookup::index_type> threedtk_pose_loader::parse_index(
	const std::string_view filename
) {
	static constexpr auto prefix = std::string_view{ "scan" };

	auto name_view = filename.substr(0, name_view.find('.'));

	if (name_view.length() <= prefix.length()) [[unlikely]]
	{
		return std::make_error_code(std::errc::invalid_argument);
	}

	name_view = name_view.substr(prefix.length());

	pose_prefetch_lookup::index_type index;

	const auto res = std::from_chars(name_view.begin(), name_view.end(), index);

	if (res.ec != std::errc{}) [[unlikely]]
	{
		return std::make_error_code(res.ec);
	}

	return index;
}


void threedtk_pose_loader::load(
	const ztu::string_list& filenames,
	dynamic_pose_store& store,
	pose_prefetch_lookup& id_lookup
) {

	auto filename_buffer = std::string{};
	auto in = std::ifstream{};
	auto line = std::string{};
	auto pose_buffer = dynamic_pose_buffer{};

	for (const auto filename : filenames)
	{

		pose_prefetch_lookup::index_type index;
		if (const auto res = parse_index(filename))
		{
			index = *res;
		}
		else
		{
			const auto error = res.error();
			ztu::logger::error(
				"Error while parsing 3dtk pose file index %: [%] %",
				filename,
				error.category().name(),
				error.message()
			);
		}

		filename_buffer = filename;
		in.open(filename_buffer.c_str());
		if (not in.is_open()) {
			ztu::logger::error("Cannot open 3dtk pose file %", filename);
			continue;
		}

		std::array<glm::vec3, 2> transform_info{};

		const auto error = parse_transform_info(in, line, transform_info);

		in.close();

		if (error)
		{
			ztu::logger::error(
				"Error while parsing 3dtk pose file %: [%] %",
				filename,
				error.category().name(),
				error.message()
			);
			continue;
		}

		const auto& translation = transform_info[0];
		auto& angles = transform_info[1];
		angles *= static_cast<float>(M_PI / 180.0);

		pose_buffer = (
			glm::translate(glm::identity<glm::mat4>(), translation) *
			glm::eulerAngleXYZ(angles[0], angles[1], angles[2])
		);

		const auto id = store.add(pose_buffer);
		id_lookup.emplace(filename, index, id);
	}
}