/*
* Copyright (c) 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: 
*
*/


#include <e32debug.h>
#include <e32base.h>
#include <e32cons.h>

#include "logging.h"
#include "dbgtrcportmgr.h"
#include "ostprotregistry.h"
#include "portreader.h"
#include "portwriter.h"
#include "dbgtrcsrvsession.h"
#include "ostmessage.h"
#include "ostbaserouter.h"

// Static functions

//
// Swap2
//
// Byte-swaps a 2-byte value.  Used to convert to/from little/big endian.
//
static TUint16 Swap2(TUint16 aSource)
{
	TUint16 dest = 0;
	for (TInt i=0; i<2; i++)
	{
		dest <<= 8;
		dest |= aSource & 0xFF;
		aSource >>= 8;
	}
	
	return dest;
} 

COstWriteMsgEntry* COstWriteMsgEntry::NewL(TDesC8& aMsg, CDbgTrcSrvSession* aMsgListener)
{
	LOG_MSG("COstWriteMsgEntry::NewL");

	COstWriteMsgEntry* self = new(ELeave) COstWriteMsgEntry(aMsgListener);
	CleanupStack::PushL(self);
	self->ConstructL(aMsg);
	CleanupStack::Pop(self);
	return self;
}

COstWriteMsgEntry::COstWriteMsgEntry(CDbgTrcSrvSession* aMsgListener)
: iMessage(NULL),
  iWriteMsgListener(aMsgListener)
{
	LOG_MSG("COstWriteMsgEntry::COstWriteMsgEntry");


}

COstWriteMsgEntry::~COstWriteMsgEntry()
{
	LOG_MSG("COstWriteMsgEntry::~COstWriteMsgEntry");

	SafeDelete(iMessage);
	iWriteMsgListener = NULL; //don't delete the listener since we don't really own it.
}

void COstWriteMsgEntry::ConstructL(TDesC8& aMsg)
{
	LOG_MSG("COstWriteMsgEntry::ConstructL");

	iMessage = COstMessage::NewL(aMsg);
}


COstBaseRouter*	COstBaseRouter::NewL()
{
	LOG_MSG("COstWriteMsgEntry::NewL");

	COstBaseRouter* self = new(ELeave) COstBaseRouter;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
}

COstBaseRouter::COstBaseRouter()
: iPortManager(NULL),
  iProtRegistry(NULL),
  iWriteMsgListener(NULL),
  iWriteMsgQueue(1)  
{
	LOG_MSG("COstBaseRouter::COstBaseRouter");

}

COstBaseRouter::~COstBaseRouter()
{	
	LOG_MSG("COstBaseRouter::~COstBaseRouter");

	SafeDelete(iPortManager);
	SafeDelete(iProtRegistry);
	
	iWriteMsgQueue.ResetAndDestroy();	
	iWriteMsgQueue.Close();
}

void COstBaseRouter::ConstructL()
{
	LOG_MSG("COstBaseRouter::ConstructL");

	iPortManager = CDbgTrcPortMgr::NewL();	
	iProtRegistry = COstProtRegistry::NewL();
	
	// check the target endianness
	TUint32	test;
	TUint8 *byte_alias = (TUint8 *)&test;
	
	// Write a specific 4-byte sequence and then read it as
	// a 32-bit word.  Big-endian systems yield one value and
	// little-endian systems yield another.
	
	byte_alias[ 0 ] = 0x12;
	byte_alias[ 1 ] = 0x34;
	byte_alias[ 2 ] = 0x56;
	byte_alias[ 3 ] = 0x78;
	
	if (test == 0x12345678)
		iIsBigEndian = ETrue;
	else
		iIsBigEndian = EFalse;			
	
	iSendMsgBuffer.Zero();
	iRecvMsgBuffer.Zero();
	
	iWriteMsgQueue.Reset();
}

void COstBaseRouter::RegisterProtocol(const TOstProtIds aProtId, CDbgTrcSrvSession* aProtMsgListener, TBool aNeedHeader)
{
	LOG_MSG("COstBaseRouter::RegisterProtocol");

	iProtRegistry->RegisterProtocol(aProtId, aProtMsgListener, aNeedHeader);
	
	// Initiate the reads once someone registers a protocol.
	//ReadMessage();
}

void COstBaseRouter::UnRegisterProtocol(const TOstProtIds aProtId)
{
	LOG_MSG("COstBaseRouter::UnRegisterProtocol");

	iProtRegistry->UnRegisterProtocol(aProtId);
	
	// if listener count is 0, cancel the reads as well.
	if (!iProtRegistry->GetProtListenerCount())
	{
		CPortReader* reader = iPortManager->GetPortReader();
		if (reader)
		{
			reader->Cancel();
		}
	}	
}


