/******************************************************************************
 *
 *	Title  : RWlists.c
 *  Version
 *
 *  Description: Read/Write primitive and command lists to/from text files.
 *
 *.
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

/******************************************************************************
 *								Header files 								  *
 ******************************************************************************/

#include <ansi_c.h>
#include "RWlists.h"
#include "primFunctionInit.h"      
#include "errorHandler.h"
#include "primListTableDefinitions.h"


/******************************************************************************
 *							   Static function decl. 						  *
 ******************************************************************************/
 
static int getPrimName(int primId, char primName[]);
static int getCmdName(int cmdId, char cmdName[]);
static int writeListHeader(FILE *file, struct MSG_LIST_HEAD *listHeader,  char listComment[COMMENT_LENGTH], 
									UINT32 allPrimCount, UINT32 replyLength, UINT32 replyCount);
static int writePrimHeader(FILE *file, struct MSG_HEAD *primHeader, char primComment[COMMENT_LENGTH], UINT32 replyLength);
static void terminateString(char *string);    
static int readComment(FILE* file, char comment[COMMENT_LENGTH]);

/******************************************************************************
 *							   Global functions 							  *
 ******************************************************************************/
/*=============================================================================
 *                               readLineFromIndex()
 *============================================================================= 
 *
 *  
 */
int readLineFromIndex(FILE* file, int index, int maxStringLength, char *returnString){  
 
   char *string;
   char *result;
   
   returnString[0]=0;
   
   string = calloc (maxStringLength+index, 1);
   if(string==NULL) return(-2);
   
	result = fgets (string, maxStringLength+index, file);
	if(result==NULL) {
		free(string); 
		return(-1); 
	}
	
	terminateString(string);
	if(strlen(string)>index) strcpy(returnString, &string[index]);
	free(string);
	
	return(0);
}	

/*=============================================================================
 *                               readPrimListFile()
 *=============================================================================
 *
 *
 *
 */
ERROR_ID readPrimListFile(char primListFile[], struct LIST_TABLE *listTable){

	FILE *file;
	ERROR_ID errorId;
	int status;
	char errorMessage[300];
	int index;
	struct PRIM_TABLE *primTable;
	unsigned int slavePrims=0;

	file = fopen (primListFile, "r");
	if(file==NULL){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"- file name:%s, errno=%d(see errno.h).", primListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fopen()", errno, errorMessage);
		return(errorId);
	}
	
	errorId=readListHeader(file, &listTable->inListHeader, listTable->comment, 
							&listTable->allPrimCount, &listTable->replyLength, &listTable->replyCount);

	ERROR_CHECK(errorId, readListHeader());
	if(errorId!=SUCCESS) return(errorId);
	
	if(listTable->allPrimCount>MAXPRIMS_IN_LIST){
		ERROR_CHECK(FATAL_ERROR, listTable->allPrimCount>MAXPRIMS_IN_LIST!);
		return(FATAL_ERROR); 
	}
	
	for(index=0; index<listTable->allPrimCount; index++){
	
		 primTable=&listTable->primTable[index];
		 
		 status=readPrimHeader(file, &primTable->inPrimHeader, primTable->comment, &primTable->replyLength);
		 if(status!=0){
		 	ERROR_CHECK(FILE_ERROR, readPrimHeader());
		 	return(FILE_ERROR);
		 }
		 
		 errorId=(*global.primFunction[getPrimArrayId(primTable->inPrimHeader.id)])(READ_FROM_FILE, primTable, NULL, (UINT32)file, 0);  
		 ERROR_CHECK(errorId, primFunction(READ_FROM_FILE));
	     if(errorId!=SUCCESS) return(errorId); 
	     
	     if(slavePrims>0) slavePrims--;
	     else listTable->masterToTablePrimIndex[primTable->inPrimHeader.index]=index;
	     
	     if(primTable->inPrimHeader.id==SEND_SLAVE_LIST){
	     	slavePrims=primTable->params.sendSlaveList.inSlaveListHeader.numMsgs;
	     	if(slavePrims>listTable->allPrimCount){
				ERROR_CHECK(FATAL_ERROR, slavePrims>listTable->allPrimCount!);
				return(FATAL_ERROR); 
			}
	     }
	
	}
	
	status=fclose(file);
	if(status!=0){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"-file name:%s, errno=%d(see errno.h).", primListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fclose()", errno, errorMessage);
		return(errorId);
	}
	return(SUCCESS);
}
/*=============================================================================
 *                               writePrimListFile()
 *=============================================================================
 *
 *
 *
 */
