#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include "msg.h"
#include <string.h>
#include <assert.h>
#include <fcntl.h>
#include <pputask.h>

#include "spu/spuverify.h"
#include "verify.h"


#define DATASET		0x1

static int num_int = 0;
static int num_float = 0;
static int item_size = 0;
static int i_upper = 0;
static int j_upper = 0;
static char* databuf = NULL;
static int memsize = 0;
static int socketfd = 0;
static int process_count = 0;
static int debug_level = 0;

static int
fcmp(float a, float b)
{
    float tmp =  a - b;

    if (tmp > 1.0e-4){
	return 1;
    }else if (tmp < -1.0e-4){
	return -1;
    }
    
    return 0;
    
}


static int
icmp(int a, int b)
{
    return a ==b ? 0:1;
    
}



int 
vf_set_element(int n_int, int n_float)
{
    num_int = n_int;
    num_float = n_float;
    item_size = n_int * sizeof(int) + n_float*sizeof(float);
    item_size += sizeof(vf_header_t);
}


static int
dump_item(char* ptr)
{
    int i;
    int* int_p = (int*)ptr;
    float* float_p = (float*) (((char*)ptr)+sizeof(int)*num_int);

    printf("integers:");
    for (i =0; i< num_int;i++){
	printf("%d\t",  (*int_p));
	int_p++;
    }
    printf("\nfloats:");
    for (i = 0; i < num_float; i++){
	printf("%f\t", (*float_p));
	float_p++;
    }
    printf("\n");
}
int 
vf_set_uppers(int i, int j)
{
    
    i_upper = i;
    j_upper = j;
    
    memsize = i_upper*j_upper*item_size;
    if (databuf){
	free(databuf);
	databuf =NULL;
    }
    databuf = (char*)memalign(128, memsize);
    if (databuf == NULL){
	printf("malloc failed for size(%d)\n", memsize);
	return -1;
    }
    
    memset(databuf, 0, memsize);
    return 0;
}

char* 
vf_get_data_ptr(void)
{
    return databuf;
}

static void
dump_all_item(void)
{
    int i, j;

    printf("dumping all items:\n");
    for (i =0; i < i_upper; i++){
	for (j =0; j < j_upper; j++){
	    vf_header_t *head;
	    head = (vf_header_t*)(databuf+(i*j_upper+j)*item_size);
	    printf("(%d %d) item: ", i, j);
	    if (!head->flag &DATASET){
		printf("not set\n");
		continue;
	    }
	    printf("\n");
	    dump_item(head->data);
	}
    }
    
    
}
int
vf_reset_data(void)
{
    if(databuf ==NULL){
	printf("ERROR: databuf is null\n");
	return -1;
    }
    
    memset(databuf, 0, memsize);
    
    return 0;
}

int
vf_set_item(int i, int j, char* ptr, int size)
{
    vf_header_t* head = (vf_header_t*)(databuf + (i*j_upper+j)*item_size);
    
    memcpy(head->data, ptr, size);
    head->flag |= DATASET;
    
    return 0;
}

static void
processdata(vf_msg_head_t* head, char* ptr, int size)
{
  
    if (debug_level >=3){
	printf("processing data item(%d,%d) (i_upper,j_upper)=(%d %d)\n", head->i, head->j,i_upper, j_upper);
    }
    if (size != item_size - sizeof(vf_header_t)){
	printf("item_size=%d, size=%d\n", item_size,size);
	assert(size == item_size - sizeof(vf_header_t) );
    }

    //printf("setting data(%d %d)\n",head->i, head->j);
    //dump_item(ptr);
    //printf("dumping all before setting (%d %d) \n", head->i, head->j);
    //dump_all_item();
    vf_set_item(head->i, head->j, ptr, size);

    process_count++;
}

static int
last_item_set(void)
{
    vf_header_t* head = (vf_header_t*)(databuf + ((i_upper-1)*j_upper+j_upper-1)*item_size);

   return (head->flag & DATASET);

}   


int
vf_recv_blocking(int i, int j)
{    
    vf_header_t* head = (vf_header_t*)(databuf + (i*j_upper+j)*item_size);

    do{
	vf_server_recv(0);
    }while( !(head->flag & DATASET));
    
    return 0;
}

int
vf_recv_all_data(void)
{    
    while( !last_item_set()){
	vf_server_recv(0);
    }
    
    return 0;
}

int 
vf_verify_item(int i, int j, char* ptr)
{
    int k;
    vf_header_t* head = (vf_header_t*)(databuf + (i*j_upper+j)*item_size);
    
    int* indisk_i =(int*) (head->data);
    int* input_i = (int*) ptr;
    float* indisk_f = (float*) ( head->data + num_int*sizeof(int));
    float* input_f = (float*) ( ptr + num_int*sizeof(int));

    
    if ( !(head->flag & DATASET)){
	vf_recv_blocking(i, j);
    }
    
    //dump_all_item();
    for (k = 0;k < num_int;k++){
	if (*(indisk_i+k) != * (input_i+k)){
	    printf("Error: integer data match error\n");
	    printf("i=%d, j=%d, k=%d\n", i, j, k);
	    printf("indisk=%d, input=%d\n",
		   *(indisk_i+k), *(input_i+k));
	    exit(1);
	}
    }

    for (k = 0;k < num_float;k++){
	if ( fcmp(*(indisk_f+k), *(input_f+k)) != 0)  {
	    printf("Error: float data match error\n");
	    return -1;
	}
    }
    
    return 0;
}


int 
vf_send_item(int i, int j, char* ptr, int size)
{
    return vf_client_send(i, j, ptr, size);
    
}

int 
vf_init_client()
{
	int rc;
	printf("vf client initializing ...\n");
	rc = vf_client_init();
	if (!rc){
		printf("vf client initialized succefully\n");
	}
	return rc;
}
int
vf_init_server( int i_u, int j_u, int n_int, int n_float)
{

    if(debug_level){
	printf("\nvf server initializing task parameters ...\n");
    }
    
	vf_set_element(n_int, n_float);
	vf_set_uppers(i_u, j_u);
	
    if (debug_level >=2){
        printf("i_upper =%d, j_upper=%d, n_int=%d, n_float=%d\n",
                i_u, j_u, n_int, n_float);
        printf("data_in_mem=%p, debug_level=%d\n", vf_get_data_ptr(), debug_level);
    }

    	volatile spuvf_init_task_t task __attribute__ ((aligned (128)));
	vf_server_init();
	set_processdata_func(processdata);
	
	task.common.cmd = VFSPU_INIT_TASK;
	task.common.size = sizeof(task);
	task.i_upper = i_u;
	task.j_upper = j_u;
	task.num_int = n_int;
	task.num_float = n_float;
	task.data_in_mem = (unsigned long)vf_get_data_ptr();
	task.debug_level = debug_level;
	if (!task.data_in_mem){
	    printf("NULL mem ptr\n");
	    exit(1);
	}
	ppu_run_task((task_t*)&task);
	
    if (debug_level){
	printf("vf server initialized successfully\n");
    }
    
    return 0;
}


int
vf_sync(int flag)
{
    if (flag == VF_SERVER){
	process_count = 0;
	vf_server_sync();
    }else if (flag == VF_CLIENT){
	vf_client_sync();
    }else{
	printf("Invalid flag\n");
	return -1;
    }
    
    return 0;
}


int
vf_set_debug_level(int level)
{
    debug_level = level;
}