/**********************************************************************
 * netfile.c
 *
 * (C) 2000 J. Ahrensfeld
 *
 **********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "nntypes.h"
#include "nnet.h"
#include "nnfile.h"

/**********************************************************************/
#define	VERSION				"0.1"
#define MAX_TOKENS			15
#define MAX_NEURON_TYPES 	6

/**********************************************************************/
char *pszNNtypeList[] =
{
	"MLP", "RECURRENT", 0
};

char *pszTokenList[]=
{
	"NINPUTS","NOUTPUTS","NHIDDENLAYERS","NHIDDENNEURONS","HIDDENTYPE","OUTPUTTYPE",
	"TRAINING","LEARNINGRATE","MOMENTUM","ERRORTHRESHOLD","MAXEPOCHS","REPORTUPDATE",
	"MAXPATTERNS", "INITWEIGHTRANGE", "NNTYPE", 0
};

char *pszNeuronTypeList[]=
{
	"NULL", "LINEAR", "TANH", "ASIGMOID", "SIGMOID", "SSIGMOID", "FSIGMOID", 0
};

enum Token
{
	NINPUTS, NOUTPUTS, NHIDDENLAYERS, NHIDDENNEURONS, HIDDENTYPE, OUTPUTTYPE,
	TRAINING, LEARNINGRATE, MOMENTUM, ERRORTHRESHOLD, MAXEPOCHS, REPORTUPDATE,
	MAXPATTERNS, INITWEIGHTRANGE, NNTYPE, NOTFOUND
};

/**********************************************************************/
int ReadNextToken(FILE *pFile, char *pToken)
{
	int i, res=EXIT_FAILURE;
	while(!feof(pFile))
	{
		fscanf(pFile,"%s",pToken);
		if((pToken[0]=='#') || (pToken[0] < '0'))
			continue;
		res = EXIT_SUCCESS;
		for (i=0; pToken[i]; i++)
			pToken[i]=toupper(pToken[i]);
		break;
	}
	return res;

}

int ReadValue(FILE *pFile, char* szValue)
{
	int i;
	szValue[0] = 0;
	fscanf(pFile,"%s",szValue);
	for (i=0; szValue[i]; i++)
		szValue[i]=toupper(szValue[i]);
	return 0;
}

int Seek(FILE *pFile, char **pTokenList, int nMaxToken, int *RetToken)
{
	char szToken[256];
	int nToken=0, res = EXIT_FAILURE, status=EXIT_SUCCESS;
	*RetToken = NOTFOUND;

	while ((status == EXIT_SUCCESS) && (*RetToken == NOTFOUND))
	{
		status=ReadNextToken(pFile,szToken);
		for (nToken=0; nToken < nMaxToken; nToken++)
		{
			if(strcmp(szToken,pszTokenList[nToken]))
				continue;
		    //cout << "Token(" << nToken << "): " << szToken << endl;
			*RetToken = nToken;
    		res = EXIT_SUCCESS;
			break;
    	}
	}
	return res;
}

