/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  
* CConsolePort
* System Includes
*
*/



#include <stdio.h>
#include <assert.h>

/*********************************************************************
 *
 * Local Includes
 *
 ********************************************************************/
#include "CConsolePort.h"
#include "../Core/UCCS_ErrorCodes.h"
#include "CProtocolTypes.h"

/*********************************************************************
 *
 * File-scope statics
 *
 ********************************************************************/
char *gKnownCommands[] = { "RUBBISH", "startusecase", "signal", "rendezvous", "endusecase", "quit", "waitforsignal", "runcmd", NULL };


/*********************************************************************
 *
 * Construction
 *
 ********************************************************************/
CConsolePort::CConsolePort()
	: iReadingData(0), iUcid(0), iCommand(0)
{
	memset( iCommandLine, 0x00, sizeof(iCommandLine) );
}


CConsolePort::~CConsolePort()
{
}


/*********************************************************************
 *
 * OpenPort() -- 
 *
 ********************************************************************/
int CConsolePort::OpenPort( char *port )
{
	return 0;
}


/*********************************************************************
 *
 * ClosePort() --
 *
 ********************************************************************/
void CConsolePort::ClosePort()
{
}

/*********************************************************************
 *
 *  ReadData() 
 *
 ********************************************************************/
int CConsolePort::ReadData( char* aBuff, int *aSize)
{
	int rand_uid = 1;
	int eng_result = 0;

	TEndUsecaseRequest* endusecase;
	TRunCommandRequest* runcommand;
	// Note we are using the startusecase structure for all the commands, as they 
	// are identical in the data they contain.
	TStartUsecaseRequest* othercases;

	// If the command we are reading the header for is Endusecase, then we 
	// have 8 bytes of data as opposed to 4, like the rest of the commands.
	// Therefore, need to distinguish between the commands.

	// If the Endusecase case
	if (iCommand == 4)
	{
		endusecase = (TEndUsecaseRequest*)aBuff;
		endusecase->iUsecaseID = iUcid;
		endusecase->iResult = eng_result;
		*aSize = sizeof(endusecase);
		iReadingData = 0;
		return 0;
	}
	else if( iCommand == 7 )
	{
		runcommand = (TRunCommandRequest*)aBuff;
		if( strlen(iCommandLine) > 0 )
		{
			memset( runcommand->iCommandLine, 0x00, sizeof(MAXCOMMANDLINELEN) );
			strcpy( runcommand->iCommandLine, iCommandLine );
			memset( iCommandLine, 0x00, sizeof(iCommandLine) );
		}
		runcommand->iResult = eng_result;
		*aSize = sizeof(runcommand);
		iReadingData = 0;
		return 0;
	}
	else 
	{	
		othercases = (TStartUsecaseRequest*)aBuff;
		othercases->iUsecaseID = iUcid; 
		*aSize = sizeof(othercases);
		iReadingData = 0;
		return 0;
	}
}

/*********************************************************************
 *
 *  ReadHeader() 
 *
 ********************************************************************/
int CConsolePort::ReadHeader( char* aBuff, int *aSize)
{
	int uid;
	int rand_uid = 1;
	int eng_result = 0;
	int ret;

	TPHeader *header = (TPHeader*)aBuff;

	do { 
	
		// Get the next command
		iCommand  = ParseNextLine( &uid );
		
		// If we have encountered an invalid command return 
		if( (iCommand == -2) ) 
		{
			return -1; //EInvalidCommand
		}
		
		header->iUid = rand_uid;
		ret = GetTPCommand(iCommand, &(header->iCmdID));
		if ( ret != 0 )
		{
			return -1; //EInvalidCommand
		}	

		// If the command is startusecase, for every other command we just ignore this
		if( iCommand == 1 ) 
		{
			iUcid = uid;
		}

		// If the command is endusecase - iDataLen is 8 - as currently we have 4 bytes 
		// for the uid and 4 for the result.
		if(iCommand == 4 )
		{
			header->iDataLen = E8DataLen;
		}
		else 
		{
			header->iDataLen = E4DataLen;
		}	
		
		// 4 bytes each for each field in the header.
		*aSize = sizeof(*header);
	} while( iCommand == -1 );

	return 0;
}

 
/*********************************************************************
 *
 *  ReceiveBytes() 
 *
 ********************************************************************/
int CConsolePort::ReceiveBytes( char* aBuff, int *aSize)
{
	int ret = 0;

	// If we are just the data part of the frame iReadingFlag is true
	if( iReadingData == 1 ) 
	{
		ret = ReadData( aBuff, aSize );
		if ( ret != 0 )
			return -1;
	
	}
	else
	{
		// Else we are reading the header - so get the next command
		ret = ReadHeader( aBuff, aSize );
		if ( ret != 0 )
			return -1;

		// Set the flag to true now that we have read the header,
		// so that the data part is read in the next iteration.
		iReadingData = 1;
	}
	
	// Return 
	return ret;
}


