#include "collector.h"

#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include <fstream>

#include "memory_pool.h"

void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size);
void gc_assign_reference(void** ref, gc_object_header* ptr);

gcpointer_t** gc_find_previous_ref(gcpointer_t* target)
{
	if(!(target)) return NULL;

	bool managed = gc_is_managed(target);
	gc_object_header* obj = gc_get_object_ptr((void*)target->ptr);

	check(gc_is_valide(obj));

	gcpointer_t** prev_next_ptr = managed ? &obj->type_chain : &obj->root_chain;
	while((*prev_next_ptr) && (*prev_next_ptr) != target)
	{
		prev_next_ptr = &(*prev_next_ptr)->next;
	}

	return prev_next_ptr;
}

void* gc_allocate(size_t target_size)
{
	size_t size = gc_compute_size(target_size + sizeof(gc_object_header));

	check(size < POOL_SIZE_BYTES);

	void* block = NULL;
	gc_state* gc = gc_get_state();

	if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);

	gc_collect(gc);

	if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);

	gc_allocate_pool(gc);

	if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);

	ofstream_stderr() | "ERROR: allocation in new pool failed" | endl;
	abort();

	return NULL;
}

void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size)
{
	void* data = (void*)(((intptr_t)block) + sizeof(gc_object_header));
	void* header = block;

	check(((intptr_t)data) > ((intptr_t)block));
	check(((intptr_t)data) >= ((intptr_t)header));
	check(is_aligned(data));
	check(((intptr_t)data) + target_size <= ((intptr_t)block) + actual_size);

	gc_object_header* obj = gc_object_header_placement_ctor(header, actual_size);

	// (void)obj; //remove unsused warning since this is for debug
	check(obj == get_object_ptr(data));

	gc_register_allocation(gc_get_state(), actual_size);

	return data;
}

void gc_process_reference(void** ref, worklist_t* worklist)
{
	check(!gc_is_in_heap(gc_get_state(), ref));

	gc_object_header* ptr = gc_get_object_ptr(*ref);
	if(ptr)
	{
		if(!ptr->is_forwarded)
		{
			gc_copy_object(ptr);

			gc_scan_object(ptr->forward, worklist);

			gc_assign_reference(ref, ptr->forward);
		}
		else
		{
			//duplication to help debug
			gc_assign_reference(ref, ptr->forward);
		}
	}
}

void gc_assign_reference(void** ref, gc_object_header* ptr)
{
	void* address = (void*)(((intptr_t)ptr) + sizeof(gc_object_header));

	gc_write_aligned_ptr(ref, address);
}

gc_object_header* gc_copy_object(gc_object_header* ptr)
{
	check(!ptr->forward);
	check(!ptr->is_forwarded);
	check(gc_is_from_space(gc_pool_of(ptr)));

	gc_memory_pool* pool = gc_pool_of(ptr)->mirror;

	void* new_block = gc_pool_allocate(pool, ptr->size, true);

	memcpy(new_block, ptr, ptr->size);

	gc_object_header* fwd_ptr = gc_object_header_placement_copy_ctor(new_block, ptr);

	ptr->forward = fwd_ptr;
	ptr->is_forwarded = true;

	return fwd_ptr;
}

void gc_scan_object(gc_object_header* object, worklist_t* worklist)
{
	gcpointer_t* field = object->type_chain;
	while(field)
	{
		check(((intptr_t)field) > ((intptr_t)object));
		check(((intptr_t)field) < ((intptr_t)((intptr_t)object) + object->size));

		check(gc_is_in_to_space(gc_get_state(), &type->ptr));

		push_back(worklist, &field->ptr);

		field = field->next;
	}
}