/*
* 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:  
* System Includes
*
*/



#include <e32uid.h>
#include <string.h>
#include <stdlib.h>


/**********************************************************************************
 *
 * Local Includes
 *
 *********************************************************************************/
#include "assert.h"
#include "CUCCSDeviceControl.h"

// Error Codes
#include "CProtocolTypes.h"
#include "UCCS_ErrorCodes.h"


/**********************************************************************************
 *
 * Dll Entry point
 *
 *********************************************************************************/
/**********************************************************************************
 *
 * Construction / Destruction
 *
 *********************************************************************************/
EXPORT_C CUCCSDeviceControl* CUCCSDeviceControl::New()
{
	CUCCSDeviceControl* self = new CUCCSDeviceControl();
    CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
    return self;
}


CUCCSDeviceControl::CUCCSDeviceControl()
{
}


void CUCCSDeviceControl::ConstructL()
{
	iProtocol = new (ELeave) CUCCSDeviceProtocol();
	assert( iProtocol != NULL );
}


EXPORT_C CUCCSDeviceControl::~CUCCSDeviceControl()
{
	int ret;
	ret = iProtocol->disconnect();
	assert (ret == TDC_SUCCESS);
	assert( iProtocol != NULL );
	delete iProtocol;
	iProtocol = NULL;
}


EXPORT_C TUint CUCCSDeviceControl::connectL( TDesC *aRemoteHost, TDPTransport aTransportType )
{
	int ret = iProtocol->initialise(*aRemoteHost,aTransportType);
	if (ret != TDP_SUCCESS)
		return TDC_ERRINTIALISING;
	return TDC_SUCCESS;
}


/**********************************************************************************
 *
 * startUseCase
 *
 *********************************************************************************/
EXPORT_C TUint CUCCSDeviceControl::startUseCase ( TUint aData, int *aErrorCode )
{		
	int ret, datalen;
	TStartUsecaseRequest req;
	TStartUsecaseReply rep;
	TPCommand cmdID;

	// Send the request
	cmdID = CMD_REQ_STARTUSECASEID;
	req.iUsecaseID = aData;
	datalen = sizeof(req);
	
	ret = iProtocol->sendMessage( cmdID, datalen, &req);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRSENDING;

	// Get the reply
	datalen = sizeof(rep);
	ret = iProtocol->receiveMessage ( &cmdID, &datalen, &rep);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRRECV;

	// Check that the reply cmdID is what we expect it to be
	if ( cmdID != CMD_REP_STARTUSECASEID )
		return TDC_INVALIDREPLY;

	// Then return the result
	return rep.iResult;
}

/**********************************************************************************
 *
 * signal
 *
 *********************************************************************************/
EXPORT_C TUint CUCCSDeviceControl::signal( TUint aData, int *aErrorCode )
{
	int ret, datalen;
	TSignalRequest req;
	TSignalReply rep;
	TPCommand cmdID;

	// Send the request
	cmdID = CMD_REQ_SIGNALID;
	req.iUsecaseID = aData;
	datalen = sizeof(req);
	
	ret = iProtocol->sendMessage( cmdID, datalen, &req);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRSENDING;

	// Get the reply
	datalen = sizeof(rep);
	ret = iProtocol->receiveMessage ( &cmdID, &datalen, &rep);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRRECV;

	// Check that the reply cmdID is what we expect it to be
	if ( cmdID != CMD_REP_SIGNALID )
		return TDC_INVALIDREPLY;

	// Then return the result
	return rep.iResult;
}

/**********************************************************************************
 *
 * waitfor
 *
 *********************************************************************************/
EXPORT_C TUint CUCCSDeviceControl::waitfor( TUint aData, int *aErrorCode )
{
	int ret, datalen;
	TWaitRequest req;
	TWaitReply rep;
	TPCommand cmdID;

	// Send the request
	cmdID = CMD_REQ_WAITID;
	req.iUsecaseID = aData;
	datalen = sizeof(req);
	
	ret = iProtocol->sendMessage( cmdID, datalen, &req);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRSENDING;

	// Get the reply
	datalen = sizeof(rep);
	ret = iProtocol->receiveMessage ( &cmdID, &datalen, &rep);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRRECV;

	// Check that the reply cmdID is what we expect it to be
	if ( cmdID != CMD_REP_WAITID )
		return TDC_INVALIDREPLY;

	// Then return the result
	return rep.iResult;
}

/**********************************************************************************
 *
 * rendezvous
 *
 *********************************************************************************/