/*********************************************************************
 *
 *  SendBytes() 
 *
 ********************************************************************/
int CConsolePort::SendBytes( char *aBuff, int *aSize )
{
	int data_base_index;
	TPHeader* header;
	int *engine_result, *script_result;

	// extract the info from the buffer
	header = (TPHeader*)aBuff;
	data_base_index = sizeof(TPHeader);
	engine_result = ((int*)(&aBuff[data_base_index]));
	script_result = ((int*)(&aBuff[data_base_index+4]));

	// print out the information for the endusecase command
	if( header->iCmdID == CMD_REP_ENDUSECASEID ) {
		assert( header->iDataLen == E8DataLen );
		if( (*script_result) == 0 ) {
			fprintf( stdout, "  %s - No script errors occured.\n\n", GetUccsErrorStringI(*engine_result) );
		} else if( ((*script_result) > UCCS_OK) && ((*script_result) < UCCS_LAST) ) {
			fprintf( stdout, "  %s - %s\n\n", GetUccsErrorStringI(*engine_result), GetUccsErrorStringI(*script_result) );
		} else {
			fprintf( stdout, "  %s - %d\n\n", GetUccsErrorStringI(*engine_result), *script_result );
		}
		*aSize = 8;
	}

	// print out the information for all other commands 
	if( header->iCmdID != CMD_REP_ENDUSECASEID ) 
	{
		assert ( header->iDataLen == E4DataLen );
		if (*engine_result < 0)
			fprintf(stdout, "Error! %s (%d)\n\n", GetUccsErrorStringI(*engine_result), *engine_result);
		else
			fprintf(stdout, "Success! (0x%08x)\n\n", *engine_result);
		*aSize = 4;
	}

	// done
	return 0;
}


/*********************************************************************
 *
 * ParseNextLine() 
 *
 ********************************************************************/
int CConsolePort::ParseNextLine( int *uid )
{
	char *cp;
	char cline[MAXLINESIZE];
	char command[MAXLINESIZE];
	int token_count;
	int i;
	int match;

	// check param
	assert( uid != NULL );

	// write a litte prompt
	fprintf( stdout, "> " );

	// read the line 
	cp = fgets( cline, MAXLINESIZE, stdin );
	if( cp == NULL ) {
		return -2;
	}

	// tokenise the line
	token_count = sscanf( cline, "%s %d\n", command, uid );

	// if there are no tokens then leave
	if( token_count <= 0 ) {
		return -1;
	}

	// otherwise try and match the token
	for( i = 0; gKnownCommands[i] != NULL; i++ ) {
		match = strcmp( gKnownCommands[i], command );
		if( match == 0 ) {
			break;
		}
	}

	// If runcmd then set the command line data
	if( i == 7 )
	{
		if( strlen(iCommandLine) > 0 )
		{
			memset( iCommandLine, 0x00, sizeof(iCommandLine) );
		}
		strcpy( iCommandLine, cline );
	}

	// check that a command was found
	if( gKnownCommands[i] == NULL ) {
		fprintf( stderr, "WARNING: unknown command '%s' (ignoring)\n\n", command );
		return -1;
	}

	// otherwise we have a command -- if startusecase then make sure that it has a uid
	if( (i == 1) && (token_count == 1) ) {
		fprintf( stderr, "WARNING: command '%s' requires a use case ID argument\n\n", gKnownCommands[i] );
		return -1;
	}

	// OK -- return the command
	return i;
}


/*********************************************************************
 *
 * GetTPCommand() 
 *
 ********************************************************************/
int CConsolePort::GetTPCommand( int aCommandID, TPCommand* aTPCommand )
{

	switch (aCommandID)
	{
		case 1:		// startusecase
			*aTPCommand = CMD_REQ_STARTUSECASEID;
			break;
		
		case 2:		// signal
			*aTPCommand = CMD_REQ_SIGNALID;
			break;
		
		case 3:		// rendezvous
			*aTPCommand = CMD_REQ_RENDEZVOUSID;
			break;

		case 4:		// endusecase
			*aTPCommand = CMD_REQ_ENDUSECASEID;
			break;

		case 5:		// quit	
			*aTPCommand = CMD_QUITID;
			break;

		case 6:		// waitforsignal
			*aTPCommand = CMD_REQ_WAITID;
			break;

		case 7:		// runcmd
			*aTPCommand = CMD_REQ_RUNCOMMAND;
			break;

		default:
			return -1;
	}

	return 0;
}