int ReadNetFile(char* szFileName, NETFILE *NetData)
{

	char szValue[80], szToken[256];
	FILE *pFile;
	UINT32 pos;
	NETFILE net;
	UINT32 Token, t, status, i, error;
	UINT32 layer, neurons, neuronType;
	UINT32 size, p;

	/***************************************************************************/
	// INIT
	net.nInputs = 0;
	net.nOutputs = 0;
	net.nHiddenLayers = 0;
	net.nHiddenNeurons = 0;
	net.nTrainingSets = 0;
	net.LearningRate = 0.4;
	net.Momentum = 0.8;
	net.ErrorThreshold = 0;
	net.MaxEpochs = 25000;
	net.reportUpd = 100;
	net.maxPatterns = 1000000;
	net.initwrange = 1.0;
	net.nntype = NNTYPE_MLP;

	/***************************************************************************/
	error = EXIT_FAILURE;

	while(1)
	{
		/***************************************************************************/
		/* Datei oeffnen */
		/***************************************************************************/
		printf("Lese Datei %s\n",szFileName);
		pFile = fopen(szFileName,"r");
		if (pFile==NULL)

		{
			printf("Die Datei %s konnte nicht geöffnet werden.\n",szFileName);
			break;
		}

		/***************************************************************************/
		/* Erwarte "net"-Identifier */
		/***************************************************************************/
		ReadNextToken(pFile, szToken);
		pos = ftell(pFile);

		if (!strcmp(szToken,"NET"))
			printf("%s\n",szToken);
		else
		{
			printf("ERROR: Missing NET-identifier\n");
			break;
		}


		/***************************************************************************/
		/* Inputs, Outputs, Layer */
		/***************************************************************************/
		pos=fseek(pFile, 0, SEEK_SET);
		status = 0;
		Token = NOTFOUND;

		while ((net.nInputs*net.nOutputs*net.nHiddenLayers)==0 && !status)
		{
			status=Seek(pFile,pszTokenList, MAX_TOKENS, &Token);
			switch (Token)
			{
				case NNTYPE:
					net.nntype = NNTYPE_MLP;
					ReadValue(pFile, szValue);
					i=0;
					while(pszNNtypeList[i])
					{
						if(!strcmp(szValue, pszNNtypeList[i]))
						{
							net.nntype = i;
							break;
						}

						i++;
					}
					printf("Neural Net type is %s\n",pszNNtypeList[net.nntype]);
					break;

				case NINPUTS:
		  		ReadValue(pFile, szValue);
	            net.nInputs = atoi(szValue);
                printf("nInputs = %d\n",net.nInputs);
                break;

				case NOUTPUTS:
		  		ReadValue(pFile, szValue);
                net.nOutputs = atoi(szValue);
  				printf("nOutputs = %d\n",net.nOutputs);
				break;

				case NHIDDENLAYERS:
		  		ReadValue(pFile, szValue);
                net.nHiddenLayers = atoi(szValue);
                printf("nHiddenLayers = %d\n",net.nHiddenLayers);
                break;

                default:
                break;
			}
		}
		if(status == EXIT_FAILURE)
		{
			printf("Invalid file Inputs, Outputs, Layer!\n");
			break;
		}

		/***************************************************************************/
		/* Layer Organization */
		/***************************************************************************/
		pos=fseek(pFile, 0, SEEK_SET);
        t = 0;
        status = 0;
		Token = NOTFOUND;

		while (t < net.nHiddenLayers && !status )
		{
		 	status = Seek(pFile,pszTokenList, MAX_TOKENS, &Token);
			if ((Token != NHIDDENNEURONS) && !feof(pFile))
				continue;
			{
				ReadValue(pFile, szValue);
				layer = atoi(szValue);
				ReadValue(pFile, szValue);
				neurons = atoi(szValue);
				printf("HiddenLayer[%d]: %d Neurons\n",layer,neurons);
				net.LInfo[layer].nNeurons = neurons;
				net.nHiddenNeurons += neurons;
				t++;
			}
		}
		printf("Total number of Hidden Neurons = %d\n",net.nHiddenNeurons);

		if(status == EXIT_FAILURE)
		{
			printf("Invalid Layer Organization!\n");
			break;
		}

		/***************************************************************************/
		/* NeuronType */
		/***************************************************************************/
		pos=fseek(pFile, 0, SEEK_SET);

		for (layer=0; layer <net.nHiddenLayers; layer++)
			net.LInfo[layer].NeuronType = Tanh;

		while (!feof(pFile))
		{
			status=0;
			Token = NOTFOUND;

		 	status=Seek(pFile,pszTokenList, MAX_TOKENS, &Token);

			switch (Token)
			{
				case HIDDENTYPE:
				ReadValue(pFile, szValue);
				layer = atoi(szValue);
				ReadValue(pFile, szValue);
				for (neuronType=0; neuronType < MAX_NEURON_TYPES; neuronType++)
				{
					if(!strcmp(szValue,pszNeuronTypeList[neuronType]))
						break;
				}
				if (neuronType==MAX_NEURON_TYPES)
					neuronType = Sig;
				printf("HiddenType[%d] = %s (%d)\n",layer,szValue,neuronType);
				net.LInfo[layer].NeuronType = neuronType;
                break;

				case OUTPUTTYPE:
                ReadValue(pFile, szValue);
 				for (net.OutType=0; net.OutType < MAX_NEURON_TYPES; net.OutType++)
				{
					if(!strcmp(szValue,pszNeuronTypeList[net.OutType]))
						break;
				}
				if (net.OutType==MAX_NEURON_TYPES)
					net.OutType = Tanh;

                printf("Output Type = %s (%d)\n",szValue,net.OutType);
                break;
	        }
         }

		net.LInfo[0].NeuronType = 0;
		net.LInfo[0].nNeurons = net.nInputs;
		net.LInfo[net.nHiddenLayers+1].NeuronType = net.OutType;
		net.LInfo[net.nHiddenLayers+1].nNeurons = net.nOutputs;

		/***************************************************************************/
		/* Parameter */
		/***************************************************************************/
		pos=fseek(pFile, 0, SEEK_SET);

		while (!feof(pFile))
		{
			status=0;
			Token = NOTFOUND;

			status=Seek(pFile,pszTokenList, MAX_TOKENS, &Token);

			switch(Token)
			{
				case LEARNINGRATE:
				ReadValue(pFile, szValue);
				net.LearningRate = atof(szValue);
				printf("Learning Rate = %g\n",net.LearningRate);
				break;

			case MOMENTUM:
				ReadValue(pFile, szValue);
				net.Momentum = atof(szValue);
				printf("Momentum = %g\n",net.Momentum);
				break;

			case ERRORTHRESHOLD:
				ReadValue(pFile, szValue);
				net.ErrorThreshold = atof(szValue);
				printf("Error Threshold = %g\n",net.ErrorThreshold);
				break;

			case MAXEPOCHS:
				ReadValue(pFile, szValue);
				net.MaxEpochs = atoi(szValue);
				printf("Max. Epochs = %d\n",net.MaxEpochs);
				break;

			case REPORTUPDATE:
				ReadValue(pFile, szValue);
				net.reportUpd = atoi(szValue);
				printf("Report every %d epoch\n",net.reportUpd);
				break;

			case MAXPATTERNS:
				ReadValue(pFile, szValue);
				net.maxPatterns = atoi(szValue);
				printf("Read max. %d patterns\n",net.maxPatterns);
				break;

			case INITWEIGHTRANGE:
	  			ReadValue(pFile, szValue);
				net.initwrange = (double)atof(szValue);
				printf("Init weight range = +/- %2.2g\n",net.initwrange);
            break;

			default:
				break;

			}
		}

		/***************************************************************************/
		/* Training Data */
		/***************************************************************************/
		pos=fseek(pFile, 0, SEEK_SET);
		status=0;
		Token = NOTFOUND;

		while (Token != TRAINING && !status )
		 	status=Seek(pFile,pszTokenList, MAX_TOKENS, &Token);

		if(status == EXIT_FAILURE)
		{
			printf("No Training Data found.\n");
			break;
		}
		status = 0;

		/* Count number of Patterns */
		while (!status)
		{
			for (i=0; i < net.nInputs; i++)
				status=ReadValue(pFile, szValue);

			if (szValue[0] < ' ') break;

			for (i=0; i < net.nOutputs; i++)
				status=ReadValue(pFile, szValue);

			if (szValue[0] < ' ') break;

			net.nTrainingSets++;
		}

		if(net.nTrainingSets == 0)
		{
			printf("Missing Training Data!\n");
			break;
		}

		if(net.maxPatterns < net.nTrainingSets)
			net.nTrainingSets = net.maxPatterns;

		/* Alloc mem */
		size = net.nInputs*net.nTrainingSets;
		net.pInput = (FLOAT64*)malloc(size*sizeof(FLOAT64));

		size = net.nOutputs*net.nTrainingSets;
		net.pTarget = (FLOAT64*)malloc(size*sizeof(FLOAT64));

		/* Read training data */
		pos=fseek(pFile, 0, SEEK_SET);
		status=0;
		Token = NOTFOUND;
		while (Token != TRAINING && !status )
		 	status=Seek(pFile,pszTokenList, MAX_TOKENS, &Token);

		for (p=0; p < net.nTrainingSets; p++)
		{
			for (i=0; i < net.nInputs; i++)
			{
				status=ReadValue(pFile, szValue);
				net.pInput[i+p*net.nInputs]= atof(szValue);
			}

			if (szValue[0] < ' ') break;
			for (i=0; i < net.nOutputs; i++)
			{
				status=ReadValue(pFile, szValue);
				net.pTarget[i+p*net.nOutputs]= atof(szValue);
			}
  			if (szValue[0] < ' ') break;
		}
		error = EXIT_SUCCESS;
		break;
	}
	printf("Number of Training Sets = %d\n",net.nTrainingSets);
	/******************************************************************************/
	fclose(pFile);
	*NetData = net;
	return error;
}
/******************************************************************************/