/*
* Copyright (c) 1998-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: 
* Implementation of the classes that import and export plain text.
*
*/


#include "TXTSTD.H"
#include "TXTPLAIN.H"
#include "charconv.h"

TPlainTextIOState::	TPlainTextIOState(const CPlainText::TImportExportParam& aParam,
									  CPlainText::TImportExportResult& aResult,
									  RWriteStream& aOutput,RReadStream& aInput):
	iParam(aParam),
	iResult(aResult),
	iOutput(aOutput),
	iInput(aInput),
	iConverter(NULL),
	iSwapInput(FALSE),
	iCheckByteOrder(FALSE)
	{
	aResult = CPlainText::TImportExportResult();  // zero output counters; aResult may be re-used.
	}

TText TPlainTextIOState::ReadRawCharL()
	{
	TText c;
	if (iParam.iInputInternal)
		iInput.ReadL((TUint8*)&c,sizeof(TText));
	else
		c = iInput.ReadUint16L();
	if (iSwapInput)
		c = (TText)(((c << 8) & 0xFF00) | ((c >> 8) & 0xFF));
	if (iCheckByteOrder)
		{
		if (c == CEditableText::EReversedByteOrderMark)
			{
			c = CEditableText::EByteOrderMark;
			iSwapInput = !iSwapInput;
			}
		iCheckByteOrder = FALSE;
		}
	iResult.iInputChars++;
	return c;
	}

void TPlainTextIOState::WriteRawCharL(TText aChar)
	{
	if (iResult.iOutputChars < iParam.iMaxOutputChars)
		{
		if (iParam.iOutputInternal)
			iOutput.WriteL((TUint8*)&aChar,sizeof(TText));
		else
			iOutput.WriteUint16L(aChar);
		iResult.iOutputChars++;
		}
	}

CPlainTextConverter* CPlainTextConverter::NewLC()
	{
	CPlainTextConverter* c = new(ELeave) CPlainTextConverter;
	CleanupStack::PushL(c);
	c->iConversionBuffer = new(ELeave) TUint8[EConversionBufferSize];
	return c;
	}

CPlainTextConverter::~CPlainTextConverter()
	{
	delete iConverter;
	delete [] iConversionBuffer;
	}

/*
Prepare to convert between Unicode and a foreign encoding.
If aSample is non-null it can be used to guess the foreign encoding, but only if iParam.iGuessForeignEncoding is true.
*/
void CPlainTextConverter::PrepareToConvertL(TPlainTextIOState& aState,const TDesC8* aSample)
	{
	RFs rfs;

	iConverter = CCnvCharacterSetConverter::NewL();
	if (aState.iParam.iFileSession == NULL)
		{
		TInt error = rfs.Connect();
		User::LeaveIfError(error);
				
		CleanupClosePushL(rfs);
		}
	else
		rfs = *aState.iParam.iFileSession;

	TUint foreign_encoding = aState.iParam.iForeignEncoding;
	
	// Try to guess the foreign encoding.
	if (aSample && aState.iParam.iGuessForeignEncoding)
		{
		CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* charsets =
			CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(rfs);
		TInt confidence = 0;
		CCnvCharacterSetConverter::AutoDetectCharacterSetL(confidence,foreign_encoding,*charsets,*aSample);
		CleanupStack::PopAndDestroy(charsets);
		if (confidence < 50)
			User::Leave(KErrNotSupported);
		}

	if (iConverter->PrepareToConvertToOrFromL(foreign_encoding,rfs) != CCnvCharacterSetConverter::EAvailable)
		User::Leave(KErrNotSupported);
	aState.iResult.iForeignEncoding = foreign_encoding;
	if (aState.iParam.iFileSession == NULL)
		{
		CleanupStack::Pop(); // rfs
		rfs.Close();
		}
	}

void TPlainTextWriter::TranslateL(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,
								  RWriteStream& aOutput,RReadStream& aInput)
	{
	TPlainTextWriter writer(aParam,aResult,aOutput,aInput);
	writer.TranslateHelperL();
	}

TPlainTextWriter::TPlainTextWriter(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,
								   RWriteStream& aOutput,RReadStream& aInput):
	TPlainTextIOState(aParam,aResult,aOutput,aInput),
	iLineLength(0),
	iLineBuffer(NULL),
	iMaxLineBufferLength(0)
	{
	}

