ghost/src/splits.c.no2

#include <raylib.h>
#include <stdlib.h>
#include <math.h>

#include "splits.h"
#include "timer.h"
#include "xml.h"
#include "fmt.h"

extern Font font;
extern void error(const char *msg);

void print_segment(segment *seg) {
    printf("%s\n", seg->name);
    //printf("%ld.%ld\n", seg->realtime.tv_sec, seg->realtime.tv_nsec);
}

//utils
int get_file_size(FILE *file) {
	int size;
	fseek(file, 0L, SEEK_END);
	size = ftell(file);
	fseek(file, 0L, SEEK_SET);
	return size;
}

void log_node(struct xml_node *node) {
	//struct xml_node *root = xml_document_root(document);
	struct xml_string *name = xml_node_name(node);
	struct xml_string *content = xml_node_content(node);
	int name_len = xml_string_length(name);
	int content_len = xml_string_length(content);
	uint8_t *name_buffer = calloc(name_len + 1, sizeof(uint8_t));
	uint8_t *content_buffer = calloc(content_len + 1, sizeof(uint8_t));
	xml_string_copy(name, name_buffer, name_len);
	xml_string_copy(content, content_buffer, content_len);
	printf("%s: %s\n", name_buffer, content_buffer);
	free(name_buffer);
	free(content_buffer);
}

//print children of node
void enum_node(struct xml_node *node) {
	int children;
	children = xml_node_children(node);

	for (int i = 0; i < children; i++) {
		struct xml_node *child = xml_node_child(node, i);
		log_node(child);
		//enum_node(child);
	}
}

void enum_node_recursive(struct xml_node *node) {
	int children;
	children = xml_node_children(node);

	for (int i = 0; i < children; i++) {
		struct xml_node *child = xml_node_child(node, i);
		log_node(child);
		enum_node(child);
	}
}

bool xml_name_compare(struct xml_node *node, const char *str) {
	bool equal;
	struct xml_string *name = xml_node_name(node);
	int len = xml_string_length(name);
	
	uint8_t *buffer = calloc(len + 1, sizeof(uint8_t));
	xml_string_copy(name, buffer, len);
	equal = !strcmp(buffer, str);
	free(buffer);
	return equal;
}

typedef struct segment_nodes {
	struct xml_node **nodes;
	int count;
} segment_nodes;

segment_nodes get_node_children(struct xml_node *node) {
	segment_nodes segments;

	segments.count = xml_node_children(node);
	printf("get_node_children: %d\n", segments.count);
	segments.nodes = calloc(segments.count, sizeof(struct xml_node *));
	
	for (int i = 0; i < segments.count; i++) {
		segments.nodes[i] = xml_node_child(node, i);
	}
	
	return segments;
}

uint8_t *convert(struct xml_string *xml) {
	int len = xml_string_length(xml);
	uint8_t *buffer = calloc(len + 1, sizeof(uint8_t));
	xml_string_copy(xml, buffer, len);
	return buffer;
}

struct xml_string *get_name_string(struct xml_node *node) {
	for (int i = 0; i < xml_node_children(node); i++) {
		struct xml_node *child = xml_node_child(node, i);
		if (xml_name_compare(child, "Name")) {
			return xml_node_content(child);
		}
	}

	return NULL;
}

struct xml_string *get_time_string(struct xml_node *node) {
	struct xml_node *iter;

	for (int i = 0; i < xml_node_children(node); i++) {
		if (xml_name_compare(xml_node_child(node, i), "SplitTimes")) {
			iter = xml_node_child(node, i);
			break;
		}
	}

	for (int i = 0; i < xml_node_children(iter); i++) {
		if (xml_name_compare(xml_node_child(iter, i), "SplitTime")) {
			iter = xml_node_child(iter, i);
			break;
		}
	}

	for (int i = 0; i < xml_node_children(iter); i++) {
		if (xml_name_compare(xml_node_child(iter, i), "RealTime")) {
			iter = xml_node_child(iter, i);
			return xml_node_content(iter);
		}
	}

	return NULL;
}

