// Copyright (c) 2004-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 "Symbian Foundation License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include <e32cons.h>
#include <bacline.h>

#include "keytool_utils.h"
#include "keytool_defs.h"
#include "keytool_controller.h"
#include "keytool_view_imp.h"
#include "keytool_commands.h"
#include "keytoolfileview.h"


// Boiler plate 
_LIT(KShortName, "Symbian OS KeyTool");
_LIT(KName, "Symbian OS KeyStore Manipulation Tool");
_LIT(KCopyright, "Copyright (c) 2004 - 2007 Symbian Software Ltd.  All rights reserved.");

_LIT(KNewLine, "\n");

_LIT(KDone, "Press any key to continue... \n");

// Keytool command line parameters
_LIT(KList, "-list");
_LIT(KListShort, "-l");

_LIT(KListStores, "-liststores");
_LIT(KListStoresShort, "-ls");

_LIT(KImport, "-import");
_LIT(KImportShort, "-i");


_LIT(KRemove, "-remove");
_LIT(KRemoveShort, "-r");

_LIT(KHelp, "-help");
_LIT(KHelpShort, "-h");

_LIT(KSetUser, "-setuser");
_LIT(KSetUserShort, "-s");

_LIT(KSetAllUsers, "-setallusers");
_LIT(KSetAllUsersShort, "-a");

_LIT(KSetManager, "-setmanager");
_LIT(KSetManagerShort, "-m");

_LIT(KRemoveUser, "-removeuser");
_LIT(KRemoveUserShort, "-ru");

// Command parameters
_LIT(KLabel, "-label");
_LIT(KKeyUsage, "-usage");
_LIT(KAccess, "-access");

_LIT(KStore, "-store");

//_LIT(KExpiry, "-expiry"); // Functionality not present at the moment...
_LIT(KDetails, "-details");
_LIT(KDetailsShort, "-d");

_LIT(KPageWise, "-page");
_LIT(KPageWiseShort, "-p");


const TInt KMaxArgs = 10;

/**
 * Displays tool name and copyright informations.
 */
LOCAL_D void BoilerPlateL(CConsoleBase* console) 
	{
	console->Printf(KNewLine);
	console->Printf(KName);
	console->Printf(KNewLine);	
	console->Printf(KCopyright);
	console->Printf(KNewLine);
	console->Printf(KNewLine);	
	}


LOCAL_D TBool VerifyCommand(const TDesC& aCommand, TInt& aCmdNum, TInt& aCmdCount)
	{
	if ((aCmdNum != -1) && (aCommand[0] == '-'))
		{
		aCmdNum = KeyToolDefController::KUsageCommand;
		aCmdCount = KMaxArgs;
		return 1;
		}
	if (aCommand.CompareF(KList) == 0 || aCommand.Compare(KListShort) == 0)
		{
		aCmdNum = KeyToolDefController::KListCommand;
		}
	else if (aCommand.CompareF(KListStores) == 0 || aCommand.Compare(KListStoresShort) == 0)
		{
		aCmdNum = KeyToolDefController::KListStoresCommand;
		}
	else if	(aCommand.CompareF(KImport) == 0 || aCommand.Compare(KImportShort) == 0)
		{
		aCmdNum = KeyToolDefController::KImportCommand;
		}
	else if	(aCommand.CompareF(KRemove) == 0 || aCommand.Compare(KRemoveShort) == 0)
		{
		aCmdNum = KeyToolDefController::KRemoveCommand;
		}
	else if	(aCommand.CompareF(KSetUser) == 0 || aCommand.Compare(KSetUserShort) == 0)
		{
		aCmdNum = KeyToolDefController::KSetUserCommand;
		}
	else if	(aCommand.CompareF(KSetManager) == 0 || aCommand.Compare(KSetManagerShort) == 0)
		{
		aCmdNum = KeyToolDefController::KSetManagerCommand;
		}
	else if	(aCommand.CompareF(KRemoveUser) == 0 || aCommand.Compare(KRemoveUserShort) == 0)
		{
		aCmdNum = KeyToolDefController::KRemoveUserCommand;
		}
	else if	(aCommand.CompareF(KSetAllUsers) == 0 || aCommand.Compare(KSetAllUsersShort) == 0)
		{
		aCmdNum = KeyToolDefController::KSetAllUsersCommand;
		}
	else	
		{
		return 0;
		}

	return 1;
	}
	
	