ERROR_ID writePrimListFile(char primListFile[], struct LIST_TABLE *listTable){

	FILE *file;
	ERROR_ID errorId;
	int status;
	char errorMessage[300];
	int index;
	struct PRIM_TABLE *primTable;
	
	if(listTable->allPrimCount>MAXPRIMS_IN_LIST){
		ERROR_CHECK(FATAL_ERROR, listTable->allPrimCount>MAXPRIMS_IN_LIST!);
		return(FATAL_ERROR); 
	}

	file = fopen (primListFile, "w");
	if(file==NULL){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"- file name:%s, errno=%d(see errno.h).", primListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fopen()", errno, errorMessage);
		return(errorId);
	}
	
	errorId=writeListHeader(file, &listTable->inListHeader, listTable->comment, 
							listTable->allPrimCount, listTable->replyLength, listTable->replyCount);
	ERROR_CHECK(errorId, writeListHeader());
	if(errorId!=SUCCESS) return(errorId);
	
	for(index=0; index<listTable->allPrimCount; index++){
	
		 primTable=&listTable->primTable[index];
		 
		 status=writePrimHeader(file, &primTable->inPrimHeader, primTable->comment, primTable->replyLength);
		 if(status!=0){
		 	ERROR_CHECK(FILE_ERROR, writePrimHeader());
		 	return(FILE_ERROR);
		 }
		 
		 errorId=(*global.primFunction[getPrimArrayId(primTable->inPrimHeader.id)])(WRITE_TO_FILE, primTable, NULL, (UINT32) file, 0);  
		 ERROR_CHECK(errorId, primFunction(WRITE_TO_FILE));
	     if(errorId!=SUCCESS) return(errorId); 
	
	}
	
	status=fclose(file);
	if(status!=0){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"-file name:%s, errno=%d(see errno.h).", primListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fclose()", errno, errorMessage);  
		return(errorId);
	}
	return(SUCCESS);
}

/*=============================================================================
 *                               readCmdListFile()
 *=============================================================================
 *
 *
 *
 */
ERROR_ID readCmdListFile(char cmdListFile[], struct COMMAND_LIST *cmdList){

	FILE *file;
	ERROR_ID errorId;
	int status;
	char errorMessage[300];
	int index, fileIndex;
	struct COMMAND *command;
	char cmdName[300];

	file = fopen (cmdListFile, "r");
	if(file==NULL){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"- file name:%s, errno=%d(see errno.h).", cmdListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fopen()", errno, errorMessage);
		return(errorId);
	}
	
	/* read list header */ 
	status=readComment(file, cmdList->comment);
	if(status!=0){
		ERROR_CHECK(PROGRAM_ERROR, readComment());
		return(-1); 
	}
	
	status=fscanf(file, "commandCount: %d\n", &cmdList->commandCount);
	if(status==-1) {
		ERROR_CHECK(PROGRAM_ERROR, fscanf());
		return(-1); 
	}
	
	if(cmdList->commandCount>MAXCOMMANDS_IN_LIST){
		ERROR_CHECK(FATAL_ERROR, cmdList->commandCount>MAXCOMMANDS_IN_LIST!);
		return(FATAL_ERROR); 
	}
	
	for(index=0; index<cmdList->commandCount; index++){
	
		command=&cmdList->command[index];
		 
		/* read cmd header */
		status=fscanf(file, "===========================================================\n");
		if(status==-1) {
			ERROR_CHECK(PROGRAM_ERROR, fscanf());
			return(-1); 
		}

	
		/* read comment */
		status=readComment(file, command->comment);
		if(status!=0){
			ERROR_CHECK(PROGRAM_ERROR, readComment());
			return(-1); 
		}

		status=fscanf(file, "index: %d,  id: %d, numRepetitions: %d, continueIfError: %d\n",
						&fileIndex, &command->id, &command->numRepetitions, &command->continueIfError); 
		if(status==-1) {
			ERROR_CHECK(PROGRAM_ERROR, fscanf());
			return(-1); 
		}
	
		/* read cmdName */
		status=readLineFromIndex(file, 0, 300, cmdName);
		if(status!=0){
			ERROR_CHECK(PROGRAM_ERROR, readLineFromIndex());
			return(-1); 
		}
		errorId=(*global.commandFunction[command->id])(LOAD_CMD_FROM_FILE, command, 0, file);
		ERROR_CHECK(errorId, commandFunction(LOAD_CMD_FROM_FILE));
	    if(errorId!=SUCCESS) return(errorId); 
	
	}
	
	status=fclose(file);
	if(status!=0){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"-file name:%s, errno=%d(see errno.h).", cmdListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fclose()", errno, errorMessage);
		return(errorId);
	}
	return(SUCCESS);
}
/*=============================================================================
 *                               writeCmdListFile()
 *=============================================================================
 *
 *
 *
 */