void COstBaseRouter::ReadMessage()
{	
	LOG_MSG("COstBaseRouter::ReadMessage");

	CPortReader* reader = iPortManager->GetPortReader();
	
	if (reader)
		reader->StartRead(this);
}


void COstBaseRouter::WriteMessageL(TDesC8& aMsg, CDbgTrcSrvSession* aProtMsgListener)
{
	LOG_MSG("COstBaseRouter::WriteMessage");
	
	iSendMsgBuffer.Zero();
	iSendMsgBuffer.Append(aMsg);
			
	DoWriteMessageL(aProtMsgListener);
}

void COstBaseRouter::WriteMessageL(TDesC8& aMsg, CDbgTrcSrvSession* aProtMsgListener, TOstProtIds aProtId)
{
	LOG_MSG("COstBaseRouter::WriteMessage");	
	
	// write now, we use a fixed size array for the write message,
	// look below for the commented implementation if necessary in the future.
	iSendMsgBuffer.Zero();

	TUint16 msgLength = aMsg.Length();
	
	TUint8 version = OST_PROTOCOL_VERSION;		
	
	iSendMsgBuffer.Append(&version, sizeof(TUint8));
	iSendMsgBuffer.Append((TUint8*)&aProtId, sizeof(TUint8));
	
	TUint16 temp = msgLength; 
	if (!iIsBigEndian)
		temp = Swap2(msgLength);
		
	iSendMsgBuffer.Append((TUint8*)&temp, sizeof(TUint16));
			
	// now append the msg data
	iSendMsgBuffer.Append(aMsg);
		
	DoWriteMessageL(aProtMsgListener);
}


/*
TInt COstBaseRouter::WriteMessage(TDesC8& aMsg, CDbgTrcSrvSession* aProtMsgListener, TOstProtIds aProtId)
{	
	HBufC8* msgBuffer = HBufC8::New(aMsg.Length() + OST_HEADER_LENGTH);
	
	TUint16 msgLength = aMsg.Length();
	
	TUint8 version = OST_PROTOCOL_VERSION;		
	
	msgBuffer->Des().Append(&version, sizeof(TUint8));
	msgBuffer->Des().Append((TUint8*)&aProtId, sizeof(TUint8));
	
	TUint16 temp = msgLength; 
	if (!iIsBigEndian)
		temp = Swap2(msgLength);
		
	msgBuffer->Des().Append((TUint8*)&temp, sizeof(TUint16));
			
	// now append the msg data
	msgBuffer->Des().Append(aMsg);
	
	
}
*/

void COstBaseRouter::DoWriteMessageL(CDbgTrcSrvSession* aProtMsgListener)
{
	LOG_MSG("COstBaseRouter::DoWriteMessage");

	CPortWriter* writer = iPortManager->GetPortWriter();
	
	if(writer)
	{
		if (writer->IsBusy())
		{
			LOG_MSG("Writer busy, queuing up the write message");

			// we are already writing a message
			// so queue up this one, we only have to queue up one message for each connected client for writing.
			COstWriteMsgEntry* writeMsgEntry = COstWriteMsgEntry::NewL(iSendMsgBuffer, aProtMsgListener);
			iWriteMsgQueue.Append(writeMsgEntry);
		}
		else
		{
			// set the write listener for completing the request when the write is done
			iWriteMsgListener = aProtMsgListener;	
			writer->StartWrite(iSendMsgBuffer, this);
		}
	}
}