/**
 * Parses the command line and given control to the handler to deal with the request.
 */
LOCAL_D void DoMainL() 
	{
	TBool interactiveMode = ETrue;
	
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	
	CConsoleBase* console = Console::NewL(KShortName, TSize(KConsFullScreen, KConsFullScreen));
	CleanupStack::PushL(console);
	CCommandLineArguments* cmdArgs = CCommandLineArguments::NewLC();
	TInt cmdArgsCount = cmdArgs->Count();
	
	RFile file;
	// command: keytool inputfile outputfile
	if (cmdArgsCount == 3)
		{
		interactiveMode = EFalse;
		TInt error = file.Open(fs, cmdArgs->Arg(1), EFileRead|EFileShareAny);
		file.Close();
		TInt error1 = file.Replace(fs, cmdArgs->Arg(2), EFileWrite|EFileShareExclusive);
	    CleanupClosePushL(file);
	    // If the input file doesn't exist or not able to create outputfile
		// switch to Interactive mode
		if (error != KErrNone || error1 != KErrNone)
			{
			CleanupStack::PopAndDestroy(&file);
			interactiveMode = ETrue;
			}	
		}
		
	CKeytoolConsoleView* view = CKeytoolConsoleView::NewLC(*console);
	CKeyToolController* controller = CKeyToolController::NewLC(*view);
	CArrayFixFlat<TPtrC>* args = new (ELeave) CArrayFixFlat<TPtrC> (10);
	CleanupStack::PushL(args);
	CKeytoolFileView* view1 = NULL;

	TInt cmdCount = 0;
	if (interactiveMode)
		{
		KeyToolUtils::SetConsole(console);
		BoilerPlateL(console);
		for (TInt i = 0; i < cmdArgsCount; i++)
			{
			args->AppendL(cmdArgs->Arg(i));
			}
		// In Interactive mode by default we can execute 1 command only.
		cmdCount = 1;
		}
	else
		{
		CleanupStack::PopAndDestroy(3, view); // args, controller, view
		KeyToolUtils::SetFile(&file);
		view1 = CKeytoolFileView::NewLC(cmdArgs->Arg(1));
		cmdCount = view1->SplitFileInputToArrayL();
		}	
		
	for (TInt j = 0; j < cmdCount; j++)
		{
		if (!interactiveMode)
			{
			controller = CKeyToolController::NewLC(*view1);
			args = view1->ReadArrayArgumentsLC(j);
			}
			
		CKeyToolParameters* params = CKeyToolParameters::NewLC();
		
		TInt command = -1; 
		TInt i = -1;

		TInt argsCount = args->Count();
		while (i < (argsCount-1))
		 	{
			i++;

			if ((args->At(i).CompareF(KDetails)==0)|| (args->At(i).Compare(KDetailsShort)==0))
				{
				params->iIsDetailed = ETrue;
				continue;
				}
			
			if (args->At(i).CompareF(KPageWise)==0 || (args->At(i).Compare(KPageWiseShort)==0))
				{
				params->iPageWise = ETrue;
				continue;
				}			
			
			TDesC& commd = args->At(i);
			if (VerifyCommand(commd, command, i))
				{
				if (commd.CompareF(KSetAllUsers) == 0 || commd.Compare(KSetAllUsersShort) == 0 ||
				    commd.CompareF(KRemoveUser) == 0 || commd.Compare(KRemoveUserShort) == 0 ||
				    commd.CompareF(KSetManager) == 0 || commd.Compare(KSetManagerShort) == 0 )
					{
					i++;
					if (args->At(i)[0] == '-' ||  args->At(i).Left(2) == _L("0x"))
						{
						i = argsCount;
						command = KeyToolDefController::KUsageCommand;
						}
					else
						{
						i--;
						}
					}
				if (commd.CompareF(KSetAllUsers) == 0 || commd.Compare(KSetAllUsersShort) == 0)
					{
					params->iPolicy = CKeyToolParameters::ESetAllUsersPolicy;
					params->iIsDetailed = ETrue;
					}
				if (commd.CompareF(KRemoveUser) == 0 || commd.Compare(KRemoveUserShort) == 0)
					{
					params->iPolicy = CKeyToolParameters::ERemoveUserPolicy;
					params->iIsDetailed = ETrue;
					}
				if (commd.CompareF(KSetManager) == 0 || commd.Compare(KSetManagerShort) == 0)
					{
					params->iPolicy = CKeyToolParameters::ESetManagerPolicy;
					params->iIsDetailed = ETrue;
					}
				if (commd.CompareF(KSetUser) == 0 || commd.Compare(KSetUserShort) == 0)
					{
					params->iPolicy = CKeyToolParameters::ESetUserPolicy;
					i++;
					if (i >= argsCount || args->At(i)[0] == '-' ||  args->At(i).Left(2) != _L("0x"))
						{
						i = argsCount;
						command = KeyToolDefController::KUsageCommand;
						}
					else
						{
						TUid app;
						TLex lex(args->At(i).Mid(2));		
						TUint uid =0;
						TInt err = lex.Val(uid, EHex);
						if (err == KErrNone)
							{
							app = TUid::Uid(uid);						
							}			 
						params->iUIDs.Append(app); 
						params->iIsDetailed = ETrue;
						}
					}
				continue;
				}

			TDesC& cmd = args->At(i);
				if (cmd.CompareF(KHelp) == 0 || cmd.Compare(KHelpShort) == 0 ||
				    cmd.CompareF(KLabel) == 0 || cmd.CompareF(KKeyUsage) == 0 ||
				    cmd.CompareF(KStore) == 0 || cmd.CompareF(KAccess) == 0)
				{
				i++;
				if (i >= argsCount || args->At(i)[0] == '-')
					{
					i = argsCount;
					command = KeyToolDefController::KUsageCommand;
					}
				else if (cmd.CompareF(KHelp) == 0 || cmd.Compare(KHelpShort) == 0)
					{
					params->iDefault = args->At(i).AllocL();
					i = argsCount;	
					}
				else if (cmd.CompareF(KLabel) == 0)
					{
					params->iLabel = args->At(i).AllocL();
					}
				else if (cmd.CompareF(KKeyUsage) == 0)
					{
					params->iUsage = KeyToolUtils::ParseKeyUsage(args->At(i));
					}
				else if (cmd.CompareF(KStore) == 0)
					{
					TLex parser(args->At(i));
					TInt err = parser.Val(params->iKeystoreIndex);
					params->iIsDetailed = ETrue;
					}
				else if (cmd.CompareF(KAccess) == 0)
					{
					params->iAccess = KeyToolUtils::ParseKeyAccess(args->At(i));
					}
				else
					{
					// no action required	
					}
				continue;
				}
				
			if (i!=0) 
				{
				if (args->At(i)[0] == '-')
					{
					i = argsCount;
					command = KeyToolDefController::KUsageCommand;
					continue;
					}
				delete params->iDefault;
				params->iDefault = NULL;
				params->iDefault = args->At(i).AllocL();			
				}
		 	} 
		 
		 
		if (command != -1)
			{
			TRAP_IGNORE(controller->HandleCommandL(command, params));
			}
		else 
			{
			controller->HandleCommandL(KeyToolDefController::KUsageCommand, params);		
			}
		
		CleanupStack::PopAndDestroy(3, controller); // params, args, controller
		}
	if (interactiveMode)
		{
		CleanupStack::PopAndDestroy(view);
		// We are done!
		console->Printf(KNewLine);
		console->Printf(KDone);
		console->Getch();	
		}
	else
		{
		CleanupStack::PopAndDestroy(2, &file); //view1 and file
		}
	CleanupStack::PopAndDestroy(3, &fs); //cmdArgs, console, fs	
	}
	

GLDEF_C TInt E32Main()         // main function called by E32
   	{
	__UHEAP_MARK;
	CTrapCleanup* cleanup=CTrapCleanup::New(); 
	
	TRAP_IGNORE(DoMainL());
	
	delete cleanup; 
	__UHEAP_MARKEND;
	return 0; 
   	}
