/**
 * $Id$
 * 
 * Test data loader.
 *
 * Copyright (c) 2006 Nathan Keynes.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "testdata.h"

#define DEFAULT_SIZE 1024

/* get the next 32-byte aligned address that is no less than x */
#define ALIGN_32(x)  ((char *)((((unsigned int)(x))+0x1F)&0xFFFFFFE0))

void free_test_dataset( test_data_t tests ) 
{
    test_data_t next;

    do {
	next = tests->next;
	free(tests);
	tests = next;
    } while( next != NULL );
}

test_data_block_t get_test_data( test_data_t data, char *name )
{
    int i;
    for( i=0; i<MAX_DATA_BLOCKS; i++ ) {
	if( data->item[i].name != NULL &&
	    strcmp(name, data->item[i].name) == 0 ) {
	    return &data->item[i];
	}
    }
    return NULL;
}

void dump_test_dataset( FILE *f, test_data_t dataset )
{
    test_data_t test = dataset;
    int i;
    while( test != NULL ) {
	fprintf( f, "Test: %s\n", test->test_name );
	for( i=0; i<MAX_DATA_BLOCKS; i++ ) {
	    if( test->item[i].name != NULL ) {
		fprintf( f, "Block: %s, %d bytes\n", test->item[i].name, test->item[i].length );
		fwrite_dump( f, test->item[i].data, test->item[i].length );
	    }
	}
	test = test->next;
    }
}

int test_block_compare( test_data_block_t block, char *result, int result_length )
{
    if( block->length != result_length )
	return -1;
    return memcmp( block->data, result, block->length );
}
    

/**
 * Load a batch of test data from the given IO stream.
 */
test_data_t load_test_dataset( FILE *f )
{
    test_data_t head = NULL;
    test_data_t current = NULL;
    test_data_t last = NULL;
    int current_size = 0;
    int current_block = -1;
    char *current_end = NULL;
    char *dataptr = NULL;

    char buf[512];
    char *line;
    while( fgets(buf, sizeof(buf), f ) != NULL ) {
	line = buf;
	while( isspace(*line) ) /* Trim leading whitespace */
	    line++;
	if( line[0] == '[' ) { /* New test */
	    char *test_name = line+1;
	    char *end = strchr(test_name, ']');
	    if( end != NULL )
		*end = '\0';
	    current_size = DEFAULT_SIZE;
	    test_data_t test = malloc(current_size);
	    if( test == NULL ) {
		fprintf( stderr, "Memory alloc failed: %d\n", current_size );
		return NULL;
	    }
	    memset( test, 0, current_size );
	    
	    dataptr = (char *)(test+1);
	    test->next = NULL;
	    if( head == NULL )
		head = test;
	    if( current != NULL )
		current->next = test;
	    last = current;
	    current = test;
	    current_end = ((char *)test) + current_size;
	    current_block = -1;
	    strcpy( dataptr, test_name );
	    test->test_name = dataptr;
	    dataptr = ALIGN_32(dataptr + strlen(test_name)+1);
	} else if( *line == '#' ) { /* Comment */
	} else {
	    char *equals = strrchr( line, '=' );
	    if( equals != NULL ) {
		char *block_name = line;
		int len;
		char *p = equals;
		*p-- = '\0';
		while( isspace(*p) )
		    *p-- = '\0';
		len = strlen(line)+1;
		if( dataptr + len > current_end ) {
		    current_end += current_size;
		    current_size *= 2;
		    current = realloc(current, current_size );
		    if( current == NULL ) {
			fprintf( stderr, "Memory alloc failed: %d\n", current_size );
			return NULL;
		    }
		    if( last != NULL )
			last->next = current;
		}
		current_block++;
		strcpy( dataptr, block_name );
		current->item[current_block].name = dataptr;
		dataptr = ALIGN_32(dataptr+len);
		current->item[current_block].data = dataptr;
		current->item[current_block].length = 0;

		line = equals+1;
		while( isspace(*line) )
		    line++;
	    } 

	    /* Data */
	    if( current == NULL || current_block == -1 )
		continue;
	    char *p = strtok(line, "\t\r\n ");
	    while( p != NULL ) {
		if( dataptr + 8 > current_end ) {
		    int old_size = current_size;
		    current_end += current_size;
		    current_size *= 2;
		    current = realloc(current, current_size );
		    if( current == NULL ) {
			fprintf( stderr, "Memory alloc failed: %d\n", current_size );
			return NULL;
		    }
		    memset( current + old_size, 0, old_size );
		    if( last != NULL )
			last->next = current;
		}
		int len = strlen(p);
		int datalen = 0;
		char *dot = strchr(p, '.');
		if( dot != NULL ) { /* FP */
		    if( p[len-1] == 'L' ) { /* Ending in L */
			p[len-1] = '\0';
			double d = strtod(p, NULL);
			*((double *)dataptr) = d;
			datalen = 8;
		    } else {
			float f = (float)strtod(p,NULL);
			*((float *)dataptr) = f;
			datalen = 4;
		    }
		} else {
		    unsigned long value = strtoul(p, NULL, 16);
		    if( len == 8 ) {
			*((unsigned int *)dataptr) = value;
			datalen = 4;
		    } else if( len == 4 ) {
			*((unsigned short *)dataptr) = value;
			datalen = 2;
		    } else if( len == 2 ) {
			*((unsigned char *)dataptr) = value;
			datalen = 1;
		    }
		}
		dataptr += datalen;
		current->item[current_block].length += datalen;
		p = strtok(NULL, "\t\r\n ");
	    }
	}
    }
    fclose(f);
    return head;
}

int run_tests( test_func_t *test_fns ) {
    int test_count, test_failures = 0;

    for( test_count=0; test_fns[test_count] != NULL; test_count++ ) {
	if( test_fns[test_count]() != 0 ) {
	    fprintf( stderr, "Test %d failed\n", test_count+1 );
	    test_failures++;
	}
    }

    /* report */
    fprintf( stderr, "%d/%d tests passed!\n", test_count - test_failures, test_count );
    return test_failures;
}