// Copyright (c) 2001-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 "TCharsetvCard.h"

// System includes

#include <versit.h>

#include <f32file.h>

#include <e32test.h>

#include <charconv.h>

// Literal constants

_LIT(KTestName, "TCharSetvCard");

// Globals

static RFs					TheFsSession;

//static CTrapCleanup*		TheCleanup;

static RTest				TheTest(KTestName);

static void FileCleanup(TAny * aFileMan)

	{

	CFileMan* FileMan = (CFileMan*)aFileMan;

	FileMan->RmDir(_L("C:\\OutputTestvCards\\"));

	}

static void DoTestsL()

	{

	CFileMan* FileMan = CFileMan::NewL(TheFsSession);

	CleanupStack::PushL(FileMan);

	CleanupStack::PushL(TCleanupItem(FileCleanup, FileMan));

	CVersitCardTest* test = CVersitCardTest::NewLC();

	test->StartTestsL();

	CleanupStack::PopAndDestroy(3, FileMan); // filecleanup, test

	}

/**

@SYMTestCaseID PIM-TCHARSETVCARD-0001

*/	

GLDEF_C TInt E32Main()

	{

	TTime startTime;

	startTime.UniversalTime();

	__UHEAP_MARK;

	CTrapCleanup* TheCleanup = CTrapCleanup::New();

	if	(!TheCleanup)

		return KErrNoMemory;

	if	(TheFsSession.Connect() < KErrNone)

		return KErrGeneral;

	TheTest.Start(_L("@SYMTestCaseID PIM-TCHARSETVCARD-0001 TCharSetvCard"));

	TRAPD(error, DoTestsL());

	TheTest(error == KErrNone);

	TheTest.End();

	TheTest.Close();

	TheFsSession.Close();

	delete TheCleanup;

	__UHEAP_MARKEND;

	TTime finishTime;

	finishTime.UniversalTime();

	TReal elapsed = (TReal)finishTime.MicroSecondsFrom(startTime).Int64();

	TheTest.Printf(_L("Elapsed time: %.4f\n"), elapsed/1000000);

	return KErrNone;

	}

//

// ------> CVersitCardTest (source)

//

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

CVersitCardTest::~CVersitCardTest()

	{

	delete iDirectoryScanner;

	delete iArrayOfCharacterSetsAvailable;

	}

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

void CVersitCardTest::ConstructL()

	{

	iDirectoryScanner = CDirScan::NewL(TheFsSession);

	iArrayOfCharacterSetsAvailable = CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableL(TheFsSession);

	}

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

