#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "ann.h"


int read_data(char* fname, double ***input, double ***output,int* num_records);

int read_data(char* fname, double ***input, double ***output, int* num_records){
	int class, count,i;
	double x1,x2;
	int nbytes = 99;
	char *trash = (char*)(malloc(100*sizeof(char)));
	FILE* fp = fopen(fname,"r");
	count = 0;
	
	while(getline(&trash,&nbytes,fp) > 0)
		count++;
	(*input) = (double**)(malloc(count*sizeof(double*)));
	(*output) = (double**)(malloc(count*sizeof(double*)));
	for(i=0;i<count;i++){
		(*input)[i] = (double*)(malloc(3*sizeof(double)));
		(*output)[i] = (double*)(malloc(1*sizeof(double)));
	}
	*num_records = count;
	fclose(fp);
	fp = fopen(fname,"r");
	i=0;
	while(fscanf(fp, "%d%lf%lf",&class,&x1,&x2) == 3){
		(*input)[i][0] = 1.0;
		(*input)[i][1] = x1;
		(*input)[i][2] = x2;
		(*output)[i][0] = (double)class;
		i++;
	}
	fclose(fp);
	free(trash);
	return i;
}

void test_sigmoid_functions(){
	printf("Testing Sigmoid functions\n");
	printf("Sigmoid(0) = %f\n",sigmoid(0));
	printf("Sigmoid(0.5) = %f\n",sigmoid(0.5));
	printf("Sigmoid(-0.5) = %f\n",sigmoid(-0.5));
	printf("Sigmoid(1.0) = %f\n",sigmoid(1.0));
	printf("Sigmoid(-1.0) = %f\n",sigmoid(-1.0));
	printf("Sigmoid(100) = %f\n",sigmoid(100));
	printf("Sigmoid(-100) = %f\n",sigmoid(-100));
}

void test_ANN_init_free(){
	int i;
	struct perceptron p;
	struct two_layer_NN tl;
	printf("Testing ANN initialization/free\n");
	for(i=0;i<10;i++){
		printf("Initializing perceptron [%d,%d]:...",i*10,i*10);
		init_perceptron(i*10,i*10,&p);
		printf("done! Freeing...");
		free_perceptron(&p);
		printf("done!\n");
	}
	for(i=0;i<10;i++){
		printf("Initializing two-layer feed-foward ANN [%d,%d,%d]:...",i*10,i*10,i*10);
		init_two_layer_NN(i*10,i*10,i*10,&tl);
		printf("done! Freeing...");
		free_two_layer_NN(&tl);
		printf("done!\n");
	}
}

void test_running_ANN(){
	int i;
	struct perceptron p;
	struct two_layer_NN tl;
	double input[3], output[1];
	printf("Testing running ANN\n");
	printf("Testing boolean functions\n");
	//first input is bias, IE always set to 1;
	init_perceptron(3,1,&p);
	//OR (all set to 1)
	p.weights[0][0] = 1.0;
	p.weights[1][0] = 1.0;
	p.weights[2][0] = 1.0;
	for(i=0;i<10;i++){
		input[i] = 0.0;
		output[i] = 0.0;
	}
	printf("OR\n");

	input[0] = 1;
	input[1] = -1;
	input[2] = -1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = -1; input[2] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	
	printf("AND\n");
	p.weights[0][0] = 0.0;
	input[0] = 1;
	input[1] = -1;
	input[2] = -1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = -1; input[2] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");	
	
	free_perceptron(&p);
	
	printf("XOR\n");
	init_two_layer_NN(3,1,3,&tl);
	//XOR:
	tl.input_hidden_weights[0][0] = -100.0;
	tl.input_hidden_weights[1][0] = 200.0;
	tl.input_hidden_weights[2][0] = -200.0;
	
	tl.input_hidden_weights[0][1] = -100.0;
	tl.input_hidden_weights[1][1] = -200.0;
	tl.input_hidden_weights[2][1] = 200.0;
	
	tl.input_hidden_weights[0][2] = 100.0;
	tl.input_hidden_weights[1][2] = 0.0;
	tl.input_hidden_weights[2][2] = 0.0;
	
	tl.hidden_output_weights[0][0] = 200.0;
	tl.hidden_output_weights[1][0] = 200.0;
	tl.hidden_output_weights[2][0] = -100.0;
	input[0] = 1;
	input[1] = 0;
	input[2] = 0;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 0; input[2] = 1;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	free_two_layer_NN(&tl);
}