void COstBaseRouter::DataAvailable(TDesC8& aMsgData, TUint aLength)
{
	LOG_MSG("COstBaseRouter::DataAvailable");
	LOG_MSG2("Received bytes : %d", aLength);	

	TInt remainingBytes = aMsgData.Length();
	const TUint8* recvMsgDataPtr = aMsgData.Ptr();
	while (remainingBytes > 0)
	{	
		TInt bytesToCopy = remainingBytes;
		TInt spaceAvailable = MAX_BUF_SIZE-iRecvMsgBuffer.Length();
		if (spaceAvailable == 0) //should never happen, if this happens, then we will loose messages.
			return;
			
		if (remainingBytes > spaceAvailable)
		{
			bytesToCopy = spaceAvailable;
		}
		
		remainingBytes -= bytesToCopy;		
		iRecvMsgBuffer.Append(recvMsgDataPtr, bytesToCopy);
		recvMsgDataPtr += bytesToCopy;
							
		LOG_MSG2("Bytes copied: %d", bytesToCopy);
		LOG_MSG2("Remaining bytes : %d", remainingBytes);
					
		//
		// We could possibly get more than one message at a time, 
		// so check until we have atleast as many bytes as the OST header.
		//
		LOG_MSG2("Total bytes in the buffer : %d", iRecvMsgBuffer.Length());
		while (iRecvMsgBuffer.Length() > OST_HEADER_LENGTH)
		{
			LOG_MSG("No of received bytes > OST header length");

			const TUint8* ptr = iRecvMsgBuffer.Ptr();

			TUint8 version = ptr[VERS_FIELD_INDEX];
			TUint8 protId  = ptr[PROTID_FIELD_INDEX];
			
			// There could be some junk bytes in the data.
			// With the latest PCSuite/USB cable drivers, there seems to be some 
			// junk bytes in the USB channel. Also we can only do this simple check 
			// only at the beginning of the packet. The only check we have right now 
			// for the OST base protocol is to check for the version and the protocol id	
			if ( !( (version == OST_PROTOCOL_VERSION || version == OST_VERSION_PROTOCOL_VERSION) &&
				 (protId == EOstProtTrk || protId == EOstProtTraceCore || protId == EOstProtOstSystem || protId == EOstProtTrcActivation) ) )
			{
				LOG_MSG2("Invalid version byte: %x", version);
				LOG_MSG2("Invalid protocol byte: %x", protId);
				RemoveNonOstBytes(iRecvMsgBuffer);
			}
				
			LOG_MSG2("Total bytes in the buffer after removing non ost : %d", iRecvMsgBuffer.Length());					
			if (iRecvMsgBuffer.Length()>OST_HEADER_LENGTH)
			{
				// reset ptr just incase if we have deleted some junk bytes
				ptr = iRecvMsgBuffer.Ptr();
				TUint16 packetLength = 0;
				SwapBytes((TUint8*)&packetLength, &ptr[LENGTH_FIELD_INDEX], 2);
			
				LOG_MSG2("packet length is %d", packetLength);			

				if (iRecvMsgBuffer.Length() >= (packetLength+OST_HEADER_LENGTH))
				{
					LOG_MSG("Got one complete message");

					// got one complete message, complete the message if someone is listening for this message.
					TBool needHeader;
					CDbgTrcSrvSession* protMsgListener = iProtRegistry->GetProtListenerForProtId((TOstProtIds)protId, needHeader);
					
					if (protMsgListener)
					{
						LOG_MSG("Found a listener");

						TPtrC8 completeMessage;
						// check to see if we need to strip the header or not.
						if (needHeader)				
							completeMessage.Set(iRecvMsgBuffer.Ptr(), packetLength+OST_HEADER_LENGTH);
						else
							completeMessage.Set(iRecvMsgBuffer.Ptr()+OST_HEADER_LENGTH, packetLength);
							
						TRAPD(err, protMsgListener->MessageAvailableL(completeMessage));
						if (err != KErrNone)
						    LOG_MSG2("Failed to deliver the message: %d", err);
					}	
				
					LOG_MSG2("Deleting bytes in the recieve buffer: %d", packetLength+OST_HEADER_LENGTH);

					// now remove this message from our buffer as its already given to the listener				
					iRecvMsgBuffer.Delete(0, packetLength+OST_HEADER_LENGTH);
					
					LOG_MSG2("Remaining bytes in the recieve buffer: %d", iRecvMsgBuffer.Length());				
				}
				else
				{
					// We have more bytes than the header but we have an incomplete message.
					// So we break out here.
					break; 
				}
			}	
		}
	}
}

void COstBaseRouter::DataWriteComplete(TInt aErrCode)
{		
	LOG_MSG("COstBaseRouter::DataWriteComplete");

	if (iWriteMsgListener != NULL)
	{
		iWriteMsgListener->WriteComplete(aErrCode);
		iWriteMsgListener = NULL;
	}
	else
	{
		LOG_MSG("Invalid write message listener, should never happen");
	}	
	
	if (iWriteMsgQueue.Count() > 0)
	{
		LOG_MSG("Message found in write queue");
		
		COstMessage* ostMsg = iWriteMsgQueue[0]->iMessage;
		iWriteMsgListener = iWriteMsgQueue[0]->iWriteMsgListener;
		HBufC8* msg = ostMsg->iMsgBuffer;
		
		CPortWriter* writer = iPortManager->GetPortWriter();
		if(writer)
			writer->StartWrite(*msg, this);
		
		// now remove the message from the queue
		SafeDelete(iWriteMsgQueue[0]);			
		iWriteMsgQueue.Remove(0);		
	}
}

