#include "utilities/AutoFreePool.h"

#include <stdlib.h>

struct AutoFreePool_callback {
	void (* callback)(void * context);
	void * context;
};

static unsigned int numberOfAddresses;
static unsigned int addressListSize;
static void ** addresses = NULL;

static unsigned int numberOfCallbacks;
static unsigned int callbackListSize;
static struct AutoFreePool_callback * callbacks = NULL;

void * AutoFreePool_add(void * address) {
	if (addresses == NULL) {
		numberOfAddresses = 0;
		addressListSize = 1;
		addresses = malloc(sizeof(void *) * addressListSize);
		
	} else if (numberOfAddresses >= addressListSize) {
		addressListSize *= 2;
		addresses = realloc(addresses, sizeof(void *) * addressListSize);
	}
	
	addresses[numberOfAddresses++] = address;
	
	return address;
}

void AutoFreePool_addCallback(void (* callback)(void * context), void * context) {
	if (callbacks == NULL) {
		numberOfCallbacks = 0;
		callbackListSize = 1;
		callbacks = malloc(sizeof(struct AutoFreePool_callback) * callbackListSize);
		
	} else if (numberOfCallbacks >= callbackListSize) {
		callbackListSize *= 2;
		callbacks = realloc(callbacks, sizeof(struct AutoFreePool_callback) * callbackListSize);
	}
	
	callbacks[numberOfCallbacks].callback = callback;
	callbacks[numberOfCallbacks].context = context;
	numberOfCallbacks++;
}

void AutoFreePool_empty() {
	if (addresses != NULL) {
		unsigned int addressIndex;
		
		for (addressIndex = 0; addressIndex < numberOfAddresses; addressIndex++) {
			free(addresses[addressIndex]);
		}
		numberOfAddresses = 0;
	}
	
	if (callbacks != NULL) {
		unsigned int callbackIndex;
		
		for (callbackIndex = 0; callbackIndex < numberOfCallbacks; callbackIndex++) {
			callbacks[callbackIndex].callback(callbacks[callbackIndex].context);
		}
		numberOfCallbacks = 0;
	}
}