CVersitCardTest* CVersitCardTest::NewLC()

	{

	CVersitCardTest* self = new(ELeave) CVersitCardTest;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//

//

//

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

void CVersitCardTest::StartTestsL()

	{

/*

	CParserVCard* parser;

	parser = new(ELeave) CParserVCard();

	CleanupStack::PushL(parser);

	InternalizeCardL(_L("C:\\Testvcards\\Encoded\\2.vcf"), *parser, CVersitParser::EUSAsciiCharSet, CVersitParser::ENoEncoding);

	ExternalizeCardL(_L("C:\\2.vcf"), *parser, CVersitParser::EUSAsciiCharSet, CVersitParser::ENoEncoding);

	CleanupStack::PopAndDestroy(); // parser

	return;

	parser = new(ELeave) CParserVCard();

	CleanupStack::PushL(parser);

	InternalizeCardL(_L("C:\\Testvcards\\Various\\9.vcf"), *parser, CVersitParser::EISO88591CharSet, CVersitParser::ENoEncoding);

	//ExternalizeCardL(_L("C:\\vCard-jis.vcf"), *parser, CVersitParser::EJISCharSet, CVersitParser::ENoEncoding);

	CleanupStack::PopAndDestroy(); // parser

	return;

	CParserVCard* parser;

	parser = new(ELeave) CParserVCard();

	CleanupStack::PushL(parser);

	InternalizeCardL(_L("C:\\Testvcards\\Encoded\\1.vcf"), *parser, CVersitParser::EISO88591CharSet, CVersitParser::ENoEncoding);

	ExternalizeCardL(_L("C:\\vCard-shiftjis.vcf"), *parser, CVersitParser::EShiftJISCharSet, CVersitParser::ENoEncoding);

	CleanupStack::PopAndDestroy(); // parser

	// Read ISO-1 -> Write JIS

	parser = new(ELeave) CParserVCard();

	CleanupStack::PushL(parser);

	InternalizeCardL(_L("C:\\Testvcards\\Encoded\\1.vcf"), *parser, CVersitParser::EISO88591CharSet, CVersitParser::ENoEncoding);

	ExternalizeCardL(_L("C:\\vCard-jis.vcf"), *parser, CVersitParser::EJISCharSet, CVersitParser::ENoEncoding);

	CleanupStack::PopAndDestroy(); // parser

	// Read ShiftJIS -> Write ISO-1

	parser = new(ELeave) CParserVCard();

	CleanupStack::PushL(parser);

	InternalizeCardL(_L("C:\\vCard-shiftjis.vcf"), *parser, CVersitParser::EShiftJISCharSet, CVersitParser::ENoEncoding);

	ExternalizeCardL(_L("C:\\vCard-iso1-from-shiftjis.vcf"), *parser, CVersitParser::EISO88591CharSet, CVersitParser::ENoEncoding);

	CleanupStack::PopAndDestroy(); // parser

	// Read JIS -> Write ISO-1

	parser = new(ELeave) CParserVCard();

	CleanupStack::PushL(parser);

	InternalizeCardL(_L("C:\\vCard-jis.vcf"), *parser, CVersitParser::EJISCharSet, CVersitParser::ENoEncoding);

	ExternalizeCardL(_L("C:\\vCard-iso1-from-jis.vcf"), *parser, CVersitParser::EISO88591CharSet, CVersitParser::ENoEncoding);

	CleanupStack::PopAndDestroy(); // parser

	*/

	_LIT(KTestDataDirectory, "Z:\\TestvCards\\");

	_LIT(KvCardExtension, ".vCF");

	iDirectoryScanner->SetScanDataL(KTestDataDirectory, KEntryAttDir, ESortByExt|EAscending, CDirScan::EScanUpTree);

	CDir* dirList = NULL;

	// Fetch next dir

	FOREVER

		{

		iDirectoryScanner->NextL(dirList);

		if	(!dirList)

			break;

		CleanupStack::PushL(dirList);

		TPtrC path(iDirectoryScanner->FullPath());

		const TInt count = dirList->Count();

		for(TInt i=0; i<count; i++)

			{

			const TEntry& entry = (*dirList)[i];

			TFileName file(path);

			file += entry.iName;

			// Check for vCards

			TParsePtrC parser(file);

			if	(parser.Ext().CompareF(KvCardExtension) != 0)

				continue;

			// We've got a vCard so internalize it

			CParserVCard* cardParser = CParserVCard::NewL();

			CleanupStack::PushL(cardParser);

			// Internalize & externalize the card	

			TheTest.Next(file);

			TheTest.Start(KNullDesC);

			TRAPD(err, InternalizeAndExternalizeCardL(file, *cardParser));

			TheTest.End();

			CleanupStack::PopAndDestroy(); // cardParser

			// Handling for invalid cards

			if	(err < KErrNone)

				{

				if	(file.Find(_L("\\invalid\\")) >= KErrNone)

					{

					// This was an invalid cards, but it's ok for versit

					// to leave if this is the case...

					continue;

					}

				}

			}

		CleanupStack::PopAndDestroy(); // dirList

		}

	}

//

//

//

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

void CVersitCardTest::InternalizeAndExternalizeCardL(const TDesC& aFile, CParserVCard& aParser) const

	{

	_LIT(KSpacer, " - ");

	//_LIT(KCharset, "CharSet=");

	//_LIT(KEncoding, "Encoding=");

	_LIT(KTestOutputDirPrefix, "Output");

	TParsePtrC outputDirParser(aFile);

	TFileName outputDir;

	// Make output directory

	outputDir += outputDirParser.Drive();

	outputDir.Append('\\');

	outputDir += KTestOutputDirPrefix;

	{

	TInt length = outputDir.Length();

	outputDir += outputDirParser.Path();

	outputDir.Delete(length, 1);

	outputDir += outputDirParser.Name();

	outputDir.Append('\\');

	TheFsSession.MkDirAll(outputDir);

	}

	{

	// Guess the charset of the vCard

	TUint charConvCharSet = AutoDetectCharacterSetL(TheFsSession, aFile);

	// Map to versit charset

	Versit::TVersitCharSet charSet = MapCharConvCharSetToVersitCharSet(charConvCharSet);

	TFileName testName(aFile);

	testName += _L(" [");

	testName += CharsetAsDescriptor(charSet);

	testName += _L("]");

	// Dump test title

	TheTest.Next(testName);

	// Internalize it

	InternalizeCardL(aFile, aParser, charSet, Versit::ENoEncoding);

	}

	TInt countCharSets = Versit::EJISCharSet;

	for(TInt i=Versit::EUSAsciiCharSet; i<=countCharSets; i++)

		{

		// Get charset

		Versit::TVersitCharSet charSet = static_cast<Versit::TVersitCharSet>(i);

		TInt countEncodings = Versit::EBase64Encoding;

		for(TInt j=Versit::ENoEncoding; j<=countEncodings; j++)

			{

			Versit::TVersitEncoding encoding = static_cast<Versit::TVersitEncoding>(j);

			// Generate filename

			TFileName file(outputDir);

			file += CharsetAsDescriptor(charSet);

			file += KSpacer;

			file += EncodingAsDescriptor(encoding);

			file += outputDirParser.Ext();

			// Write test

			{

			TParsePtrC testNameParser(file);

			TName name(testNameParser.NameAndExt());

			name.Insert(0, _L("\t"));	

			TheTest.Next(name);

			}

			// Externalize 

			ExternalizeCardL(file, aParser, charSet, encoding);

			}

		}

	}

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

//void CVersitCardTest::InternalizeCardL(const TDesC& aFile, CParserVCard& aParser, CVersitParser::TVersitCharSet aCharSet, CVersitParser::TVersitEncoding aEncoding) const

void CVersitCardTest::InternalizeCardL(const TDesC& aFile, CParserVCard& aParser, Versit::TVersitCharSet aCharSet, Versit::TVersitEncoding aEncoding) const

//

//	Internalize the specified file

//

	{

	TInt pos = 0;

	RFile file;

	User::LeaveIfError(file.Open(TheFsSession, aFile, EFileRead));

	CleanupClosePushL(file);

	// Set defaults

	aParser.SetDefaultEncoding(aEncoding);

	aParser.SetDefaultCharSet(aCharSet);

	// Read from the file

	static_cast<CVersitParser&>(aParser).InternalizeL(file, pos);

	CleanupStack::PopAndDestroy(); // file

	}

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

//void CVersitCardTest::ExternalizeCardL(const TDesC& aFile, CParserVCard& aParser, CVersitParser::TVersitCharSet aCharSet, CVersitParser::TVersitEncoding aEncoding) const

void CVersitCardTest::ExternalizeCardL(const TDesC& aFile, CParserVCard& aParser, Versit::TVersitCharSet aCharSet, Versit::TVersitEncoding aEncoding) const

//

//	Externalize the specified file

//

	{

	RFile file;

	User::LeaveIfError(file.Replace(TheFsSession, aFile, EFileWrite));

	CleanupClosePushL(file);

	// Set defaults

	aParser.SetDefaultEncoding(aEncoding);

	aParser.SetDefaultCharSet(aCharSet);

	// Write from the file

	static_cast<CVersitParser&>(aParser).ExternalizeL(file);

	CleanupStack::PopAndDestroy(); // file

	}

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

//const TDesC& CVersitCardTest::CharsetAsDescriptor(CVersitParser::TVersitCharSet aCharSet)

const TDesC& CVersitCardTest::CharsetAsDescriptor(Versit::TVersitCharSet aCharSet)

	{

	_LIT(KVersitCharSetASCII,		"ASCII");

	_LIT(KVersitCharSetUTF8,		"UTF8");

	_LIT(KVersitCharSetUTF7,		"UTF7");

	_LIT(KVersitCharSetISO_8859_1,	"ISO-8859-1");

	_LIT(KVersitCharSetISO_8859_2,	"ISO-8859-2");

	_LIT(KVersitCharSetISO_8859_4,	"ISO-8859-4");

	_LIT(KVersitCharSetISO_8859_5,	"ISO-8859-5");

	_LIT(KVersitCharSetISO_8859_7,	"ISO-8859-7");

	_LIT(KVersitCharSetISO_8859_9,	"ISO-8859-9");

	_LIT(KVersitCharSetISO_8859_3,	"ISO-8859-3");

	_LIT(KVersitCharSetISO_8859_0,	"ISO-8859-0");

	_LIT(KVersitCharSetGB_231280,	"GB-231280");

	_LIT(KVersitCharSetGBK,			"GBK");

	_LIT(KVersitCharSetBIG5,		"BIG5");

	_LIT(KVersitCharSetISO_2022JP,	"ISO-2022JP");

	_LIT(KVersitCharSetEUCJP,		"EUCJP");

	_LIT(KVersitCharSetShiftJIS,	"ShiftJIS");

	_LIT(KVersitCharSetJIS,			"JIS");

	//

	switch(aCharSet)

		{

	default:

	case Versit::EUSAsciiCharSet:

		return KVersitCharSetASCII;

	case Versit::EUTF8CharSet:

		return KVersitCharSetUTF8;

	case Versit::EUTF7CharSet:

		return KVersitCharSetUTF7;

	case Versit::EISO88591CharSet:

		return KVersitCharSetISO_8859_1;

	case Versit::EISO88592CharSet:

		return KVersitCharSetISO_8859_2;

	case Versit::EISO88594CharSet:

		return KVersitCharSetISO_8859_4;

	case Versit::EISO88595CharSet:

		return KVersitCharSetISO_8859_5;

	case Versit::EISO88597CharSet:

		return KVersitCharSetISO_8859_7;

	case Versit::EISO88599CharSet:

		return KVersitCharSetISO_8859_9;

	case Versit::EISO88593CharSet:

		return KVersitCharSetISO_8859_3;

	case Versit::EISO885910CharSet:

		return KVersitCharSetISO_8859_0;

	case Versit::EGB231280CharSet:

		return KVersitCharSetGB_231280;

	case Versit::EGBKCharSet:

		return KVersitCharSetGBK;

	case Versit::EBIG5CharSet:

		return KVersitCharSetBIG5;

	case Versit::EISO2022JPCharSet:

		return KVersitCharSetISO_2022JP;

	case Versit::EEUCJPCharSet:

		return KVersitCharSetEUCJP;

	case Versit::EShiftJISCharSet:

		return KVersitCharSetShiftJIS;

	case Versit::EJISCharSet:

		return KVersitCharSetJIS;

		}

	}

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

const TDesC& CVersitCardTest::EncodingAsDescriptor(Versit::TVersitEncoding aEncoding)

	{

	_LIT(KVersitEncodingNone,	"None");

	_LIT(KVersitEncodingQP,		"Quoted Printable");

	_LIT(KVersitEncodingBase64, "Base64");

	//

	switch(aEncoding)

		{

	default:

	case Versit::ENoEncoding:

		return KVersitEncodingNone;

	case Versit::EQuotedPrintableEncoding:

		return KVersitEncodingQP;

	case Versit::EBase64Encoding:

		return KVersitEncodingBase64;

		}

	}

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

TUint CVersitCardTest::AutoDetectCharacterSetL(RFs& aFsSession, const TDesC& aFile) const

	{

	_LIT8(KCharset, "CHARSET");

	_LIT8(KBase64, "BASE64");

	RFile file;

	User::LeaveIfError(file.Open(aFsSession, aFile, EFileRead));

	// Read a bit of the file

	TBuf8<400> sample;

	file.Read(sample); // ignore error

	file.Close();

	const TInt length = sample.Length();

	if	(!length)

		User::Leave(KErrUnderflow);

	// First of all, try and find a charset identifier in the vCard...

	TInt pos = sample.Find(KCharset);

	if	(pos >= KErrNone)

		{

		// There is a charset line, so read until we hit a = 

		while(pos < length && sample[pos] != '=')

			pos++;

		// Did we find the '=' ?

		if	(pos < length && sample[pos] == '=')

			{

			// Yes, so mark the start

			TInt start = ++pos;

			// There is a charset line, so read until we hit a : or a ;

			while(pos < length && !(sample[pos] == ';' || sample[pos] == ':'))

				pos++;

			// Did we find the ':' or ';' ?

			if	(pos < length && sample[pos] == ';' || sample[pos] == ':')

				{

				// We now have a range for the charset identifier

				TPtrC8 pCharset(sample.Mid(start, pos-start));

				// Attempt to ask CharConv to identify it...

				CCnvCharacterSetConverter* charConv = CCnvCharacterSetConverter::NewLC();

				TUint charset = charConv->ConvertStandardNameOfCharacterSetToIdentifierL(pCharset, TheFsSession);

				CleanupStack::PopAndDestroy(); // charConv

				// Charconv returns 0 if it doesn't recognize it

				if	(charset)

					return charset;

				}

			}

		}

	// See if we can find a BASE64 marker... if we can then ignore everything

	// before this point in the stream, since it confuses CharConv

	pos = sample.Find(KBase64);

	if	(pos >= KErrNone)

		{

		// Snip off anything after this point

		sample = sample.Left(pos);

		}

	// Attempt to detect charset

	TUint charset = 0;

	TInt confidence = 0;

	CCnvCharacterSetConverter::AutoDetectCharacterSetL(confidence, charset, *iArrayOfCharacterSetsAvailable, sample);

	if	(!confidence)

		return KCharacterSetIdentifierAscii;

	return charset;

	}

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

Versit::TVersitCharSet CVersitCardTest::MapCharConvCharSetToVersitCharSet(TUint aCharConvCharSet)

	{

	switch(aCharConvCharSet)

		{

	case KCharacterSetIdentifierAscii:

	case KCharacterSetIdentifierIso88596:

	case KCharacterSetIdentifierIso88598:

	case KCharacterSetIdentifierCodePage1252:

		return Versit::EUSAsciiCharSet;

	case KCharacterSetIdentifierUtf8: