/*
* 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 the License "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 "SyntaxTest.h"
#include "wtlscert.h"
#include "t_input.h"

TInt CSyntaxTest::nInstances = 0;
_LIT(KSyntaxLogFile, "X509SyntaxLog.txt");
_LIT(KPathStart, "<path>");

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CTestAction* CSyntaxTest::NewL(RFs& aFs, CConsoleBase& aConsole, 
		Output& aOut, const TTestActionSpec& aTestActionSpec)
	{
	CTestAction* self = CSyntaxTest::NewLC(aFs, aConsole, aOut, aTestActionSpec);
	CleanupStack::Pop(self);
	return self;
	}

CTestAction* CSyntaxTest::NewLC(RFs& aFs, CConsoleBase& aConsole, 
		Output& aOut, const TTestActionSpec& aTestActionSpec)
	{
	CSyntaxTest* self = new(ELeave) CSyntaxTest(aFs, aConsole, aOut);
	CleanupStack::PushL(self);
	self->ConstructL(aTestActionSpec);
	return self;
	}

CSyntaxTest::CSyntaxTest(RFs& aFs, 
								 CConsoleBase& aConsole,
								 Output& aOut)
: CTestAction(aConsole, aOut), iFs(aFs)
	{
	nFileNumber = 0;
	}

CSyntaxTest::~CSyntaxTest(void)
	{
	delete iDirList;
	delete iSyntaxOut;
	iLogFile.Close();
	delete iWriter;
	iExpectedResults->ResetAndDestroy();
	delete iExpectedResults;
	};

void CSyntaxTest::ConstructL(const TTestActionSpec& aTestActionSpec)
	{
	CTestAction::ConstructL(aTestActionSpec);

	if(nInstances==0)
		{
		nInstances++;
		HBufC* body = HBufC::NewLC(aTestActionSpec.iActionBody.Length());
		iExpectedResults = new (ELeave)RPointerArray<CSyntaxResult>;
		body->Des().Copy(aTestActionSpec.iActionBody);
		TPtrC chainBuf = Input::ParseElement(*body, KPathStart);
		iPath.Copy(chainBuf);
		CleanupStack::PopAndDestroy();
		User::LeaveIfError(iLogFile.Replace(iFs,KSyntaxLogFile,EFileWrite));
		iSyntaxOut = new(ELeave) FileOutput(iLogFile);
		iWriter = new(ELeave) CertWriter(iSyntaxOut);
		LoadResultsL();
		}
	else
		{
		SetScriptError(ESyntax, _L("Only one syntax test can be run in each script"));
		iFinished = ETrue;		
		}
	}

TBool CSyntaxTest::LoadResultsL()
	{
	RFile resultsFile;
	TFileName fullPath;
	TInt err, fileSize;
	HBufC8 *fileInfo;

	fullPath.Append(iPath);
	fullPath.Append(KResultsFile);

	err = resultsFile.Open(iFs, fullPath, EFileRead);
	if (err != KErrNone)
		{
		iConsole.Printf(_L("Error opening results file : "));
		iConsole.Printf(fullPath);
		iConsole.Printf(_L("\n"));
		return(EFalse);
		}

	CleanupClosePushL(resultsFile);
	resultsFile.Size(fileSize);
	CleanupStack::PopAndDestroy(); // resultsFile
	
	fileInfo = HBufC8::NewLC(fileSize);
	TPtr8 fileInfoPtr(fileInfo->Des());
	fileInfoPtr.SetLength(fileSize);

	RFileReadStream fileStream;
	User::LeaveIfError(fileStream.Open(iFs, fullPath, EFileStream));
	CleanupClosePushL(fileStream);
	fileStream.ReadL(fileInfoPtr, fileSize);

	TLex8 theLex(fileInfoPtr);
	CSyntaxResult *syntaxResult = NULL;
	
	do
		{
		syntaxResult = CSyntaxResult::NewLC();
		syntaxResult->SetFilename(theLex.NextToken());
		syntaxResult->SetResult(theLex.NextToken());
		iExpectedResults->Append(syntaxResult);
		CleanupStack::Pop(); // syntaxResult
		}
	while(!theLex.Eos());

	CleanupStack::PopAndDestroy(2);  // fileinfo & fileStream
	return(ETrue);
	};


void CSyntaxTest::DoPerformPrerequisite(TRequestStatus& aStatus)
	{
	HBufC *searchPath = HBufC::NewLC(iPath.Size() + 1);
	TPtr searchPathPtr(searchPath->Des());
	searchPathPtr.Copy(iPath);
	searchPathPtr.Append(_L("*"));
    TInt err = iFs.GetDir(searchPathPtr, KEntryAttNormal, ESortByName, iDirList);
	if (err != KErrNone)
		{
		iConsole.Printf(_L("Error getting directory "));
		iConsole.Printf(searchPathPtr);
		iConsole.Printf(_L("\n"));
		iOut.writeString(_L("Error getting directory "));
		iOut.writeString(searchPathPtr);
		iOut.writeNewLine();
		iFinished = ETrue;
		TRequestStatus* status = &aStatus;
		User::RequestComplete(status, KErrNone);
		SetScriptError(EFileNotFound, searchPathPtr);
		}
	else
		{
		iConsole.Printf(_L("Please view "));
		iConsole.Printf(KSyntaxLogFile);
		iConsole.Printf(_L(" for results\n"));
		iOut.writeString(_L("Please view "));
		iOut.writeString(KSyntaxLogFile);
		iOut.writeString(_L(" for results"));
		iOut.writeNewLine();
		iActionState = EAction;
		TRequestStatus* status = &aStatus;
		User::RequestComplete(status, KErrNone);
		iResult = ETrue;
		}
	CleanupStack::PopAndDestroy(); // searchPath
	}

void CSyntaxTest::DoPerformPostrequisite(TRequestStatus& aStatus)
	{
	TRequestStatus* status = &aStatus;
	iFinished = ETrue;
	User::RequestComplete(status, KErrNone);
	}

void CSyntaxTest::ReadAndSyntaxCheckL(const TDesC &aFilename)
	{
	HBufC8* buf = Input::ReadFileLC(aFilename, iPath, iFs);
	CX509Certificate* cert = CX509Certificate::NewLC(buf->Des());
	iWriter->WriteCert(*cert);
	
	TestInternalizeExternalizeL(cert);
	
	CleanupStack::PopAndDestroy(2, buf);
	};

//////////////////////////////////////////////////////////////////////////////////
//	Test fix for INC023303: CX509Certificate externalize - internalize don't work 
//////////////////////////////////////////////////////////////////////////////////
void CSyntaxTest::TestInternalizeExternalizeL(CX509Certificate* aCert)
	{
	RFileWriteStream newwriter;
	newwriter.PushL();
	User::LeaveIfError(newwriter.Replace(iFs,_L("x509stream"),EFileStream));
	
	aCert->ExternalizeL(newwriter);
	newwriter.CommitL();
	CleanupStack::PopAndDestroy(1);//newwriter
	
	RFileReadStream newreader;
	newreader.PushL();
	newreader.Open(iFs,_L("x509stream"),EFileStream);
	CX509Certificate* readCert=CX509Certificate::NewLC(newreader); //Use the stream to create new cert

	if (!readCert->IsEqualL(*aCert))
		User::Leave(KErrGeneral);

//	iFs.Delete(_L("x509stream"));
	CleanupStack::PopAndDestroy(2);	//	readCert, newreader
	}

//////////////////////////////////////////////////////////////////////////////////

void CSyntaxTest::PerformAction(TRequestStatus& aStatus)
	{
	TBuf<256> filename = (*iDirList)[nFileNumber].iName;

	// dont try and do the results.txt file
	if(filename.CompareF(KResultsFile)!=0)
		{
		TRAPD(error, ReadAndSyntaxCheckL(filename));

		if(error == KErrNoMemory)
			User::Leave(error);
		if(!CheckResult(filename, error))
			iResult = EFalse;
		}

	nFileNumber++;
	if(nFileNumber == iDirList->Count())
		{
		iActionState = EPostrequisite;
		};
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, KErrNone);
	}

void CSyntaxTest::DoReportAction()
	{
	iConsole.Printf(_L("\n"));
	}

void CSyntaxTest::DoCheckResult(TInt /*aError*/)
	{
	}