void TPlainTextWriter::TranslateHelperL()
	{
	if (iParam.iForeignEncoding)
		{
		iConverter = CPlainTextConverter::NewLC();
		iConverter->PrepareToConvertL(*this,NULL);
		}

	if (iParam.iOrganisation == CPlainText::EOrganiseByLine)
		iMaxLineLength = iParam.iMaxLineLength;
	else
		iMaxLineLength = KMaxTInt; // when exporting by paragraph, the wrapping width has no effect
	if (iMaxLineLength <= 0)
		iMaxLineLength = KMaxTInt;
	iLineLength = 0;
	if (iMaxLineLength < KMaxTInt)
		iMaxLineBufferLength = iMaxLineLength;
	else if (iParam.iForeignEncoding)
		iMaxLineBufferLength = EDefaultLineBufferSize;
	if (iMaxLineBufferLength)
		iLineBuffer = new(ELeave) TText[iMaxLineBufferLength];
	else
		iLineBuffer = NULL;
	CleanupStack::PushL(iLineBuffer);
	TRAPD(error,TranslateToEofL());
	if (error == KErrEof)
		error = KErrNone;
	if (error == KErrNone)
		{
		FlushL();
		iOutput.CommitL();
		}
	CleanupStack::Pop(iLineBuffer);
	delete [] iLineBuffer;
	if (iConverter)
		CleanupStack::PopAndDestroy(iConverter);
	User::LeaveIfError(error);
	}

void TPlainTextWriter::TranslateToEofL()
	{
	while (!Finished())
		{
		TText c = ReadRawCharL();
		switch (c)
			{
			// Write a CR-LF at a forced line break if organising by line.
			case CEditableText::ELineBreak:
				if (iParam.iOrganisation == CPlainText::EOrganiseByLine)
					{
					FlushL();
					WriteNewLineL();
					}
				else
					WriteCharL(c);
				break;

			// Write a CR-LF at the end of the paragraph, then an extra one if lines are split by CR-LFs.
			case CEditableText::EParagraphDelimiter:
				FlushL();
				WriteNewLineL();
				if (iParam.iOrganisation == CPlainText::EOrganiseByLine)
					WriteNewLineL();
				break;

			default:
				WriteCharL(c);
			}
		}
	}

void TPlainTextWriter::FlushL()
	{
	if (iLineBuffer)
		WriteAndConvertL(iLineBuffer,iLineLength);
	iLineLength = 0;
	}

void TPlainTextWriter::WriteCharL(TText aChar)
	{
	if (iLineBuffer)
		{
		if (iLineLength >= iMaxLineBufferLength)
			{
			int linebreak = iMaxLineBufferLength;
			int stripped_linebreak = iMaxLineBufferLength;

			if (iLineLength >= iMaxLineLength)
				{
				for (linebreak = iMaxLineLength; linebreak > 0; linebreak--)
					if (iLineBuffer[linebreak - 1] == ' ')
						break;
				if (linebreak == 0)
					linebreak = iMaxLineLength;

				// Strip a single trailing space if any; it is added when text is imported.
				stripped_linebreak = linebreak;
				if (iLineBuffer[linebreak - 1] == ' ')
					stripped_linebreak = linebreak - 1;
				}

			WriteAndConvertL(iLineBuffer,stripped_linebreak);
			if (iLineLength >= iMaxLineLength)
				WriteNewLineL();
			int i = linebreak;
			int j = 0;
			while (i < iMaxLineBufferLength)
				iLineBuffer[j++] = iLineBuffer[i++];
			iLineLength = j;
			}
		iLineBuffer[iLineLength++] = aChar;
		}
	else
		WriteRawCharL(aChar);
	}

void TPlainTextWriter::WriteNewLineL()
	{
	WriteAndConvertL(_S("\x0d\x0a"),2);
	}

void TPlainTextWriter::WriteAndConvertL(const TText* aText,TInt aLength)
	{
	if (iConverter)
		{
		while (aLength > 0)
			{
			TPtrC source(aText,aLength);
			TPtr8 dest(iConverter->iConversionBuffer,CPlainTextConverter::EConversionBufferSize);
			int remainder = iConverter->iConverter->ConvertFromUnicode(dest,source);
			if (remainder < 0)
				User::Leave(KErrCorrupt);
			int available = iParam.iMaxOutputChars - iResult.iOutputChars;
			if (available < dest.Length())
				dest.SetLength(available);
			if (dest.Length() > 0)
				{
				iOutput.WriteL(dest);
				iResult.iOutputChars += dest.Length();
				}
			int converted = aLength - remainder;
			aText += converted;
			aLength -= converted;
			}
		}
	else
		{
		while (aLength-- > 0)
			WriteRawCharL(*aText++);
		}
	}

TPlainTextReader::TPlainTextReader(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,
								   RWriteStream& aOutput,RReadStream& aInput):
	TPlainTextIOState(aParam,aResult,aOutput,aInput),
	iInputBuffer(NULL),
	iInputLength(0),
	iInputPos(0),
	iConversionState(CCnvCharacterSetConverter::KStateDefault)
	{
	iCheckByteOrder = TRUE;
	}

void TPlainTextReader::TranslateL(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,
								  RWriteStream& aOutput,RReadStream& aInput)
	{
	TPlainTextReader reader(aParam,aResult,aOutput,aInput);
	if(reader.iParam.iOrganisation == CPlainText::EOrganiseByLine)
		{
		TLineTextWriter txtWriter(reader);
		TSLBTransaltor slbTranslator(txtWriter);
		reader.TranslateHelperL(slbTranslator);
		}
	else
		{
		TParagraphTextWriter txtWriter(reader);
		TSLBTransaltor slbTranslator(txtWriter);
		reader.TranslateHelperL(slbTranslator);
		}
	}

