//a Dynamic int array
//an int array that can be created at any time. it also grows automaticly
//by: gannon

//how much the auto growth expands the array
#define DA_autoBufferGrowth 10
//how many arrays it can handle at once
#define DA_numberOfArrays 5

struct DA_arrayData{
	int base;  
	int size;
	int length;
}

DA_arrayData DA_arrays[DA_numberOfArrays];

int DA_firstRun;

int DA_makeArray(int size){//pass in the size of the int array you want

	if(DA_firstRun == 0){
	 	DA_initialize();
		DA_firstRun = 1;
	}
	
	int arrayHandle =  DA_getAvalibleArray();
	
	if(arrayHandle == 0-1)
		return 0-1;//no more arrays can be made
		
	DA_arrays[arrayHandle].base = malloc(size * 4);
	DA_arrays[arrayHandle].size = size;
	DA_arrays[arrayHandle].length = size;

	return arrayHandle;
	
}

//fills array arrayHandle with filler
void DA_fillArray(int arrayHandle, int filler){

	int tempBase = DA_arrays[arrayHandle].base;
	int templength = DA_arrays[arrayHandle].length;
	
	int i;
	for(i = 0; i < templength; i++){
		dma.squad[tempBase + (i*4)] = filler;
	}
	
}

//geting does not activate the auto grow only set does
int DA_getIndex(int arrayHandle, int index){
	
	//log("index"+str(index));
	
	if(index < 0){
		return 0;
	}
	
	if(index >= DA_arrays[arrayHandle].length){
	
		return 0;
	}
	return dma.squad[DA_arrays[arrayHandle].base + (index * 4)];
}

//sets the index with number
//autogrow if needed
//does nothing if index is negitive
void DA_setIndex(int arrayHandle, int index, int number){
	
	if(index < 0) return;
		
	if(index >= DA_arrays[arrayHandle].size){
		DA_resizeArray(arrayHandle, index + DA_autoBufferGrowth);

	}
	if(index > DA_arrays[arrayHandle].length){
		DA_arrays[arrayHandle].length = index + 1;
	}

	dma.squad[DA_arrays[arrayHandle].base + (index * 4)] = number;
	
}

int DA_length(int arrayHandle){

	return DA_arrays[arrayHandle].length;

}

//resizes the array can loose data if newsize is smaller than oldsize
void DA_resizeArray(int arrayHandle, int newsize){


	int tempArray = malloc(newsize * 4);

	int copySize = DA_arrays[arrayHandle].length * 4;
	if(newsize < DA_arrays[arrayHandle].length){
		copySize = newsize * 4;
		DA_arrays[arrayHandle].length = newsize;
	}
	MemCopy(DA_arrays[arrayHandle].base, tempArray, copySize);

	MemFree(DA_arrays[arrayHandle].base);

	DA_arrays[arrayHandle].base = tempArray;
	DA_arrays[arrayHandle].size = newsize;

}

void DA_CopyDAarrays(int arrayFrom, int arrayTo, int fromIndex, int copylen){

	int fromArray = DA_arrays[arrayFrom].base;
	int toArray = DA_arrays[arrayTo].base;
	
	int copyLength = 4 * (min(fromIndex+copylen,DA_arrays[arrayTo].size) - fromIndex);
	
	MemCopy(fromArray,toArray +(4 * fromIndex),copyLength);

}

void DA_freeArray(int arrayHandle){
	MemFree(DA_arrays[arrayHandle].base);
	DA_arrays[arrayHandle].base = 0-1;
}
	
//internal helper functions
void DA_initialize(){
	
	int i;
	for(i = 0; i < DA_numberOfArrays; i++){
		DA_arrays[i].base = 0-1;//a -1 base meens its free
	}
}

int DA_getAvalibleArray(){

	int i;
	for(i = 0; i < DA_numberOfArrays; i++){
		if(DA_arrays[i].base == 0-1){
			return i;
		}
	}
	log("no arrays found");
	return 0-1;//no free arrays can be found
}


int min(int x, int y){
	if(x > y)
		return y;
	return x;
}