/*

* Copyright (c) 2008-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 <usif/scr/scr.h>

#include <usif/sif/sif.h>

#include <e32cons.h>

#include "command.h"

using namespace Usif;

_LIT(KTxtOptionPrefix, "--");

_LIT(KTxtDeleteCommand, "delete");

_LIT(KTxtListCommand, "list");

_LIT(KTxtListOptName, "name");

_LIT(KTxtListOptVendor, "vendor");

_LIT(KTxtListOptType, "type");

_LIT(KTxtListOptActivated, "activated");

_LIT(KTxtListOptDeactivated, "deactivated");

_LIT(KTxtListOptRemovable, "removable");

_LIT(KTxtListOptProperty, "property");

_LIT(KTxtListOptIntProperty, "intproperty");

_LIT(KTxtListOptDrives, "drives");

_LIT(KTxtListOptLocale, "locale");

_LIT(KTxtActivated, "Activated");

_LIT(KTxtDeactivated, "Deactivated");

_LIT(KTxtPressToContinue, "\nPress any key to continue...");

_LIT(KTxtSifConnectionFailure, "\nFailed to connect to the SIF server\n");

_LIT(KTxtDeleting, "Deleting...\n");

// ==================================================================================

CConsoleCommand::CConsoleCommand()

	{

	}

CConsoleCommand::~CConsoleCommand()

	{

	}

// ==================================================================================

CListCommand* CListCommand::NewLC()

	{

	CListCommand* self = new (ELeave) CListCommand;

	CleanupStack::PushL(self);

	self->iFilter = CComponentFilter::NewL();

	return self;

	}

CListCommand::CListCommand(): iLocale(KUnspecifiedLocale)

	{

	}

CListCommand::~CListCommand()

	{

	delete iFilter;

	}

const TDesC& CListCommand::Name()

	{

	return KTxtListCommand;

	}

namespace

	{

	// Leave if the number of values differs from aCount

	void AssertNumValuesL(const RArray<TPtrC>& aValues, TInt aCount)

		{

		if (aValues.Count() != aCount)

			{

			User::Leave(KErrArgument);

			}

		}

	}

void CListCommand::OptionHandlerL(const TPtrC& aName, const RArray<TPtrC>& aValues)

	{

	// Configure the component query filter:

	// Component name

	if (aName == KTxtListOptName)

		{

		AssertNumValuesL(aValues, 1);

		iFilter->SetNameL(aValues[0]);

		}

	// Vendor

	else if (aName == KTxtListOptVendor)

		{

		AssertNumValuesL(aValues, 1);

		iFilter->SetVendorL(aValues[0]);

		}

	// Software type

	else if (aName == KTxtListOptType)

		{

		AssertNumValuesL(aValues, 1);

		iFilter->SetSoftwareTypeL(aValues[0]);

		}

	// SCOMO state - Activated

	else if (aName == KTxtListOptActivated)

		{

		AssertNumValuesL(aValues, 0);

		// The activated and deactivated options are mutually exclusive

		if (iScomoStateSet)

			{

			User::Leave(KErrArgument);

			}

		iScomoStateSet = ETrue;

		iFilter->SetScomoStateL(EActivated);

		}

	// SCOMO state - Deactivated

	else if (aName == KTxtListOptDeactivated)

		{

		AssertNumValuesL(aValues, 0);

		// The activated and deactivated options are mutually exclusive

		if (iScomoStateSet)

			{

			User::Leave(KErrArgument);

			}

		iScomoStateSet = ETrue;

		iFilter->SetScomoStateL(EDeactivated);

		}

	// Removable

	else if (aName == KTxtListOptRemovable)

		{

		AssertNumValuesL(aValues, 0);

		iFilter->SetRemovable(ETrue);

		}

	// String property

	else if (aName == KTxtListOptProperty)

		{

		const TInt numValues = aValues.Count();

		if (numValues < 2 || numValues > 3)

			{

			User::Leave(KErrArgument);

			}

		// Convert language from string to int if specified

		TInt language = KUnspecifiedLocale;

		if (numValues == 3)

			{

			TLex lex(aValues[2]);

			if (lex.Val(language) != KErrNone || language < ELangEnglish || language >= ELangMaximum)

				{

				User::Leave(KErrArgument);

				}

			}

		// Add the property to the filter

		iFilter->AddPropertyL(aValues[0], aValues[1], static_cast<TLanguage>(language));

		}

	// Integer property

	else if (aName == KTxtListOptIntProperty)

		{

		AssertNumValuesL(aValues, 2);

		TLex lex(aValues[1]);

		TInt64 val;

		if (lex.Val(val) != KErrNone)

			{

			User::Leave(KErrArgument);

			}

		iFilter->AddPropertyL(aValues[0], val);

		}

	// Drives

	else if (aName == KTxtListOptDrives)

		{

 	 	AssertNumValuesL(aValues, 1);

 	 	TPtrC drives = aValues[0];

 	 	TDriveList driveList;

 	 	driveList.FillZ(KMaxDrives);

 	 	for (TInt i=0; i<drives.Length(); ++i)

 	 	   	{

 	 	  	TChar driveLetter = static_cast<TChar>(drives[i]);

 	 	   	TInt driveNumber = 0;

 	 	   	User::LeaveIfError(RFs::CharToDrive(driveLetter, driveNumber));

 	 	   	driveList[driveNumber] = ETrue;

 	 	   	}

 	 	iFilter->SetInstalledDrivesL(driveList);

		}

	// Locale

	else if (aName == KTxtListOptLocale)

		{

		AssertNumValuesL(aValues, 1);

		TLex lex(aValues[0]);

		TInt val;

		if (lex.Val(val) != KErrNone || val < ELangEnglish || val >= ELangNone)

			{

			User::Leave(KErrArgument);

			}

		iLocale = static_cast<TLanguage>(val);

		}

	// Unknown

	else

		{

		User::Leave(KErrArgument);

		}

	}

void CListCommand::ExecuteL(CConsoleBase& aConsole)

	{

	// Connect to the SCR server

	RSoftwareComponentRegistry scr;

	TInt err = scr.Connect();

	if (err != KErrNone)

		{

		aConsole.Printf(_L("\nFailed to connect to the SCR server"));

		User::Leave(err);

		}

	CleanupClosePushL(scr);

	// Create an SCR view

	RSoftwareComponentRegistryView scrView;

	scrView.OpenViewL(scr, iFilter);

	CleanupClosePushL(scrView);

	// Iterate over the matching components

	CComponentEntry* entry = CComponentEntry::NewLC();

	TBool first(ETrue);

	while (scrView.NextComponentL(*entry, iLocale))

		{

		if (first)

			{

			first = EFalse;

			}

		else

			{

			aConsole.Printf(KTxtPressToContinue);

			aConsole.Getch();

			aConsole.ClearScreen();

			}

		aConsole.Printf(_L("\n============= Component Info =============\n"));

		aConsole.Printf(_L("\nComponent ID     : %d"), entry->ComponentId());

		aConsole.Printf(_L("\nComponent name   : %S"), &entry->Name());

		aConsole.Printf(_L("\nVendor name      : %S"), &entry->Vendor());

		aConsole.Printf(_L("\nSoftware type    : %S"), &entry->SoftwareType());

		aConsole.Printf(_L("\nSCOMO state      : %S"), entry->ScomoState() == EActivated ? &KTxtActivated : &KTxtDeactivated );

		aConsole.Printf(_L("\nComponent size   : %d"), entry->ComponentSize());

		aConsole.Printf(_L("\nInstalled drives : %S"), &entry->InstalledDrives());

		aConsole.Printf(_L("\nVersion          : %S"), &entry->Version());

		aConsole.Printf(_L("\n\n=========================================\n"));

		}

	// Disconnect from the SCR server and cleanup the entry

	CleanupStack::PopAndDestroy(3, &scr);

	}

// ==================================================================================

CDeleteCommand* CDeleteCommand::NewLC()

	{

	CDeleteCommand* self = new (ELeave) CDeleteCommand;

	CleanupStack::PushL(self);

	return self;

	}

CDeleteCommand::CDeleteCommand(): iComponentId(EInvalidComponentId)

	{

	}

CDeleteCommand::~CDeleteCommand()

	{

	}

const TDesC& CDeleteCommand::Name()

	{

	return KTxtDeleteCommand;

	}

void CDeleteCommand::OptionHandlerL(const TPtrC& aName, const RArray<TPtrC>& aValues)

	{

	// The delete command takes only the id of a component

	if (aName.Length() || aValues.Count() != 1)

		{

		User::Leave(KErrArgument);

		}

	// Convert the id of the component from string to int

	TLex lex(aValues[0]);

	if (lex.Val(iComponentId) != KErrNone)

		{

		User::Leave(KErrArgument);

		}

	}

void CDeleteCommand::ExecuteL(CConsoleBase& aConsole)

	{

	// Connect to the SIF server

	RSoftwareInstall sif;

	TInt err = sif.Connect();

	if (err != KErrNone)

		{

		aConsole.Printf(KTxtSifConnectionFailure);

		User::Leave(err);

		}

	CleanupClosePushL(sif);

	// Delete the component

	TRequestStatus status;

	sif.Uninstall(iComponentId, status);

	aConsole.Printf(KTxtDeleting);

	User::WaitForRequest(status);

	if (status.Int() != KErrNone)

		{

		User::Leave(status.Int());

		}

	// Disconnect from the SIF server

	CleanupStack::PopAndDestroy(&sif);

	}

// ==================================================================================

CCommandLineParser* CCommandLineParser::NewLC()

	{

	CCommandLineParser* self = new (ELeave) CCommandLineParser;

	CleanupStack::PushL(self);

	self->iCmdLineArgs = CCommandLineArguments::NewL();

	return self;

	}

CCommandLineParser::CCommandLineParser()

	{

	}

CCommandLineParser::~CCommandLineParser()

	{

	delete iCmdLineArgs;

	iCommands.Close();

	}

void CCommandLineParser::RegisterCommandL(CConsoleCommand& aCommand)

	{

	iCommands.Append(&aCommand);

	}

CConsoleCommand& CCommandLineParser::ParseL()

	{

	const TInt numArgs = iCmdLineArgs->Count();

	// There must be at least two arguments: the name of the program and the name of a command

	if (numArgs <= 1)

		{

		User::Leave(KErrArgument);

		}

	// Extract the name of the command

	TPtrC arg0 = iCmdLineArgs->Arg(1);

	if (arg0.Left(KTxtOptionPrefix.iTypeLength) != KTxtOptionPrefix)

		{

		User::Leave(KErrArgument);

		}

	TPtrC cmdName = arg0.Mid(KTxtOptionPrefix.iTypeLength);

	// Look for the command in iCommands

	CConsoleCommand* cmd = NULL;

	for (TInt i=0; i<iCommands.Count(); ++i)

		{

		if (cmdName == iCommands[i]->Name())

			{

			cmd = iCommands[i];

			}

		}

	if (cmd == NULL)

		{

		User::Leave(KErrArgument);

		}

	// Iterate over the command's options and build pairs of optName and optValues

	TPtrC optName;

	RArray<TPtrC> optValues;

	CleanupClosePushL(optValues);

	for (TInt i=2; i<numArgs; ++i)

		{

		TPtrC arg = iCmdLineArgs->Arg(i);

		// Option name

		if (arg.Left(KTxtOptionPrefix.iTypeLength) == KTxtOptionPrefix)

			{

			// Process the previous option

			if (optName.Length())

				{

				cmd->OptionHandlerL(optName, optValues);

				}

			// Set new option

			optName.Set(arg.Mid(KTxtOptionPrefix.iTypeLength));

			if (optName.Length() == 0)

				{

				User::Leave(KErrArgument);

				}

			optValues.Reset();

			}

		else

			{

			// Store the option's value

			optValues.AppendL(arg);

			}

		}

	// Process the last option

	if (optName.Length() || optValues.Count())

		{

		cmd->OptionHandlerL(optName, optValues);

		}

	CleanupStack::PopAndDestroy(&optValues);

	// Return the current command

	return *cmd;

	}