void test_update_ANN(double** training_inputs, double** training_outputs){
	int i;
	double input[3], output[1];
	struct perceptron p;
	struct two_layer_NN tl;
	
	printf("Testing perceptron update rule on the AND function\n");
	init_perceptron(3,1,&p);
	
	for(i=0;i<100000;i++){
		double bias,one,two,t;
		training_inputs[i][0] = bias = 1.0;
		training_inputs[i][1] = one = (drand48()*2)-1;
		training_inputs[i][2] = two = (drand48()*2)-1;
		training_outputs[i][0] = t = (threshold(one)>0 && threshold(two)>0)?1.0:-1.0;
	}
	train_perceptron(&p,training_inputs,training_outputs,0.1,100000);
	
	input[0] = 1;
	input[1] = -1;
	input[2] = -1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = -1; input[2] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_perceptron(&p,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	free_perceptron(&p);
	//Two layer!
	printf("Testing back-prop training on the XOR function\n");
	init_two_layer_NN(3,1,3,&tl);
	for(i=0;i<100000;i++){
		double bias,one,two,t;
		training_inputs[i][0] = bias = 1.0;
		training_inputs[i][1] = one = drand48();
		training_inputs[i][2] = two = drand48();
		training_outputs[i][0] = t = ((one>0.5 && two <0.5) || (two > 0.5 && one < 0.5))?1.0:0.0;
	}
	train_two_layer_NN(&tl,training_inputs,training_outputs,0.1,100000);
	
	input[0] = 1;
	input[1] = 0;
	input[2] = 0;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 0; input[2] = 1;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	input[1] = 1;
	run_two_layer_NN(&tl,input,output);
	print_arr(input,3); printf(" -> "); print_arr(output,1); printf("\n");
	
	free_two_layer_NN(&tl);
}

int main(int argc, char** argv){
	int i,j,k,l,num_hidden_nodes=10, train_rep=400;
	struct perceptron p;
	struct two_layer_NN tl;
	double output[1], nu=0.1;
	long int seed = (long int)time(NULL);
	/*
	double **training_inputs, **training_outputs;
	training_inputs = (double**)(malloc(100000*sizeof(double*)));
	training_outputs = (double**)(malloc(100000*sizeof(double*)));
	for(i=0;i<100000;i++){
		training_inputs[i] = (double*)(malloc(3*sizeof(double)));
		training_outputs[i] = (double*)(malloc(1*sizeof(double)));
	} 
	test_sigmoid_functions();
	printf("***************************************************************************\n");
	test_ANN_init_free();
	printf("***************************************************************************\n");
	test_running_ANN();
	printf("***************************************************************************\n");
	test_update_ANN(training_inputs,training_outputs);
	*/
	
	for(i=0;i<argc;i++){
		if(strcmp(argv[i],"-hidden") == 0 && i+1<argc)
			num_hidden_nodes=atoi(argv[++i]);
		else if(strcmp(argv[i],"-train")==0 && i+1<argc)
			train_rep = atoi(argv[++i]);
		else if(strcmp(argv[i],"-nu")==0 && i+1<argc)
			nu = atof(argv[++i]);
		else if(strcmp(argv[i],"-seed")==0 && i+1<argc)
			seed = atol(argv[++i]);
	}
	
	double **inp, **outp,bad_sum=0.0, big_sum=0.0;
	int num_rec,bad_count;
	srand48(seed);
	printf("Seed: %ld\n",seed);
	printf("Training the Perceptron on the spiral data set, with leave-one-out ");
	printf("cross-validation.\n");
	printf("Training repititions: %d\n",train_rep);
	printf("Learning rate: %f\n",nu);
	for(i=1;i<11;i++){
		char buf[50];
		init_perceptron(3,1,&p);
		for(j=0;j<train_rep;j++){
			for(k=1;k<11;k++){
				if(i==k) continue;
				sprintf(buf,"spiralfold%d.txt",k);
				num_rec = read_data(buf,&inp,&outp,&num_rec);
				for(l=0;l<num_rec;l++)
					outp[l][0] = threshold(outp[l][0]);
				train_perceptron(&p,inp,outp,nu,num_rec);
				for(l=0;l<num_rec;l++){
					free(inp[l]);
					free(outp[l]);
				}
				free(inp); free(outp);
			}
		}
		sprintf(buf,"spiralfold%d.txt",i);
		num_rec = read_data(buf,&inp,&outp,&num_rec);
		for(l=0;l<num_rec;l++)
			outp[l][0] = threshold(outp[l][0]);
		bad_count=0;
		for(j=0;j<num_rec;j++){
			run_perceptron(&p,inp[j],output);
			if((output[0] > 0 && outp[j][0] < 0)||(output[0]<0 && outp[j][0]>0))
				bad_count++;
		}
		printf("Testing on %s: %d/%d\n",buf,num_rec-bad_count,num_rec);
		bad_sum += bad_count;
		big_sum += num_rec;
		free_perceptron(&p);
		for(l=0;l<num_rec;l++){
			free(inp[l]);
			free(outp[l]);
		}
		free(inp); free(outp);
	}
	printf("Average correct labeling: %f%%\n",(big_sum-bad_sum)/big_sum);
	big_sum = bad_sum = 0.0;
	printf("***************************************************************************\n");
	printf("Training a two-layer ANN on the spiral data set, with leave-one-out ");
	printf("cross-validation.\n");
	printf("Training repititions: %d\n",train_rep);
	printf("Learning rate: %f\n",nu);
	printf("Hidden nodes: %d\n",num_hidden_nodes);
	for(k=1;k<11;k++){
		char buf[50];
		init_two_layer_NN(3,1,num_hidden_nodes,&tl);
		for(i=0;i<train_rep;i++){
			for(j=1;j<11;j++){
				if(j==k) continue;
				sprintf(buf,"spiralfold%d.txt",j);
				num_rec = read_data(buf,&inp,&outp,&num_rec);
				train_two_layer_NN(&tl,inp,outp,nu,num_rec);
				for(l=0;l<num_rec;l++){
					free(inp[l]);
					free(outp[l]);
				}
				free(inp); free(outp);
			}
		}
		
		//Trained, now test
		sprintf(buf,"spiralfold%d.txt",k);
		num_rec = read_data(buf,&inp,&outp,&num_rec);
		bad_count=0;
		for(i=0;i<num_rec;i++){
			run_two_layer_NN(&tl,inp[i],output);
			if( (output[0] > 0.5 && outp[i][0] < 0.5) || (output[0] < 0.5 && outp[i][0] > 0.5))
				bad_count++;
			//printf("%f / %f\n",output[0],outp[i][0]);
		}
		printf("Testing on %s: %d/%d\n",buf,num_rec-bad_count,num_rec);
		bad_sum += bad_count;
		big_sum += num_rec;
		free_two_layer_NN(&tl);
		for(l=0;l<num_rec;l++){
			free(inp[l]);
			free(outp[l]);
		}
		free(inp); free(outp);
	}
	printf("Average correct labeling: %f%%\n",(big_sum-bad_sum)/big_sum);
	
	return 0;
}