void COstBaseRouter::GetPortConfig(TDes8& aConfigDes)
{
	LOG_MSG("COstBaseRouter::GetPortConfig");

	iPortManager->GetPortConfig(aConfigDes);
}

TInt COstBaseRouter::SetPortConfig(TDesC8& aConfigDes)
{
	LOG_MSG("COstBaseRouter::SetPortConfig");

	return iPortManager->SetPortConfig(aConfigDes);
}

TInt COstBaseRouter::OpenCommPortL()
{
	LOG_MSG("COstBaseRouter::OpenCommPort");

	return iPortManager->OpenPortL();
}

TInt COstBaseRouter::CloseCommPort()
{
	LOG_MSG("COstBaseRouter::CloseCommPort");
	
	return iPortManager->ClosePort();
}


void COstBaseRouter::SwapBytes(TUint8* aTrgtData, const TUint8* aSrcData, TInt aLength)
{	
	LOG_MSG("COstBaseRouter::SwapBytes");
	
	if (iIsBigEndian)
	{
		Mem::Copy(aTrgtData, aSrcData, aLength);
	}
	else
	{
		for (int i=aLength-1, j=0; i>=0; i--, j++)
			aTrgtData[j] = aSrcData[i];
	}		
}


void COstBaseRouter::RemoveNonOstBytes(TDes8& aMsgBuffer)
{
	LOG_MSG("COstBaseRouter::RemoveNonOstBytes");	
	// We need to check for non OST bytes only in the beginning of the packet.
	// The only check we have right now for the OST base protocol
	// is to check for the version and the protocol id	
	const TUint8* msgDataPtr = aMsgBuffer.Ptr(); 				
	// look for the version byte..
	// if found, bail out and check for protocol byte
	TUint length = aMsgBuffer.Length();
	LOG_MSG2("Total bytes in the buffer: %d", length);
	for (TInt i=VERS_FIELD_INDEX; i<length; i++)
	{			
		if (msgDataPtr[VERS_FIELD_INDEX] == OST_PROTOCOL_VERSION ||
			msgDataPtr[VERS_FIELD_INDEX] == OST_VERSION_PROTOCOL_VERSION)	
		{
			// If we have more than one byte and the first byte seems to be the version byte
			// then check to see whether the second byte is the protocol byte or not.
			// if not, then delete the two bytes and start looking for version byte in the remaining bytes
			if (aMsgBuffer.Length()>1)
			{
				if (msgDataPtr[PROTID_FIELD_INDEX] == EOstProtTrk || 
					msgDataPtr[PROTID_FIELD_INDEX] == EOstProtTraceCore  ||
					msgDataPtr[PROTID_FIELD_INDEX] == EOstProtOstSystem ||
					msgDataPtr[PROTID_FIELD_INDEX] == EOstProtTrcActivation)				
				{
					LOG_MSG("Found a valid packet");
					break;					
				}					
				else
				{
					// we didn't find the version byte and the protocol byte together
					// so delete the two bytes
					LOG_MSG2("Deleting junk bytes, unexpected version: %x", msgDataPtr[VERS_FIELD_INDEX]);
					LOG_MSG2("Deleting junk bytes, unexpected protocol id: %x", msgDataPtr[PROTID_FIELD_INDEX]);

					aMsgBuffer.Delete(VERS_FIELD_INDEX, 2);
					i++; //deleting more than one byte, so increment one more time here.
				}					
			}
			else
			{
				// Special case handling when there is only one remaining byte 
				// and that byte happens to be the version byte
				// This could be an invalid byte from out of protocol data, just happens to be the version byte.
				// So delete this byte as well just so that we don't treat this byte as the version byte by mistake.
				LOG_MSG2("Deleting one remaining byte, unexpected version: %x", msgDataPtr[VERS_FIELD_INDEX]);
				aMsgBuffer.Delete(VERS_FIELD_INDEX, 1);			
			}
		}
		else
		{
			// if the first byte is not the version byte, delete it
			// it could be out of protocol data, we just need throw away
			LOG_MSG2("Deleting junk byte, unexpected version: %x", msgDataPtr[VERS_FIELD_INDEX]);
			aMsgBuffer.Delete(VERS_FIELD_INDEX, 1);
		}
	}		
}