ERROR_ID writeCmdListFile(char cmdListFile[], struct COMMAND_LIST *cmdList){

	FILE *file;
	ERROR_ID errorId;
	int status;
	char errorMessage[300];
	int index;
	struct COMMAND *command;
	char cmdName[300]; 
	
	if(cmdList->commandCount>MAXCOMMANDS_IN_LIST){
		ERROR_CHECK(FATAL_ERROR, cmdList->commandCount>MAXCOMMANDS_IN_LIST!);
		return(FATAL_ERROR); 
	}

	file = fopen (cmdListFile, "w");
	if(file==NULL){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"- file name:%s, errno=%d(see errno.h).", cmdListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fopen()", errno, errorMessage);
		return(errorId);
	}
	/* print list header */
	status=fputs(cmdList->comment, file);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, fputs());
		return(-1); 
	}
	
	status=fputs("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n", file);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, fputs());
		return(-1); 
	}

	status=fprintf(file, "commandCount: %d\n", cmdList->commandCount);
	if(status<0) {
		ERROR_CHECK(PROGRAM_ERROR, fprintf());
		return(-1); 
	}

	for(index=0; index<cmdList->commandCount; index++){
	
		command=&cmdList->command[index];
		 
		/* write header */
		 

		status=getCmdName(command->id, cmdName);
		if(status!=0) {
			ERROR_CHECK(PROGRAM_ERROR, getCmdName());
			return(-1); 
		}	
	
		status=fputs("===========================================================\n", file);
		if(status!=0) {
			ERROR_CHECK(PROGRAM_ERROR, fputs());
			return(-1); 
		}
	
		status=fputs(command->comment, file);
		if(status!=0) {
			ERROR_CHECK(PROGRAM_ERROR, fputs());
			return(-1); 
		}
					
		status=fputs("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n", file);
		if(status!=0) {
			ERROR_CHECK(PROGRAM_ERROR, fputs());
			return(-1); 
		}
	
		status=fprintf(file, "index: %d,  id: %d, numRepetitions: %d, continueIfError: %d\n%s\n",
						index, command->id, command->numRepetitions, command->continueIfError, cmdName);
		if(status<0) {
			ERROR_CHECK(PROGRAM_ERROR, fprintf());
			return(-1); 
		}
		 
		errorId=(*global.commandFunction[command->id])(SAVE_CMD_TO_FILE, command, 0, file);
		ERROR_CHECK(errorId, commandFunction(SAVE_CMD_TO_FILE));
	    if(errorId!=SUCCESS) return(errorId); 
	
	}
	
	status=fclose(file);
	if(status!=0){
		errorId=FILE_ERROR;
		sprintf(errorMessage,"-file name:%s, errno=%d(see errno.h).", cmdListFile, errno);
		programError(__FILE__,__LINE__, errorId, "fclose()", errno, errorMessage);  
		return(errorId);
	}
	return(SUCCESS);
}
/*=============================================================================
 *                               readListHeader()
 *=============================================================================
 *
 *
 *
 */

int readListHeader(FILE *file, struct MSG_LIST_HEAD *listHeader,  char listComment[COMMENT_LENGTH], 
									UINT32 *allPrimCount, UINT32 *replyLength, UINT32 *replyCount){


	ERROR_ID errorId;
	int fileIndex;
	int status;

	/* read comment */
	status=readComment(file, listComment);
	if(status!=0){
		ERROR_CHECK(PROGRAM_ERROR, readComment());
		return(-1); 
	}
	
	status=fscanf(file, "length: 0x%X, numMsgs= 0x%X, primListRevision= %d\n",
								&listHeader->length, &listHeader->numMsgs, &listHeader->primListRevision);
	if(status==-1) {
		ERROR_CHECK(PROGRAM_ERROR, fscanf());
		return(-1); 
	}
	
	status=fscanf(file, "allPrimCount: %d, replyLength: 0x%X, replyCount: 0x%X\n",
					allPrimCount, replyLength, replyCount);
	if(status==-1) {
		ERROR_CHECK(PROGRAM_ERROR, fscanf());
		return(-1); 
	}
	
	return(SUCCESS);

}
/*=============================================================================
 *                               readPrimHeader()
 *=============================================================================
 *
 *
 *
 */
