ACPlayer_tracker/include/handle.hpp

#ifndef HANDLE_HPP
#define HANDLE_HPP

#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>

#include "file.hpp" // for parce_args
#include "net.hpp"  // for socket operations
#include "server_structs.h"

using namespace std;

class PacketReader {
  private:
	const u_char *buffer_;
	size_t buffer_size_;
	size_t offset_ = 0;
	bool error_ = false;

  public:
	PacketReader();  // TODO:
	~PacketReader(); // TODO:

	bool read_uint8(uint8_t &value) {
		size_t __bytes = sizeof(value);

		if (offset_ + __bytes > buffer_size_) {
			error_ = true;
			return false;
		}

		memcpy(&value, buffer_ + offset_, sizeof(value));

		offset_++;
		return true;
	}

	bool read_uint16(uint16_t &value) {
		size_t __bytes = sizeof(value);

		if (offset_ + __bytes > buffer_size_) {
			error_ = true;
			return false;
		}

		memcpy(&value, buffer_ + offset_, sizeof(value));
		value = ntohs(value);

		offset_ += 2;
		return true;
	}

	bool read_uint32(uint32_t &value) {
		size_t __bytes = sizeof(value);

		if (offset_ + __bytes > buffer_size_) {
			error_ = true;
			return false;
		}

		memcpy(&value, buffer_ + offset_, sizeof(value));
		value = ntohl(value);

		offset_ += 4;
		return true;
	}

	bool read_float(float &value) {
		size_t __bytes = sizeof(value);

		if (offset_ + __bytes > buffer_size_) {
			error_ = true;
			return false;
		}

		uint32_t v_int;
		memcpy(&v_int, buffer_ + offset_, sizeof(v_int));
		v_int = ntohl(v_int);

		memcpy(&value, &v_int, sizeof(value));

		offset_ += 4;
		return true;
	}

	bool read_string_utf32l(string &value) {
		uint8_t __length;
		if (!read_uint8(__length))
			return false;

		if (offset_ + (__length * sizeof(uint32_t)) > buffer_size_) {
			error_ = true;
			return false;
		}

		value.clear();
		for (size_t i = 0; i < __length; i++) {
			uint32_t codeunit;
			if (!read_uint32(codeunit))
				return false;

			if (codeunit == 0) {
				break; // null terminator
			}

			value.push_back(static_cast<char>(codeunit));
		}

		return true;
	}

	bool has_error() const {
		return error_;
	}
};

class ProtocolHandler {
  private:
	trackAtributes track_info_;
	carAtributes player_info_[64];

  public:
	ProtocolHandler();
	~ProtocolHandler();

	bool handle_new_session(PacketReader &reader) {

		if (!reader.read_uint8(track_info_.protocol_version))
			return false;
		if (!reader.read_uint8(track_info_.session_index))
			return false;
		if (!reader.read_uint8(track_info_.current_session_index))
			return false;
		if (!reader.read_uint8(track_info_.session_count))
			return false;

        /*
         * str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.server_name, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track_config, str_len_8, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.session_name, str_len_8, &ok);

			trackInfo.typ = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.laps = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.wait_time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.ambient_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			trackInfo.road_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);

			str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
			read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.weather_graphics, str_len_8, &ok);
         */

        if (!reader.read_string_utf32l(track_info_.server_name))
            return false;
        if (!reader.read_string_utf32l(track_info_.track))
            return false;
        if (!reader.read_string_utf32l(track_info_.track_config))
            return false;
        if (!reader.read_string_utf32l(track_info_.session_name))
            return false;
        if (!reader.read_uint8(track_info_.typ))
            return false;
        if (!reader.read_uint16(track_info_.time))
            return false;
        if (!reader.read_uint16(track_info_.laps))
            return false;
        if (!reader.read_uint16(track_info_.wait_time))
            return false;
        if (!reader.read_uint8(track_info_.ambient_temp))
            return false;
        if (!reader.read_uint8(track_info_.road_temp))
            return false;
        if (!reader.read_string_utf32l(track_info_.weather_graphics))
            return false;

		return true;
	}
};
#endif // HANDLE_HPP