void TPlainTextReader::TranslateHelperL(TSLBTransaltor& aSLBTranslator)
	{
	if (iParam.iForeignEncoding || iParam.iGuessForeignEncoding)
		{
		iConverter = CPlainTextConverter::NewLC();
		iInputBuffer = new(ELeave) TText[EInputBufferSize];
		CleanupStack::PushL(iInputBuffer);
		}
	else
		iInputBuffer = NULL;
	TRAPD(error,TranslateToEofL(aSLBTranslator));
	if (error == KErrEof)
		error = KErrNone;
	if (error == KErrNone)
		iOutput.CommitL();
	if (iConverter)
		{
		CleanupStack::Pop(iInputBuffer);
		delete [] iInputBuffer;
		CleanupStack::PopAndDestroy(iConverter);
		}
	User::LeaveIfError(error);
	}

void TPlainTextReader::TranslateToEofL(TSLBTransaltor& aSLBTranslator)
	{
	while(!Finished())
		{
		TText c = ReadAndConvertL();
		aSLBTranslator.ProcessL(c);
		}
	aSLBTranslator.FlushL();
	}

TText TPlainTextReader::ReadAndConvertL()
	{
	// Read EConversionBufferSize bytes into a conversion buffer (iConversionBuffer).
	// Using CharConv convert this into unicode and place in a destination buffer (dest).
	// This may result in some bytes that cannot be converted (remainder) as that
	// character encoding is truncated.
	// This remainder is then moved to the begining of the conversion buffer and more
	// data read in after it, in effect untruncating that last character.
	// Before this next read takes place the next converted unicode character is returned
	// until the destination buffer positional pointers reach the end where more data is
	// required for processing.
	//  
	if (iConverter && iInputBuffer)
		{
		if (iInputPos >= iInputLength)
			{
			/*
			Attempt to read more foreign characters if there are less than 20,
			which is the current maximum length of a multibyte character sequence for CHARCONV.
			Use MStreamBuf::ReadL, which doesn't leave on EOF, rather than RReadStream::ReadL,
			which does, and doesn't tell you how much was actually read.
			*/
			if (iConverter->iConversionBufferLength < 20)
				iConverter->iConversionBufferLength +=
					iInput.Source()->ReadL(iConverter->iConversionBuffer + iConverter->iConversionBufferLength,
										   CPlainTextConverter::EConversionBufferSize - iConverter->iConversionBufferLength);

			// Create the converter late so we have a sample of foreign text for auto-detection of the encoding.
			if (!iConverter->iConverter)
				{
				TPtrC8 sample(iConverter->iConversionBuffer,iConverter->iConversionBufferLength);
				iConverter->PrepareToConvertL(*this,&sample);
				}

			// Translate from the foreign encoding to Unicode.
			TPtr dest(iInputBuffer,0,EInputBufferSize);
			TPtrC8 source(iConverter->iConversionBuffer,iConverter->iConversionBufferLength);
			int remainder = iConverter->iConverter->ConvertToUnicode(dest,source,iConversionState);
			if (remainder < 0)
				User::Leave(KErrCorrupt);

			// Move the remaining foreign characters if any to the start of the buffer
			// so that on the next read it can be joined with its truncated part.
			for (int i = 0, j = iConverter->iConversionBufferLength - remainder; i < remainder; ++i, ++j)
				iConverter->iConversionBuffer[i] = iConverter->iConversionBuffer[j];
			iConverter->iConversionBufferLength = remainder;

			iInputPos = 0;
			iInputLength = dest.Length();
			if (iInputLength == 0)
				User::Leave(KErrEof);
			}
		iResult.iInputChars++;
		return iInputBuffer[iInputPos++];
		}
	else
		return ReadRawCharL();
	}

/**
The method processes the imput characters, writing them to the output, but skipping 
the picture characters (CEditableText::EPictureCharacter).
The method is not called directly and should not be called. It implements 
MOutputChar::OutputCharL(TChar aChar) and is called from TParagraphTextWriter and 
TLineTextWriter implementations.
@param aChar Character to be processed.
*/
void TPlainTextReader::OutputCharL(TText aChar)
	{
	switch(aChar)
		{
		case CEditableText::EByteOrderMark :
			// leading byte order marks are ignored
			if(iResult.iInputChars > 1)
				{
				WriteRawCharL(aChar);
				}
			break;
		case CEditableText::EPictureCharacter:
			//Picture characters are ignored because they would cause ETEXT to panic when it attempted to find
			//the picture corresponding to the character.
			break;
		default:
			WriteRawCharL(aChar);
			break;
		}
	}