int readPrimHeader(FILE *file, struct MSG_HEAD *primHeader,  char primComment[COMMENT_LENGTH], UINT32 *replyLength){

	int fileIndex;
	int status;
	char string[300];

	status=fscanf(file, "===========================================================\n");
	if(status==-1) {
		ERROR_CHECK(PROGRAM_ERROR, fscanf());
		return(-1); 
	}

	
	/* read comment */
	status=readComment(file, primComment);
	if(status!=0){
		ERROR_CHECK(PROGRAM_ERROR, readComment());
		return(-1); 
	}

	status=fscanf(file, "index: %d,  id: 0x%X, primRevision: %d, length: 0x%X, replyLength: 0x%X\n",
					&primHeader->index, &primHeader->id, &primHeader->primRevision, &primHeader->length,
					replyLength);  
	if(status==-1) {
		ERROR_CHECK(PROGRAM_ERROR, fscanf());
		return(-1); 
	}
	
	/* read primName */
	status=readLineFromIndex(file, 0, 300, string);
	if(status!=0){
		ERROR_CHECK(PROGRAM_ERROR, readLineFromIndex());
		return(-1); 
	}
	
	return(0);

}

/******************************************************************************
 *							   Static functions 							  *
 ******************************************************************************/

/*=============================================================================
 *                               writeListHeader()
 *=============================================================================
 *
 *
 *
 */

static int writeListHeader(FILE *file, struct MSG_LIST_HEAD *listHeader,  char listComment[COMMENT_LENGTH], 
									UINT32 allPrimCount, UINT32 replyLength, UINT32 replyCount){

	int status;
	char primName[300];

	status=fputs(listComment, file);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, fputs());
		return(-1); 
	}
	
	status=fputs("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n", file);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, fputs());
		return(-1); 
	}

	status=fprintf(file, "length: 0x%X, numMsgs= 0x%X, primListRevision= %d\n",
						  listHeader->length, listHeader->numMsgs, listHeader->primListRevision);
	if(status<0) {
		ERROR_CHECK(PROGRAM_ERROR, fprintf());
		return(-1); 
	}
	
	status=fprintf(file, "allPrimCount: %d, replyLength: 0x%X, replyCount: 0x%X\n",
					allPrimCount, replyLength, replyCount);
	if(status<0) {
		ERROR_CHECK(PROGRAM_ERROR, fprintf());
		return(-1); 
	}
	
	return(0);

}
/*=============================================================================
 *                               writePrimHeader()
 *=============================================================================
 *
 *
 *
 */

static int writePrimHeader(FILE *file, struct MSG_HEAD *primHeader, char primComment[COMMENT_LENGTH], UINT32 replyLength){

	ERROR_ID errorId;
	int status;
	char primName[300];

	status=getPrimName(primHeader->id, primName);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, getPrimName());
		return(-1); 
	}	
	
	status=fputs("===========================================================\n", file);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, fputs());
		return(-1); 
	}
	
	status=fputs(primComment, file);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, fputs());
		return(-1); 
	}
					
	status=fputs("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n", file);
	if(status!=0) {
		ERROR_CHECK(PROGRAM_ERROR, fputs());
		return(-1); 
	}
	
	status=fprintf(file, "index: %d,  id: 0x%X, primRevision: %d, length: 0x%X, replyLength: 0x%X\n%s\n",
					primHeader->index, primHeader->id, primHeader->primRevision, primHeader->length,
					replyLength, primName);
	if(status<0) {
		ERROR_CHECK(PROGRAM_ERROR, fprintf());
		return(-1); 
	}
	
	return(SUCCESS);

}
/*=============================================================================
 *                               getPrimName()
 *=============================================================================
 *
 *   Returns prim ID as a text string 
 *
 */

#define  GET_PRIM_NAME(primId) case (primId): strcpy(primName, #primId); break;

static int getPrimName(int primId, char primName[]){

	switch(primId){
	
		/* common */
		GET_PRIM_NAME(ECHO);
		GET_PRIM_NAME(SET_MESSAGE_MASK);
		GET_PRIM_NAME(PAUSE_LIST);
		GET_PRIM_NAME(EVENT_TRAP_SETUP);
		GET_PRIM_NAME(SET_MEMORY);
		GET_PRIM_NAME(COPY_MEMORY);
		GET_PRIM_NAME(MEMORY_TEST);
		GET_PRIM_NAME(SET_LED);
		GET_PRIM_NAME(FLASH_LED);
		GET_PRIM_NAME(SEND_DATA);
		GET_PRIM_NAME(MODULE_MASK);
		GET_PRIM_NAME(SET_TRIGGER);
		GET_PRIM_NAME(START_TASK);
		GET_PRIM_NAME(TASK_OPERATION);
		GET_PRIM_NAME(TEST);
		GET_PRIM_NAME(WRITE_BUFFER);
		
		/* slave */
		GET_PRIM_NAME(START_EVENT_TRAPPING);
		GET_PRIM_NAME(STOP_EVENT_TRAPPING);
		GET_PRIM_NAME(HISTOGRAM_SETUP);
		
		/* master */
		GET_PRIM_NAME(RW_SLAVE_MEMORY);
		GET_PRIM_NAME(TRANS_SERIAL_DATA);
		GET_PRIM_NAME(START_SLAVE_EXECUTING);
		GET_PRIM_NAME(CONFIG_SLAVE);
		GET_PRIM_NAME(RW_REG_FIELD);
		GET_PRIM_NAME(POLL_REG_FIELD);
		GET_PRIM_NAME(RW_FIFO);
		GET_PRIM_NAME(SEND_SLAVE_LIST);
		GET_PRIM_NAME(START_SLAVE_LIST);
		GET_PRIM_NAME(SLAVE_LIST_OP);
		GET_PRIM_NAME(BUILD_STREAM);
		GET_PRIM_NAME(SEND_STREAM);
		GET_PRIM_NAME(RW_MODULE_DATA);
		GET_PRIM_NAME(SEND_CONFIG);
		GET_PRIM_NAME(DSP_RESET);
		GET_PRIM_NAME(SET_ROD_MODE);
		GET_PRIM_NAME(RW_MODULE_VARIABLE);
		GET_PRIM_NAME(RW_BOC_DATA);
		GET_PRIM_NAME(BOC_HISTOGRAM);
		
		default:
			ERROR_CHECK(PROGRAM_ERROR, Wrong prim Id!); 
			return(-1);
	}

	return(0);
}
/*=============================================================================
 *                               getCmdName()
 *=============================================================================
 *
 *   Returns cmd ID as a text string 
 *
 */

#define  GET_CMD_NAME(cmdId) case (cmdId): strcpy(cmdName, #cmdId); break;

static int getCmdName(int cmdId, char cmdName[]){

	switch(cmdId){
	
		GET_CMD_NAME(RW_VME_COMMAND_ID);
		GET_CMD_NAME(RW_MASTER_COMMAND_ID);
		GET_CMD_NAME(RW_SLAVE_COMMAND_ID);
		GET_CMD_NAME(SEND_PRIM_LIST_COMMAND_ID);
		GET_CMD_NAME(COMPARE_FILES_COMMAND_ID);
		GET_CMD_NAME(BUS_TEST_ID);
		GET_CMD_NAME(RUN_CHILD_COMMAND_LIST_ID);
		GET_CMD_NAME(RW_FPGA_FLASH_ID);
		GET_CMD_NAME(WRITE_MDSP_FLASH_ID);
		GET_CMD_NAME(BOC_SETUP_ID);
		GET_CMD_NAME(RUN_EXTERNAL_PROGRAM_ID);
		GET_CMD_NAME(DELAY_COMMAND_ID);
		
		default:
			ERROR_CHECK(PROGRAM_ERROR, Wrong cmd Id!); 
			return(-1);
	}

	return(0);
}
/*=============================================================================
 *                               terminateString()
 *============================================================================= 
 *
 * removes new line character from input string 
 */
static void terminateString(char *string){
	
	int len=strlen(string);
	
	if(len>1) len--;
	if(string[len]==0xA) string[len]=0;
	
	return;
}
/*=============================================================================
 *                               readComment()
 *============================================================================= 
 *
 *  
 */
static int readComment(FILE* file, char comment[COMMENT_LENGTH]){  
 
   	char string[COMMENT_LENGTH];
   	int index=0;
   	char *result;
   	int len;
   	int i;								  
    
    for(i=0; i<20; i++){
	
		result = fgets (string, COMMENT_LENGTH, file);
		if(result==NULL) {
			return(-1); 
		}
		if(strcmp(string, "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n")==0){
			terminateString(comment);
			return(0);
		}
	
		len=strlen(string);
		if((index+len)<(COMMENT_LENGTH-1)){
			strcpy(&comment[index], string);
			index+=len;
		}else{
			return(-2);
		}
	}	
	
	return(-3);
}	

/******************************************************************************/