uint8_t **extract(segment_nodes segments, struct xml_string *(operation)(struct xml_node *)) {
	struct xml_string **xml_strings = calloc(segments.count, sizeof(struct xml_string *));
	
	for (int i = 0; i < segments.count; i++) {
		xml_strings[i] = operation(segments.nodes[i]);
	}

	uint8_t **strings = calloc(segments.count, sizeof(uint8_t *));
	
	for (int i = 0; i < segments.count; i++) {
		strings[i] = convert(xml_strings[i]);
	}

	return strings;
}

struct xml_node *get_segments_node(struct xml_node *root) {
	struct xml_node *child;	
	
	for (int i = 0; i < xml_node_children(root); i++) {
		struct xml_node *child = xml_node_child(root, i);
		if (xml_name_compare(child, "Segments")) {
			return child;
		}
	}

	return NULL;
}

struct xml_string **get_segment_names(struct xml_node *segments) {
	int segments_count;
 	struct xml_string **segment_names;

	segments_count = xml_node_children(segments);
	
}

void print_all_segment_names(struct xml_node *node) {
	struct xml_node *segments = get_segments_node(node);
	if (!segments) {
		error("couldnt get em");	
	}

	enum_node(segments);
}

segment *create_segment(char *name) {
	segment *seg = calloc(1, sizeof(segment));
	seg->name = name;
	return seg;
}

segment_list open_splits_file(const char *path) {
	FILE *xml_file = fopen(path, "r");
	if (!xml_file) {
		error("Could not open file");
	}

	int xml_file_size = get_file_size(xml_file);
	uint8_t *buffer = calloc(sizeof(uint8_t), xml_file_size);
	int no = fread(buffer, sizeof(uint8_t), xml_file_size, xml_file);
	
	struct xml_document *xml = xml_parse_document(buffer, xml_file_size);
	if (!xml) {
		error("Could not parse xml");	
	}

	//printf("splits.c: parsed %s successfully\n", path);

	int children = 0;
	struct xml_node *root = xml_document_root(xml);
	
	struct xml_node *segments_node = get_segments_node(root);
	segment_nodes segments = get_node_children(segments_node);
	uint8_t **segment_names = extract(segments, get_name_string);
	uint8_t **segment_times = extract(segments, get_time_string);

	printf("open_splits_file: %d\n", segments.count);

	for (int i = 0; i < segments.count; i++) {
		printf("%s\n", segment_names[i]);
	}

	segment_list seglist = {0};
	printf("open_splits_file: %d\n", segments.count);

	//printf("%ld\n", segments.count * sizeof(segment));
	//long long what = segments.count * sizeof(segment);
	//printf("what: %lld\n", what);
    //segment *segs = malloc(1008);
	segment *segs = malloc(segments.count * sizeof(*segs));
	//printf("?\n");

	for (int i = 0; i < segments.count; i++) {
		segs[i].name = segment_names[i];
		if (segment_times[i] != NULL) {
			segs[i].realtime = parse_time(segment_times[i]);
			printf("%s\n", segment_times[i]);
		}
	}
	
	printf("splits.c: parsed %s successfully\n", path);

	seglist.segments = segs;
	seglist.count = segments.count;
	return seglist;
}

char *save_fmt(segment_list *sl) {
#define buffer_size 8192
	static char buffer[buffer_size];
	char *bfp;
	bfp = &buffer[0];
	memset(bfp, 0, buffer_size);

	char unparse_buffer[64];
	char *unp;
	
	for (int i = 0; i < sl->count; i++) {
		unp = time_unparse(unparse_buffer, 64, &sl->segments[i].realtime);
		sprintf(bfp, "%s=%s%%", sl->segments[i].name, unp);
		bfp += strlen(bfp);
	}

	printf("%s\n", buffer);
	return buffer;
#undef buffer_size
}
/*void render_splits(segment_list *segments) {
    char buffer[100];
    
    for (int i = 0; i < segments->count; i++) {
        DrawTextEx(font, segments->segments[i].name, (Vector2){10, 30 * i}, (float)font.baseSize/16, 2, WHITE);
        //DrawTextEx(font, time_unparse(buffer, 100, &segments->segments[i].realtime), (Vector2){200, 30 * i}, (float)font.baseSize/16, 2, BLACK);
    }
}*/

void debug_print_list(segment_list *segments) {
	for (int i = 0; i < segments->count; i++) {
		printf("fucker %d\n", i);
		printf("%s\n", segments->segments[i].name);
	}
}

//probably need a thing to free all the segments