EXPORT_C TUint CUCCSDeviceControl::rendezvous( TUint aData, int *aErrorCode )
{
	int ret, datalen;
	TRendezvousRequest req;
	TRendezvousReply rep;
	TPCommand cmdID;

	// Send the request
	cmdID = CMD_REQ_RENDEZVOUSID;
	req.iUsecaseID = aData;
	datalen = sizeof(req);
	
	ret = iProtocol->sendMessage( cmdID, datalen, &req);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRSENDING;

	// Get the reply
	datalen = sizeof(rep);
	ret = iProtocol->receiveMessage ( &cmdID, &datalen, &rep);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRRECV;

	// Check that the reply cmdID is what we expect it to be
	if ( cmdID != CMD_REP_RENDEZVOUSID )
		return TDC_INVALIDREPLY;

	// Then return the result
	return rep.iResult;
}

/**********************************************************************************
 *
 * endUseCase
 *
 *********************************************************************************/
EXPORT_C TUint CUCCSDeviceControl::endUseCase (TUint aUseCaseID, TUint aResult, int *aErrorCode )
{	
	int ret, datalen;
	TEndUsecaseRequest req;
	TEndUsecaseReply rep;
	TPCommand cmdID;

	// Send the request
	cmdID = CMD_REQ_ENDUSECASEID;
	req.iUsecaseID = aUseCaseID;
	req.iResult = aResult;
	datalen = sizeof(req);
	
	ret = iProtocol->sendMessage( cmdID, datalen, &req);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRSENDING;

	// Get the reply
	datalen = sizeof(rep);
	ret = iProtocol->receiveMessage ( &cmdID, &datalen, &rep);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRRECV;

	// Check that the reply cmdID is what we expect it to be
	if ( cmdID != CMD_REP_ENDUSECASEID )
		return TDC_INVALIDREPLY;

	// Then return the result
	return rep.iCommandResult;
}

/**********************************************************************************
 *
 * getVariableName
 *
 *********************************************************************************/
EXPORT_C TUint CUCCSDeviceControl::getVariableName( char* aVariableName, char* aOutputBuffer, int aOutputBufferSize, int *aErrorCode )
{
	int ret, len, recDatalen;
	TGetVariableNameRequest var_req;
	TGetVariableNameReply var_rep;
	TPCommand cmd;

	// Check params
	assert ( aVariableName != NULL );
	assert ( aOutputBuffer != NULL );
	assert ( aOutputBufferSize >= 0);

	// Check if aVariableName can be copied into our structure
	len = strlen(aVariableName) + 1;
	if ( len > MAXVARNAMELEN )
		return TDC_VARNAMETOOLONG;

	// Then copy into our buffer
	memcpy ( var_req.iVariableName, aVariableName, len);

	// Send the request
	cmd = CMD_REQ_GETVARIABLENAMEID;
	ret = iProtocol->sendMessage( cmd, sizeof(var_req), &var_req);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRSENDING;

	// Get the reply
	recDatalen = sizeof(var_rep);
	ret = iProtocol->receiveMessage( &cmd, &recDatalen, &var_rep);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRRECV;

	// Check whether we successfully retrieved the value we want
	if ( cmd != CMD_REP_GETVARIABLENAMEID)
		return TDC_INVALIDREPLY;			// Not what we are expecting 

	// Only copy the data if everything went ok at the UCCS end - UCCS_OK 
	if ( var_rep.iResult == UCCS_OK )
	{
		// Return the data
		// Check that the data received will fit into the return buffer
		len = strlen (var_rep.iVariableValue) + 1;
		if ( len > aOutputBufferSize )
			return TDC_VARVALTOOLONG;

		// Else copy the data into the return buffer
		memcpy ( aOutputBuffer, var_rep.iVariableValue, len);
	}

	return var_rep.iResult;
}

/**********************************************************************************
 *
 * runCommand
 *
 *********************************************************************************/
EXPORT_C TUint CUCCSDeviceControl::runCommandL( char* aCommandLine, int *aErrorCode )
{
	int ret, len, recDatalen;
	TRunCommandRequest* run_req = new (ELeave) (TRunCommandRequest);
	TRunCommandReply run_rep;
	TPCommand cmd;

	// Check params
	assert ( aCommandLine != NULL );

	// Check if aCommandLine can be copied into our structure
	len = strlen( aCommandLine )+1;
	if ( len > MAXCOMMANDLINELEN )
		return TDC_COMMANDLINETOOLONG;

	// Then copy into our buffer
	memset( run_req->iCommandLine, 0x00, sizeof(run_req->iCommandLine) );
	memcpy( run_req->iCommandLine, aCommandLine, len);

	// Send the request
	cmd = CMD_REQ_RUNCOMMAND;
	ret = iProtocol->sendMessage( cmd, sizeof(*run_req), run_req);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRSENDING;

	// Get the reply
	recDatalen = sizeof(run_rep);
	ret = iProtocol->receiveMessage( &cmd, &recDatalen, &run_rep);
	*aErrorCode = ret;
	if ( ret != TDP_SUCCESS )
		return TDC_ERRRECV;

	// Check whether we successfully retrieved the value we want
	if ( cmd != CMD_REP_RUNCOMMAND)
		return TDC_INVALIDREPLY;			// Not what we are expecting 

	return run_rep.iResult;
}