TBool CSyntaxTest::CheckResult(const TDesC &aFilename, const TInt &aError)
	{
	CSyntaxResult *syntaxResult;
	TPtrC filename;

	iConsole.Printf(aFilename);
	iOut.writeString(aFilename);

	for(TInt element = 0; element < iExpectedResults->Count(); element++)
		{
		syntaxResult = (*iExpectedResults)[element];
	
		syntaxResult->GetFilename(filename);
		if(filename.CompareF(aFilename)==0)
			{
			
			if(syntaxResult->Result() != aError)
				{	
				iConsole.Printf(_L(" FAILED. Expecting "));
				iOut.writeString(_L(" FAILED. Expecting "));
				PrintError(syntaxResult->Result());
				iConsole.Printf(_L("  Recieved "));
				iOut.writeString(_L(" Recieved "));
				PrintError(aError);
				iConsole.Printf(_L("\n"));
				iOut.writeNewLine();
				return(EFalse);
				}
			else
				{
				iConsole.Printf(_L(" Success\n"));
				iOut.writeString(_L(" Success "));
				iOut.writeNewLine();
				return(ETrue);
				}
			}
		}

	iConsole.Printf(_L(" FAILED to find expected result\n"));
	iOut.writeString(_L(" FAILED to find expected result"));
	iOut.writeNewLine();
	return(EFalse);
	};

void CSyntaxTest::PrintError(const TInt &aError)
	{
	switch(aError) 
		{
		case KErrArgument:
			{
			iConsole.Printf(_L(" Wrongly encoded"));
			iOut.writeString(_L(" Wrongly encoded"));
			break;
			}
		case KErrNotSupported:
			{
			iConsole.Printf(_L(" Not Supported"));
			iOut.writeString(_L(" Not Supported"));
			break;
			}
		case KErrNone:
			{
			iConsole.Printf(_L(" None "));
			iOut.writeString(_L(" None "));
			break;
			}
		default:
			{
			iConsole.Printf(_L(" UNKNOWN "));
			iOut.writeString(_L(" UNKNOWN "));
			}
		};
	}

void CSyntaxTest::Reset()
    {
    // nothing to do
    }