/******************************************************************************
 *
 *  Title  : primFunc_test.c
 *  Version 0.0,
 *
 *  Description: 
 *  Related files:
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

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

#include <stdio.h>
#include "primFunc_test.h"
#include "globalDefinitions.h"
#include "uirUtility.h"
#include "primParamsUir.h"
#include "mainUir.h"
#include <utility.h>
#include "primFunctionInit.h"
#include "RWlists.h"

/******************************************************************************
 *                              Global functions                              *
 ******************************************************************************/

/*=============================================================================
 *                              primFunction_test()
 *=============================================================================
 *
 *	
 *
 */
ERROR_ID primFunction_test(PRIM_FUNC_OPTION funcOption, struct PRIM_TABLE *primTable, void *primitive, UINT32 inputParameter, UINT8 slotNumber){

	FILE *file;

	ERROR_ID errorId=SUCCESS;
	char errorMessage[200];
	int status;
/*	char *fileName;*/
	unsigned int fileSize;
	struct MSG_HEAD* primHeader=(struct MSG_HEAD*) primitive;
	UINT32 *primDataPtr=(UINT32*)((UINT32)primHeader+sizeof(struct MSG_HEAD));
	struct HOST *host;

	int outputFile;
	struct TEST_PARAMS *test=&primTable->params.test;
	char subdir[PATHNAME_LENGTH];
	const int panel=global.panel.primEdit[getPrimArrayId(TEST)];
	UINT32 i, j;
	UINT32 dataLength;
	int paramsLength;

	struct TEST_IN *testIn;


	if(R_TEST!=R_TEST_HOST){
		ERROR_CHECK(PROGRAM_ERROR, primitive TEST - wrong revision number);
		return(PROGRAM_ERROR);
	}

	switch(funcOption){

		case PRIM_PANEL_TO_TABLE:

			GetCtrlVal(panel, TESTP_INPUT_OPTION, (int*)&test->inputDataOption);

			switch(test->inputDataOption){
				case T_TEST_PATTERN:
					GetTableCellRangeVals (panel, TESTP_INP_TABLE, MakeRect (1, 1, 10, 3), test->testPattern, VAL_COLUMN_MAJOR);
					test->inputParams.dataLen = 30; /*Length of data from INP_TABLE*/
					break;

				case T_FROM_FILE:
					GetCtrlVal(panel, TESTP_INP_FILE, (char*)&test->inDataFileName);
					GetCtrlVal(panel, TESTP_DATA_LEN, &test->inputParams.dataLen);
					if(test->inDataFileName[0]==0){
						status=MessagePopup ("WARNING", "Select input data!");
						UIR_STATUS_CHECK(status, MessagePopup());
						return(PROGRAM_ERROR);
					};

					break;
				default: ERROR_CHECK(PROGRAM_ERROR, wrong test input option!);
					break;
			}
			/* NO BREAK HERE!!!*/
		case PRIM_PARAMS_TO_TABLE:

			/* add table headers - don't set indexes!!! */
			primTable->inPrimHeader.length=SIZEOF(struct MSG_HEAD)+SIZEOF(struct TEST_IN)-SIZEOF(UINT32)+test->inputParams.dataLen;
			primTable->inPrimHeader.id=TEST;
			primTable->inPrimHeader.primRevision=R_TEST_HOST;
			primTable->replyLength=0;/* not known */

	  		break;

		case PRIM_TABLE_TO_PANEL:
			if(primTable->inPrimHeader.primRevision!=R_TEST){
				ERROR_CHECK(PROGRAM_ERROR, primitive TEST - wrong revision number);
				return(PROGRAM_ERROR);
			}

			SetCtrlVal(panel, TESTP_INPUT_OPTION, test->inputDataOption);

			switch(test->inputDataOption){
				case T_TEST_PATTERN:

					SetTableCellRangeVals (panel, TESTP_INP_TABLE, MakeRect (1, 1, 10, 3), test->testPattern, VAL_COLUMN_MAJOR);
					SetCtrlVal(panel, TESTP_INP_FILE, 0); /* no input file */
					SetCtrlVal(panel, TESTP_DATA_LEN, test->inputParams.dataLen);

					status=SetInputMode(panel, TESTP_INP_TABLE, 1);
					UIR_STATUS_CHECK(status, SetInputMode());

					SetCtrlVal(panel, TESTP_INP_FILE, "");
					status=SetInputMode(panel, TESTP_INP_FILE, 0);
					UIR_STATUS_CHECK(status, SetInputMode());

					break;

				case T_FROM_FILE:
					SetCtrlVal(panel, TESTP_INP_FILE, test->inDataFileName);
					status=SetInputMode(panel, TESTP_INP_FILE, 1);
					UIR_STATUS_CHECK(status, SetInputMode());

					status=SetInputMode(panel, TESTP_INP_TABLE, 0);
					UIR_STATUS_CHECK(status, SetInputMode());

					status=SetCtrlAttribute(panel, TESTP_DATA_LEN, ATTR_CTRL_MODE, VAL_INDICATOR);
					UIR_STATUS_CHECK(status, SetCtrlAttribute());

					SetCtrlVal(panel, TESTP_DATA_LEN, test->inputParams.dataLen);

					break;

				default:
					ERROR_CHECK(PROGRAM_ERROR, primitive ECHO - inputDataOption);
					break;
			}

			break;
		case PRIM_BUILD:

			testIn=(struct TEST_IN*)(primDataPtr);
			switch (test->inputDataOption) {

				case T_TEST_PATTERN:
					testIn->dataLen = 30; /*Length of data from INP_TABLE*/
					memcpy(&testIn->dataPtr, test->testPattern, 30*sizeof(UINT32)); /*Length of data from INP_TABLE*/

					break;

				case T_FROM_FILE:

					/* copy params */
					errorId=getFileSize(test->inDataFileName, &fileSize);
					ERROR_CHECK(errorId, getFileSize());

					testIn->dataLen=((fileSize+3)/4);
					primDataPtr+=SIZEOF(UINT32);
					/*copy data*/
					if(fileSize>0){
						errorId=readFromBinFile(test->inDataFileName, primDataPtr, fileSize);
						ERROR_CHECK(errorId, readFromBinFile());
						if(errorId!=SUCCESS){
							return(errorId);
						}
					}

	 			break;
			}

			/* update length!!!! */
			primTable->inPrimHeader.length=SIZEOF(struct MSG_HEAD)+SIZEOF(struct TEST_IN)-SIZEOF(UINT32)+testIn->dataLen;
			primHeader->length=primTable->inPrimHeader.length;


			break;

		case REP_DATA_PROCESS:

			host=global.host[HOST_INDEX(slotNumber)];

			dataLength=primHeader->length-SIZEOF(struct MSG_HEAD);

 			/* save reply data */
			strcpy(subdir, host->dataDir);
			if(test->inDataFileName[0] == 0)
			{
				strcat(subdir, "test_default_output.out");
			}
			else
			{
				strncat (subdir, test->inDataFileName, strlen(test->inDataFileName)-3);
				strcat (subdir, "out");
			}
			errorId=writeToBinFile(subdir, 0, primDataPtr, dataLength*sizeof(UINT32));
			ERROR_CHECK(errorId, writeToBinFile());

			break;
			
		case WRITE_TO_FILE:

			file=(FILE*)inputParameter; 
			
  			fprintf(file, "dataLen= 0x%X, inputDataOption= %d\n", test->inputParams.dataLen, test->inputDataOption); 
  			switch (test->inputDataOption) {

				case T_TEST_PATTERN:
					fprintf(file, "testPattern[]={\n");
					for(i=0; i<6; i++){
						for(j=0; j<5; j++) fprintf(file, " 0x%X,", test->testPattern[5*i+j]);
						if(i<5) fprintf(file, "               \n");
						else  fprintf(file, "}\n");
					}
					
					break;

				case T_FROM_FILE:
					fprintf(file, "inDataFileName[]= %s\n", test->inDataFileName);
	 				break;
			}
  			
			break;
			
		case READ_FROM_FILE:
		
			file=(FILE*)inputParameter;
			
			status=fscanf(file, "dataLen= 0x%X, inputDataOption= %d\n", &test->inputParams.dataLen, (int*) &test->inputDataOption); 
			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
  			switch (test->inputDataOption) {

				case T_TEST_PATTERN:
					status=fscanf(file, "testPattern[]={\n");
					if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	
					for(i=0; i<6; i++){
						for(j=0; j<5; j++){
							status=fscanf(file, " 0x%X,", &test->testPattern[5*i+j]);
							if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	
						}	
						if(i<5) status=fscanf(file, "               \n");
						else  status=fscanf(file, "}\n");
						if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	
					}
					
					break;

				case T_FROM_FILE:
					status=readLineFromIndex(file, strlen("inDataFileName[]= "), PATHNAME_LENGTH, test->inDataFileName);
					if(status!=0) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	
	 				break;
			}
			
			break;	

	

		default: ;
 	}


	return(errorId);

}

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