/******************************************************************************
 * 
 *  Title  : primFunc_sendSlaveList.c 
 *  Version 0.0,
 *   
 *  Description: Send slaveList primitive function.    
 *  Related files:
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

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

#include <stdio.h>
#include "primFunc_sendSlaveList.h"
#include "globalDefinitions.h"
#include "uirUtility.h"
#include "primParamsUir.h"
#include "mainUir.h"
#include "hostUtility.h"   
#include <utility.h>   
#include "primFunctionInit.h"

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

/*=============================================================================
 *                              primFunction_sendSlaveList()
 *=============================================================================
 *
 *	
 *
 */
ERROR_ID primFunction_sendSlaveList(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));
	
	struct MSG_LIST_HEAD *outListHeader;  
	struct MSG_LIST_TAIL *outListTrailer;  
	struct MSG_HEAD *outPrimHeader;   
	struct PRIM_TABLE *primTableSlave;
	
	ERROR_ID errorId;
	ERROR_ID returnErrorId=SUCCESS;   
	char errorMessage[200];
	int status;
	
	UINT32 primBodyLength;
	UINT32 primitiveId;

	struct PRIM_SEND_SLAVE_LIST_PARAMS *sendSlaveList=&primTable->params.sendSlaveList;
	const int panel=global.panel.primEdit[getPrimArrayId(SEND_SLAVE_LIST)];
	UINT32 i;
	UINT32 dataLength;
	struct SEND_SLAVE_LIST_IN *sendSlaveListIn;
	struct SEND_SLAVE_LIST_OUT *sendSlaveListOut;
	char textMessage[200];
	char errorText[100]; 
	UINT32 listIndex;
	int ringIndex;
	UINT32 listLength;
	UINT32 index;
	UINT32 *listStartPtr;
	struct HOST *host;
	UINT32 maxLength;
	
	
	int slaveChecksumYes;
	UINT32 checksumHost;

		
	if(R_SEND_SLAVE_LIST!=R_SEND_SLAVE_LIST_HOST){
		ERROR_CHECK(PROGRAM_ERROR, primitive SEND_SLAVE_LIST - wrong revision number);
		return(PROGRAM_ERROR);
	}

	switch(funcOption){
		case PRIM_PANEL_TO_TABLE:
		
			GetCtrlVal(panel, SEND_SLIST_SLV_ID, &sendSlaveList->primParams.slaveNumber);

			/* NO BREAK HERE!!!*/
		case PRIM_PARAMS_TO_TABLE:				
			/* add table headers - don't set indexes!!! */ 
			listLength=SIZEOF(struct MSG_HEAD)+SIZEOF(struct SEND_SLAVE_LIST_IN);
			//primTable->inPrimHeader.length - calculated in primListEditor 
			primTable->inPrimHeader.id=SEND_SLAVE_LIST;
			primTable->inPrimHeader.primRevision=R_SEND_SLAVE_LIST; 
			
			sendSlaveList->primParams.slavePrimList=(UINT32*)DEFAULT; /* inList in primBuff !!!!! */
			sendSlaveList->primParams.slaveRepData=(UINT32*)DEFAULT; /* reply list in primBuff !!!!! */

			// primTable->outPrimHeader.length - calculated in primListEditor
			
			sendSlaveList->inSlaveListHeader.primListRevision=PRIM_LIST_REVISION;
		
	  		break;
		
		case PRIM_TABLE_TO_PANEL:
			if(primTable->inPrimHeader.primRevision!=R_SEND_SLAVE_LIST){  
				ERROR_CHECK(PROGRAM_ERROR, primitive SEND_SLAVE_LIST - wrong revision number);
				return(PROGRAM_ERROR);
			}
			
			SetCtrlVal(panel, SEND_SLIST_SLV_ID, sendSlaveList->primParams.slaveNumber);
			SetCtrlVal(panel, SEND_SLIST_LIST_LENGTH, sendSlaveList->primParams.listLength);

			break;
		case PRIM_BUILD:
			maxLength=inputParameter; /* !!! */    
		
 			/* copy params */
			*(struct SEND_SLAVE_LIST_IN*)(primDataPtr)=sendSlaveList->primParams;
			
			if(sendSlaveList->inSlaveListHeader.length==0) break; 
			/* copy list */ 
			primDataPtr+=(SIZEOF(struct SEND_SLAVE_LIST_IN));
			listStartPtr=primDataPtr;
			memcpy(primDataPtr, &sendSlaveList->inSlaveListHeader, sizeof(struct MSG_LIST_HEAD));	
			primDataPtr+=SIZEOF(struct MSG_LIST_HEAD);
			
			for(index=0; index<sendSlaveList->inSlaveListHeader.numMsgs; ++index){
			
				++primTable;
				memcpy(primDataPtr, &primTable->inPrimHeader, sizeof(struct MSG_HEAD));  
				errorId=(*global.primFunction[getPrimArrayId(primTable->inPrimHeader.id)])(PRIM_BUILD, primTable, (struct MSG_HEAD*)primDataPtr, maxLength, slotNumber);  
				ERROR_CHECK(errorId, primFunction());
				if(errorId!=SUCCESS) return(errorId);
	
				primDataPtr+=primTable->inPrimHeader.length; 
			
			}
			
			*primDataPtr=sendSlaveList->inSlaveListHeader.length;
			++primDataPtr;
			
			host=global.host[HOST_INDEX(slotNumber)];  
			if(global.option.slaveChecksum){ 
				*primDataPtr=checkSum(listStartPtr, sendSlaveList->inSlaveListHeader.length-1); 
			}	
			
 			break;
 
		case REP_DATA_PROCESS:
			/* similar to master repListProcessing.c - some shared code could be moved to common functions */ 
			outListHeader=(struct MSG_LIST_HEAD*)primDataPtr;
			primDataPtr+=SIZEOF(struct MSG_LIST_HEAD);
		
			/* reply */
			host=global.host[HOST_INDEX(slotNumber)];  
			
			if(outListHeader->index!=sendSlaveList->inSlaveListHeader.index) {
				returnErrorId=REPLIST_ERROR;
				HOST_ERROR_CHECK(returnErrorId, host, Slave RepList index error!);
				return(returnErrorId); /* don't process */
			}
			/* check list length */ 
			if(outListHeader->length!=sendSlaveList->replyLength) {
				returnErrorId=REPLIST_ERROR;
				ERROR_CHECK(returnErrorId, SlaveRepListLength!=expectedLength); 
				/* continue anyway */
			}
			
			/* check trailer length */
			outListTrailer=(struct MSG_LIST_TAIL*)(primDataPtr+outListHeader->length-SIZEOF(struct MSG_LIST_HEAD)-SIZEOF(struct MSG_LIST_TAIL));   
    		if(outListTrailer->length!=sendSlaveList->replyLength){
    			returnErrorId=REPLIST_ERROR; 
    			ERROR_CHECK(returnErrorId, outListTrailer->length!=primTable->outPrimHeader.length);
    			return(returnErrorId);
    		};
    		

			if(global.option.slaveChecksum){
				checksumHost=checkSum((UINT32*)outListHeader, outListHeader->length);
				if(checksumHost!=0){
					returnErrorId=REPLIST_ERROR;
					ERROR_CHECK(returnErrorId, Slave checksum error!);
					return(returnErrorId); /* don't process */
				}
			} 
    		
			if(sendSlaveList->replyCount!=outListHeader->numMsgs){ 
				returnErrorId=REPLIST_ERROR; 
				ERROR_CHECK(returnErrorId, Slave numMsgs!=expectedNumMsgs); 
				/* continue anyway */ 
			}
	
			for(index=0; index<(outListHeader->numMsgs); ++index){
		
				outPrimHeader=(struct MSG_HEAD*)primDataPtr;
				primTableSlave=primTable+outPrimHeader->index+1;
		
				if((outPrimHeader->length!=primTableSlave->replyLength)&&(primTableSlave->inPrimHeader.id!=SEND_DATA)){
					
					returnErrorId=REPLIST_ERROR; 
					ERROR_CHECK(returnErrorId, RepPrim length!=expectedLength);
					primDataPtr+= outPrimHeader->length; 
					continue; /* don't process */   
				}
		
				if(outPrimHeader->id!=primTableSlave->inPrimHeader.id){
					returnErrorId=REPLIST_ERROR;  
					ERROR_CHECK(returnErrorId, Wrong reply prim ID!);
					primDataPtr+= outPrimHeader->length; 
					continue; /* don't process */   
				}
		
				/* processing */
				errorId=(*global.primFunction[getPrimArrayId(outPrimHeader->id)])(REP_DATA_PROCESS, primTableSlave, outPrimHeader, sendSlaveList->primParams.slaveNumber, slotNumber);
				ERROR_CHECK(errorId, primFunction());
				if(errorId!=SUCCESS){
					returnErrorId=REPLIST_ERROR;
				}
				primDataPtr+= outPrimHeader->length;
		
			}	
    		
			break;
			
		case WRITE_TO_FILE:
		
			file=(FILE*)inputParameter;
			
  			fprintf(file, "slaveNumber= %d, listLength= 0x%X, *slavePrimList= 0x%X, *slaveRepData= 0x%X\n", 
  						sendSlaveList->primParams.slaveNumber, sendSlaveList->primParams.listLength,
  						(UINT32)sendSlaveList->primParams.slavePrimList, (UINT32)sendSlaveList->primParams.slaveRepData); 
  			
  			fprintf(file, "inSlaveListHeader.length: 0x%X, numMsgs= 0x%X, primListRevision= %d,\nreplyLength: 0x%X, replyCount: 0x%X\n",
						sendSlaveList->inSlaveListHeader.length, sendSlaveList->inSlaveListHeader.numMsgs, 
						sendSlaveList->inSlaveListHeader.primListRevision, sendSlaveList->replyLength, sendSlaveList->replyCount);
  			
			break;
			
		case READ_FROM_FILE:
		
			file=(FILE*)inputParameter;
			
			status=fscanf(file, "slaveNumber= %d, listLength= 0x%X, *slavePrimList= 0x%X, *slaveRepData= 0x%X\n", 
  						&sendSlaveList->primParams.slaveNumber, &sendSlaveList->primParams.listLength,
  						(UINT32*)&sendSlaveList->primParams.slavePrimList, (UINT32*)&sendSlaveList->primParams.slaveRepData);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
  			status=fscanf(file, "inSlaveListHeader.length: 0x%X, numMsgs= 0x%X, primListRevision= %d,\nreplyLength: 0x%X, replyCount: 0x%X\n",
						&sendSlaveList->inSlaveListHeader.length, &sendSlaveList->inSlaveListHeader.numMsgs, 
						&sendSlaveList->inSlaveListHeader.primListRevision, &sendSlaveList->replyLength, &sendSlaveList->replyCount);
  			if(status==-1) {ERROR_CHECK(FATAL_ERROR, Read from prim file error!); return(FATAL_ERROR);}
         	
			break;	

		
		default: ;
 	}

	return(returnErrorId);	
			
}

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