#include "string.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

typedef uint8_t Byte;

typedef struct {
	Byte* buf;
	size_t cap;
} Buffer;

typedef struct {
	char* str;
	size_t cap;
} String;

typedef struct {
	void* data;
	String name;
	size_t size;
} Member;

typedef struct {
	Member* members;
	size_t cap;
} Members;

Buffer serialize(Members src) {
	Buffer buffer = {
		.buf = (Byte*)malloc(sizeof(Byte) * 0xFF),
		.cap = 0x100,
	};

	size_t total_size = 0;
	for (size_t i = 0; i < src.cap; ++i) {
		Member mem = src.members[i];

		size_t required_size = sizeof(size_t) + mem.name.cap + sizeof(size_t) + mem.size;

		while (total_size + required_size >= buffer.cap) {
			buffer.buf = realloc(buffer.buf, buffer.cap * 2);
			buffer.cap *= 2;
		}

		printf("[INFO]: New member:\n");
		printf("\tcap: %zu\n", mem.name.cap);
		printf("\tname: %s\n", mem.name.str);
		printf("\tsize: %zu\n", mem.size);
		printf("\tdata location: %zu\n", (size_t)mem.data);

		memcpy(buffer.buf + total_size, &mem.name.cap, sizeof(size_t));
		total_size += sizeof(size_t);

		memcpy(buffer.buf + total_size, mem.name.str, mem.name.cap);
		total_size += mem.name.cap;

		memcpy(buffer.buf + total_size, &mem.size, sizeof(size_t));
		total_size += sizeof(size_t);

		memcpy(buffer.buf + total_size, mem.data, mem.size);
		total_size += mem.size;
	}


	buffer.buf = realloc(buffer.buf, total_size);
	buffer.cap = total_size;

	return buffer;
}

typedef struct {
	size_t a;
	uint32_t b;
	uint8_t* c;
	union {
		uint16_t t16;
		uint8_t t8_2[2];
	} d;
} MyStruct;

Members to_members(MyStruct ms) {

	size_t cap = sizeof(size_t) + sizeof(uint32_t) + sizeof(uint8_t*) + sizeof(uint16_t);
	Member* members = malloc(sizeof(Member) * cap);

	members[0] = (Member){
		.data = &ms.a,
		.name = {
			.str = (char*)"a",
			.cap = 2,
		},
		.size = sizeof(size_t)
	};

	members[1] = (Member){
		.data = &ms.b,
		.name = {
			.str = (char*)"b",
			.cap = 2,
		},
		.size = sizeof(uint32_t)
	};

	members[2] = (Member){
		.data = &*ms.c,
		.name = {
			.str = (char*)"c",
			.cap = 2,
		},
		.size = sizeof(uint8_t*)
	};

	members[3] = (Member){
		.data = &ms.d,
		.name = {
			.str = (char*)"c",
			.cap = 2,
		},
		.size = sizeof(uint16_t)
	};

	return (Members){
		.members = members,
		.cap = cap,
	};
}

int main() {
	size_t a = 420;
	void* aa = &a;
	Byte buf[100] = {0};
	Buffer buffer = {
		.buf = buf,
		.cap = 100,
	};
	memcpy(buffer.buf, aa, 8);
	printf("[INFO]: %d\n", buffer.buf[0]);
	printf("[INFO]: %d\n", buffer.buf[1]);
	printf("[INFO]: %d\n", buffer.buf[2]);
	printf("[INFO]: %d\n", buffer.buf[3]);
	printf("[INFO]: %d\n", buffer.buf[4]);
	printf("[INFO]: %d\n", buffer.buf[5]);
	printf("[INFO]: %d\n", buffer.buf[7]);
	/*
	MyStruct ms = {
		.a = 420,
		.b = 60000,
		.c = malloc(sizeof(uint8_t)),
		.d.t8_2 = {[0] = 1, [1] = 2}
	};

	Members mem = to_members(ms);

	Buffer buffer = serialize(mem);

	for (size_t i = 0; i < buffer.cap; ++i) {
		printf("[%d] ", buffer.buf[i]);
	}

	free(buffer.buf);
	free(mem.members);
	*/
	return 0;
}