/******************************************************************************
 * 
 *  Title  : primFunc_buildStream.c 
 *  Version 0.0,
 *   
 *  Description: Task operation primitive function.    
 *  Related files:
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

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

#include <stdio.h>

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

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

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


	FILE *file;
	
	struct MSG_HEAD* primHeader=(struct MSG_HEAD*) primitive;
	UINT32 *primDataPtr=(UINT32*)((UINT32)primHeader+sizeof(struct MSG_HEAD));
	
	ERROR_ID errorId=SUCCESS;
	char errorMessage[200];
	int status;
	unsigned int chip, fibre;

	struct BUILD_STREAM_PARAMS *buildStream=&primTable->params.buildStream;
	const int panel=global.panel.primEdit[getPrimArrayId(BUILD_STREAM)];
	
	struct BUILD_STREAM_IN *buildStreamIn=&buildStream->inputParams;
	
	struct BUILD_STREAM_IN *buildStreamInBuff;

	unsigned int fileSize;
	
	if(R_BUILD_STREAM!=R_BUILD_STREAM_HOST){
		ERROR_CHECK(PROGRAM_ERROR, primitive BUILD_STREAM - wrong revision number);
		return(PROGRAM_ERROR);
	}

	switch(funcOption){
		case PRIM_PANEL_TO_TABLE:
		
			GetCtrlVal(panel, BUILD_STRM_CMD0, &buildStreamIn->cmdList.cmd[0]);
			GetCtrlVal(panel, BUILD_STRM_CMD1, &buildStreamIn->cmdList.cmd[1]);   
			GetCtrlVal(panel, BUILD_STRM_CMD2, &buildStreamIn->cmdList.cmd[2]);   
			GetCtrlVal(panel, BUILD_STRM_CMD3, &buildStreamIn->cmdList.cmd[3]); 
			GetCtrlVal(panel, BUILD_STRM_CMD4, &buildStreamIn->cmdList.cmd[4]);   
			GetCtrlVal(panel, BUILD_STRM_CMD5, &buildStreamIn->cmdList.cmd[5]); 
			GetCtrlVal(panel, BUILD_STRM_DATA0, &buildStreamIn->cmdList.data[0]); 
			GetCtrlVal(panel, BUILD_STRM_DATA1, &buildStreamIn->cmdList.data[1]);  
			GetCtrlVal(panel, BUILD_STRM_DATA2, &buildStreamIn->cmdList.data[2]);   
			GetCtrlVal(panel, BUILD_STRM_DATA3, &buildStreamIn->cmdList.data[3]);   
			GetCtrlVal(panel, BUILD_STRM_DATA4, &buildStreamIn->cmdList.data[4]);   
			GetCtrlVal(panel, BUILD_STRM_DATA5, &buildStreamIn->cmdList.data[5]);
			
			GetCtrlVal(panel, BUILD_STRM_CMD_BUFF, &buildStreamIn->port);
			GetCtrlVal(panel, BUILD_STRM_RESET, &buildStreamIn->reset); 
			
			GetCtrlVal(panel, BUILD_STRM_FIBRE, &buildStreamIn->fibre);
			GetCtrlVal(panel, BUILD_STRM_CHIP, &buildStreamIn->chip);
			
			GetCtrlVal(panel, BUILD_STRM_INPUT_OPTION, (int*)&buildStream->inputDataOption);
			
			switch(buildStream->inputDataOption){
			
				case MASK_DATA:
					buildStreamIn->dataLen = 4;
					GetCtrlVal(panel, BUILD_STRM_MASK0, &buildStream->mask[0]);
					GetCtrlVal(panel, BUILD_STRM_MASK1, &buildStream->mask[1]); 
					GetCtrlVal(panel, BUILD_STRM_MASK2, &buildStream->mask[2]); 
					GetCtrlVal(panel, BUILD_STRM_MASK3, &buildStream->mask[3]);
					break;

				case FILE_DATA:
					GetCtrlVal(panel, BUILD_STRM_INP_FILE, (char*)&buildStream->inDataFileName);
					GetCtrlVal(panel, BUILD_STRM_DATA_LEN, &buildStreamIn->dataLen);
					if(buildStream->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 BUILD_STREAM_IN)-SIZEOF(UINT32)+buildStreamIn->dataLen;
			primTable->inPrimHeader.id=BUILD_STREAM;
			primTable->inPrimHeader.primRevision=R_BUILD_STREAM; 
			primTable->replyLength=0; /* no reply */
		
	  		break;
	  		
		case PRIM_TABLE_TO_PANEL:
			if(primTable->inPrimHeader.primRevision!=R_BUILD_STREAM){  
				ERROR_CHECK(PROGRAM_ERROR, primitive BUILD_STREAM - wrong revision number);
				return(PROGRAM_ERROR);
			}
			
			SetCtrlVal(panel, BUILD_STRM_CMD0, buildStreamIn->cmdList.cmd[0]);  
			SetCtrlVal(panel, BUILD_STRM_CMD1, buildStreamIn->cmdList.cmd[1]);   
			SetCtrlVal(panel, BUILD_STRM_CMD2, buildStreamIn->cmdList.cmd[2]);   
			SetCtrlVal(panel, BUILD_STRM_CMD3, buildStreamIn->cmdList.cmd[3]); 
			SetCtrlVal(panel, BUILD_STRM_CMD4, buildStreamIn->cmdList.cmd[4]);   
			SetCtrlVal(panel, BUILD_STRM_CMD5, buildStreamIn->cmdList.cmd[5]); 
			SetCtrlVal(panel, BUILD_STRM_DATA0, buildStreamIn->cmdList.data[0]);  
			SetCtrlVal(panel, BUILD_STRM_DATA1, buildStreamIn->cmdList.data[1]);   
			SetCtrlVal(panel, BUILD_STRM_DATA2, buildStreamIn->cmdList.data[2]);   
			SetCtrlVal(panel, BUILD_STRM_DATA3, buildStreamIn->cmdList.data[3]);   
			SetCtrlVal(panel, BUILD_STRM_DATA4, buildStreamIn->cmdList.data[4]);   
			SetCtrlVal(panel, BUILD_STRM_DATA5, buildStreamIn->cmdList.data[5]);   

			SetCtrlVal(panel, BUILD_STRM_CMD_BUFF, buildStreamIn->port);
			SetCtrlVal(panel, BUILD_STRM_RESET, buildStreamIn->reset); 
			
			SetCtrlVal(panel, BUILD_STRM_FIBRE, buildStreamIn->fibre);
			SetCtrlVal(panel, BUILD_STRM_CHIP, buildStreamIn->chip); 
			
			SetCtrlVal(panel, BUILD_STRM_DATA_LEN, buildStreamIn->dataLen); 
			
			SetCtrlVal(panel, BUILD_STRM_INPUT_OPTION, buildStream->inputDataOption);

			switch(buildStream->inputDataOption){
				
				case MASK_DATA:
					SetInputMode(panel, BUILD_STRM_MASK0, 1);
					SetInputMode(panel, BUILD_STRM_MASK1, 1);
					SetInputMode(panel, BUILD_STRM_MASK2, 1);
					SetInputMode(panel, BUILD_STRM_MASK3, 1);
					
					SetCtrlVal(panel, BUILD_STRM_INP_FILE, 0); /* no input file */
					
					SetCtrlVal(panel, BUILD_STRM_INP_FILE, "");
					status=SetInputMode(panel, BUILD_STRM_INP_FILE, 0);
					UIR_STATUS_CHECK(status, SetInputMode());
					
					SetCtrlVal(panel, BUILD_STRM_MASK0, buildStream->mask[0]);
					SetCtrlVal(panel, BUILD_STRM_MASK1, buildStream->mask[1]); 
					SetCtrlVal(panel, BUILD_STRM_MASK2, buildStream->mask[2]); 
					SetCtrlVal(panel, BUILD_STRM_MASK3, buildStream->mask[3]);
					
					break;

				case FILE_DATA:
					
					SetInputMode(panel, BUILD_STRM_MASK0, 0);
					SetInputMode(panel, BUILD_STRM_MASK1, 0);
					SetInputMode(panel, BUILD_STRM_MASK2, 0);
					SetInputMode(panel, BUILD_STRM_MASK3, 0);
					
				
					SetCtrlVal(panel, BUILD_STRM_INP_FILE, buildStream->inDataFileName);
					status=SetInputMode(panel, BUILD_STRM_INP_FILE, 1);
					UIR_STATUS_CHECK(status, SetInputMode());

					break;

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

			break;  
			
		case PRIM_BUILD:
 			
			buildStreamInBuff=(struct BUILD_STREAM_IN*)(primDataPtr);
			/* copy data */ 
			*buildStreamInBuff=*buildStreamIn;
			
			switch(buildStream->inputDataOption){
				
				case MASK_DATA:
					
					memcpy(&buildStreamInBuff->data, buildStream->mask, buildStreamIn->dataLen*sizeof(UINT32));
					break;

				case FILE_DATA:
					/* copy params */
					errorId=getFileSize(buildStream->inDataFileName, &fileSize);
					ERROR_CHECK(errorId, getFileSize());

					buildStreamInBuff->dataLen=((fileSize+3)/4);
					/*copy data*/
					if(fileSize>0){
						errorId=readFromBinFile(buildStream->inDataFileName, &buildStreamInBuff->data, fileSize);
						ERROR_CHECK(errorId, readFromBinFile());
						if(errorId!=SUCCESS){
							return(errorId);
						}
					}
					
					/* update length!!!! */
					primTable->inPrimHeader.length=SIZEOF(struct MSG_HEAD)+SIZEOF(struct BUILD_STREAM_IN)-SIZEOF(UINT32)+buildStreamInBuff->dataLen;
					primHeader->length=primTable->inPrimHeader.length;
					
					break;

			}
			

 			break;
 
		case REP_DATA_PROCESS:
		
			/* no reply data */
			
			break;
		
		case WRITE_TO_FILE:
		
			file=(FILE*)inputParameter;
			
  			fprintf(file, "cmdList.cmd[] ={ 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X }\n",
  						buildStreamIn->cmdList.cmd[0], 
  						buildStreamIn->cmdList.cmd[1], 
  						buildStreamIn->cmdList.cmd[2], 
  						buildStreamIn->cmdList.cmd[3], 
  						buildStreamIn->cmdList.cmd[4],
  						buildStreamIn->cmdList.cmd[5]);	
  			fprintf(file, "cmdList.data[]={ 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X }\n",
  						buildStreamIn->cmdList.data[0], 
  						buildStreamIn->cmdList.data[1], 
  						buildStreamIn->cmdList.data[2], 
  						buildStreamIn->cmdList.data[3], 
  						buildStreamIn->cmdList.data[4],
  						buildStreamIn->cmdList.data[5]);
  			fprintf(file, "port= %d, reset= %d, chip= %2d, fibre= %d\n",
  						buildStreamIn->port, buildStreamIn->reset, buildStreamIn->chip, buildStreamIn->fibre);
  			fprintf(file, "InputDataOption= %d\n", buildStream->inputDataOption);
  			switch(buildStream->inputDataOption){
				case MASK_DATA:
					fprintf(file, "mask[]={ 0x%X, 0x%X, 0x%X, 0x%X }\n",
							buildStream->mask[0], buildStream->mask[1], buildStream->mask[2], buildStream->mask[3]);
					break;
				case FILE_DATA:
					fprintf(file, "inDataFileName[]= %s\n", buildStream->inDataFileName);
  					break;
  			}		
		
			break;
			
		case READ_FROM_FILE:
		
			file=(FILE*)inputParameter;
			
  			status=fscanf(file, "cmdList.cmd[] ={ 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X }\n",
  						(int*)&buildStreamIn->cmdList.cmd[0], 
  						(int*)&buildStreamIn->cmdList.cmd[1], 
  						(int*)&buildStreamIn->cmdList.cmd[2], 
  						(int*)&buildStreamIn->cmdList.cmd[3], 
  						(int*)&buildStreamIn->cmdList.cmd[4],
  						(int*)&buildStreamIn->cmdList.cmd[5]);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}			
  			status=fscanf(file, "cmdList.data[]={ 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X }\n",
  						&buildStreamIn->cmdList.data[0], 
  						&buildStreamIn->cmdList.data[1], 
  						&buildStreamIn->cmdList.data[2], 
  						&buildStreamIn->cmdList.data[3], 
  						&buildStreamIn->cmdList.data[4],
  						&buildStreamIn->cmdList.data[5]);
			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	  						
  			status=fscanf(file, "port= %d, reset= %d, chip= %2d, fibre= %d\n",
  						&buildStreamIn->port, &buildStreamIn->reset, &buildStreamIn->chip, &buildStreamIn->fibre);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}				
  			status=fscanf(file, "InputDataOption= %d\n", (int*)&buildStream->inputDataOption);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}	
  			
  			switch(buildStream->inputDataOption){
				case MASK_DATA:
					status=fscanf(file, "mask[]={ 0x%X, 0x%X, 0x%X, 0x%X }\n",
							&buildStream->mask[0], &buildStream->mask[1], &buildStream->mask[2], &buildStream->mask[3]);
					if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}		
					break;
				case FILE_DATA:
					status=readLineFromIndex(file, strlen("inDataFileName[]= "), PATHNAME_LENGTH, buildStream->inDataFileName);
					if(status!=0) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
  					break;
  			}		
         	
			break;	
		
		default: ;//error	
 	}

	return(SUCCESS);	
			
}

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