/*

* 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 "dbhelper.h"

#include "dbprocessor.h"

#include "dbconstants.h"

#include "is_utils.h"

#include "sisregistryobject.h"

#include "sisregistrytoken.h"

#include "sisregistrypackage.h"

#include "errors.h"

#include "../common/exception.h"

#include <sstream>

#include <stdexcept>

const int DbHelper::Absent = -1;

DbHelper::~DbHelper()

	{

	delete iScrDbHandler;

	}

DbHelper::DbHelper( const std::wstring& aDrivePath, bool aIsSystemDrive)

	{

	std::string dllName = "sqlite3.dll";

	std::string dbName; 

	if (aIsSystemDrive)

		dbName = wstring2string(aDrivePath) + "\\sys\\install\\scr\\scr.db";

	else 

		dbName = wstring2string(aDrivePath) + "\\sys\\install\\scr\\provisioned\\scr.db";

	try

		{

		iScrDbHandler = new CDbProcessor(dllName, dbName);		

		}

	catch(CException& aException)

		{

		int returnCode = aException.GetCode();

		std::wstring emessage = Utf8ToUcs2( aException.GetMessageA() );

		returnCode = (returnCode == ExceptionCodes::ELibraryLoadError) ? LIBRARYLOAD_ERROR : returnCode;

		throw InterpretSisError(emessage,returnCode);		

		}

	}

TBool DbHelper::IsInstalled(TInt32 aUid) const

	{

	std::string selectUid("SELECT IntValue FROM ComponentProperties WHERE Name='CompUid' and IntValue=?;");

	std::auto_ptr<CStatement> stmtUid(iScrDbHandler->PrepareStatement(selectUid));

	stmtUid->BindInt(1, aUid);

	if(!stmtUid->ProcessNextRow())

		return false;

	TInt32 uid = stmtUid->IntColumn(0);

	return (uid == aUid);

	}

TBool DbHelper::IsAppUidInstalled(TUint32 aAppUid) const

	{

	std::string selectUid("SELECT AppFile FROM AppRegistrationInfo WHERE AppUid=?;");

	std::auto_ptr<CStatement> stmtUid(iScrDbHandler->PrepareStatement(selectUid));

	stmtUid->BindInt(1, aAppUid);

	if(!stmtUid->ProcessNextRow())

		return false;

	return true;

	}

TInt32 DbHelper::GetComponentId(TInt32 aUid, const std::wstring aPackageName, const std::wstring aVendorName ) const

	{

	std::string selectUid("SELECT ComponentId from ComponentProperties where Name='CompUid' and IntValue=? and ComponentId IN (SELECT ComponentId FROM \

	ComponentProperties WHERE Name='CompUniqueVendorName' and StrValue=? and ComponentId IN (SELECT ComponentId FROM ComponentLocalizables WHERE Name=?));");

	std::auto_ptr<CStatement> stmtCompid(iScrDbHandler->PrepareStatement(selectUid));

	stmtCompid->BindInt(1, aUid);

	stmtCompid->BindStr(2, aVendorName);

	stmtCompid->BindStr(3, aPackageName);

	TInt32 componentId = DbHelper::Absent;

	if(stmtCompid->ProcessNextRow())

		{

		componentId = stmtCompid->IntColumn(0);

		}

	return componentId;	

	}

TInt32 DbHelper::GetComponentId(TInt32 aUid, TInt32 aInstallType ) const

	{

	std::string selectUid("SELECT ComponentId from ComponentProperties where Name='CompUid' and IntValue=? and ComponentId IN (SELECT ComponentId FROM \

	ComponentProperties WHERE Name='CompInstallType' and IntValue=?) ");

	std::auto_ptr<CStatement> stmtCompid(iScrDbHandler->PrepareStatement(selectUid));

	stmtCompid->BindInt(1, aUid);

	stmtCompid->BindInt(2, aInstallType);

	TInt32 componentId = DbHelper::Absent;

	if(	stmtCompid->ProcessNextRow())

		{

		componentId = stmtCompid->IntColumn(0);

		}

	return componentId;	

	}

TInt32 DbHelper::GetComponentId( TInt32 aUid ) const

	{

	std::string selectCompId(	"SELECT ComponentId FROM ComponentProperties WHERE Name='CompUid' \

								AND IntValue=? AND ComponentId IN (SELECT ComponentId from \

								ComponentProperties WHERE Name='CompIndex' AND IntValue='0');"	

							);

	std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selectCompId));

	stmtCompId->BindInt(1, aUid);

	// this might contain multiple entries for the specific uid but as it has been

	// ordered by propertyid the first entry would be of the first installation.

	if(stmtCompId->ProcessNextRow())

		{

		return stmtCompId->IntColumn(0);

		}

	return DbHelper::Absent;

	}

std::vector<TInt32> DbHelper::GetComponentIdList( TInt32 aUid ) const

	{

	std::vector<TInt32> componentIdList;

	std::string selectCompId("SELECT ComponentId FROM ComponentProperties WHERE Name='CompUid' and IntValue=? order by PropertyId;");

	std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selectCompId));

	stmtCompId->BindInt(1, aUid);

	// this might contain multiple entries for the specific uid but as it has been

	// ordered by propertyid the first entry would be of the first installtion.

	while(stmtCompId->ProcessNextRow())

		{

		componentIdList.push_back(stmtCompId->IntColumn(0));

		}

	return componentIdList;

	}

bool DbHelper::GetIsRemovable( TInt32 aComponentId ) const

	{

	std::string selectIsRemovable("SELECT Removable FROM Components WHERE ComponentId=?;");

	std::auto_ptr<CStatement> stmtIsRemovable(iScrDbHandler->PrepareStatement(selectIsRemovable));

	stmtIsRemovable->BindInt(1, aComponentId);

	if(!stmtIsRemovable->ProcessNextRow())

		return false;

	return (stmtIsRemovable->IntColumn(0) == 1);

	}

bool DbHelper::GetInRom( TInt32 aComponentId ) const

	{

	std::string selectInRom("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompInRom';");

	std::auto_ptr<CStatement> stmtInRom(iScrDbHandler->PrepareStatement(selectInRom));

	stmtInRom->BindInt(1, aComponentId);

	if(!stmtInRom->ProcessNextRow())

		return DbConstants::KDefaultIsInRom;

	return (stmtInRom->IntColumn(0) == 1);

	}

std::wstring DbHelper::GetPackageName( TInt32 aComponentId ) const

	{

	std::string selectPckgName("SELECT Name FROM ComponentLocalizables WHERE ComponentId=?;");

	std::auto_ptr<CStatement> stmtPckgName(iScrDbHandler->PrepareStatement(selectPckgName));

	stmtPckgName->BindInt(1, aComponentId);

	if(stmtPckgName->ProcessNextRow())

		{

		return stmtPckgName->StrColumn(0);

		}

	return NULL;

	}

TUint32 DbHelper::GetUid( TInt32 aComponentId ) const

	{

	std::string selectUid("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompUid';");

	std::auto_ptr<CStatement> stmtUid(iScrDbHandler->PrepareStatement(selectUid));

	stmtUid->BindInt(1, aComponentId);

	if(stmtUid->ProcessNextRow())

		{

		return stmtUid->IntColumn(0);

		}

	return DbHelper::Absent;

	}

TUint32 DbHelper::GetUidFromFileName( const std::wstring& aFileName ) const

	{

	std::string selCompId("SELECT ComponentId FROM ComponentsFiles WHERE Location=?;");

	std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selCompId));

	stmtCompId->BindStr(1, aFileName);

	TInt32 componentId = 0;

	if(stmtCompId->ProcessNextRow())

		{

		componentId = stmtCompId->IntColumn(0);

		return GetUid(componentId);

		}

	std::string selCompPropsId("SELECT ComponentId FROM ComponentProperties WHERE StrValue=? and Name like 'WCFile%';");

	std::auto_ptr<CStatement> stmtCompPropsId(iScrDbHandler->PrepareStatement(selCompPropsId));

	stmtCompPropsId->BindStr(1, aFileName);

	if(stmtCompPropsId->ProcessNextRow())

		{

		componentId = stmtCompPropsId->IntColumn(0);

		return GetUid(componentId);

		}

	return 0;

	}

TUint32 DbHelper::GetInstallType( TInt32 aComponentId ) const

	{

	std::string selectInstallType("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompInstallType';");

	std::auto_ptr<CStatement> stmtInstallType(iScrDbHandler->PrepareStatement(selectInstallType));

	stmtInstallType->BindInt(1, aComponentId);

	if(stmtInstallType->ProcessNextRow())

		return stmtInstallType->IntColumn(0);

	return DbConstants::KDefaultInstallType;

	}

TInt DbHelper::GetIndex( TInt32 aComponentId) const

	{

	return GetComponentPropertyIntValue(aComponentId,DbConstants::CompIndex);

	}

void DbHelper::RemoveEntry( TInt32 aComponentId ) const

	{

	std::vector<TInt32> appUidList = GetAppRegistrationInfoAppUid(aComponentId);

	std::vector<TInt32> ::iterator appUidIter;

	for( appUidIter = appUidList.begin(); appUidIter != appUidList.end() ; ++appUidIter )

	{

		// delete FileOwnershipInfo

		std::string delFileOwnerInfo("DELETE FROM FileOwnershipInfo WHERE AppUid=?;");

		std::auto_ptr<CStatement> stmtdelFileOwnerInfo(iScrDbHandler->PrepareStatement(delFileOwnerInfo));

		stmtdelFileOwnerInfo->BindInt(1, *appUidIter);

		stmtdelFileOwnerInfo->ExecuteStatement();

		// delete AppProperties

		std::string delAppProperties("DELETE FROM AppProperties WHERE AppUid=?;");

		std::auto_ptr<CStatement> stmtAppProperties(iScrDbHandler->PrepareStatement(delAppProperties));

		stmtAppProperties->BindInt(1, *appUidIter);

		stmtAppProperties->ExecuteStatement();

		std::vector<TInt32> serviceIdList = GetServiceInfoServiceID(*appUidIter);

		std::vector<TInt32> ::iterator serviceIdIter;

		for( serviceIdIter = serviceIdList.begin(); serviceIdIter != serviceIdList.end() ; ++serviceIdIter )

		{

			// delete DataType

			std::string delDataType("DELETE FROM DataType WHERE ServiceId=?;");

			std::auto_ptr<CStatement> stmtDataType(iScrDbHandler->PrepareStatement(delDataType));

			stmtDataType->BindInt(1, *serviceIdIter);

			stmtDataType->ExecuteStatement();

		}

		// delete ServiceInfo

		std::string delServiceInfo("DELETE FROM ServiceInfo WHERE AppUid=?;");

		std::auto_ptr<CStatement> stmtServiceInfo(iScrDbHandler->PrepareStatement(delServiceInfo));

		stmtServiceInfo->BindInt(1, *appUidIter);

		stmtServiceInfo->ExecuteStatement();

		std::vector<TInt32> localAppInfoIdList = GetLocalAppInfoID(*appUidIter);

		std::vector<TInt32> ::iterator localAppInfoIdIter;

		for( localAppInfoIdIter = localAppInfoIdList.begin(); localAppInfoIdIter != localAppInfoIdList.end() ; ++localAppInfoIdIter )

		{

			std::vector<TInt32> viewDataCaptionIdList = GetViewDataCaptionAndIconID(*localAppInfoIdIter);

			std::vector<TInt32> ::iterator viewDataCaptionIdIter;

			for( viewDataCaptionIdIter = viewDataCaptionIdList.begin(); viewDataCaptionIdIter != viewDataCaptionIdList.end() ; ++viewDataCaptionIdIter )

			{

				// delete CaptionAndIconInfo

				std::string delCaptionInfo("DELETE FROM CaptionAndIconInfo WHERE CaptionAndIconId=?;");

				std::auto_ptr<CStatement> stmtCaptionInfo(iScrDbHandler->PrepareStatement(delCaptionInfo));

				stmtCaptionInfo->BindInt(1, *viewDataCaptionIdIter);

				stmtCaptionInfo->ExecuteStatement();

			}

			// delete ViewData

			std::string delViewData("DELETE FROM ViewData WHERE LocalAppInfoId=?;");

			std::auto_ptr<CStatement> stmtViewData(iScrDbHandler->PrepareStatement(delViewData));

			stmtViewData->BindInt(1, *localAppInfoIdIter);

			stmtViewData->ExecuteStatement();

		}

		std::vector<TInt32> LocalCaptionIdList = GetLocalCaptionAndIconID(*appUidIter);

		std::vector<TInt32> ::iterator LocalCaptionIdIter;

		for( LocalCaptionIdIter = LocalCaptionIdList.begin(); LocalCaptionIdIter != LocalCaptionIdList.end() ; ++LocalCaptionIdIter )

		{

			// delete CaptionAndIconInfo

			std::string delCaptionInfo("DELETE FROM CaptionAndIconInfo WHERE CaptionAndIconId=?;");

			std::auto_ptr<CStatement> stmtCaptionInfo(iScrDbHandler->PrepareStatement(delCaptionInfo));

			stmtCaptionInfo->BindInt(1, *LocalCaptionIdIter);

			stmtCaptionInfo->ExecuteStatement();

		}

		// delete LocalizableAppInfo

		std::string delLocalizableAppInfo("DELETE FROM LocalizableAppInfo WHERE AppUid=?;");

		std::auto_ptr<CStatement> stmtLocalizableAppInfo(iScrDbHandler->PrepareStatement(delLocalizableAppInfo));

		stmtLocalizableAppInfo->BindInt(1, *appUidIter);

		stmtLocalizableAppInfo->ExecuteStatement();

	}

	// delete AppRegistrationInfo

	std::string delAppRegistrationInfo("DELETE FROM AppRegistrationInfo WHERE ComponentId=?;");

	std::auto_ptr<CStatement> stmtAppRegistrationInfo(iScrDbHandler->PrepareStatement(delAppRegistrationInfo));

	stmtAppRegistrationInfo->BindInt(1, aComponentId);

	stmtAppRegistrationInfo->ExecuteStatement();

	// delete component properties

	std::string delCompProps("DELETE FROM ComponentProperties WHERE ComponentId=?;");

	std::auto_ptr<CStatement> stmtDelCompProps(iScrDbHandler->PrepareStatement(delCompProps));

	stmtDelCompProps->BindInt(1, aComponentId);

	stmtDelCompProps->ExecuteStatement();

	// delete component file properties

	std::string delFileProps("DELETE from FileProperties WHERE CmpFileId IN \

				(SELECT CmpFileId FROM ComponentsFiles WHERE ComponentId=?);");

	std::auto_ptr<CStatement> stmtDelFileProps(iScrDbHandler->PrepareStatement(delFileProps));

	stmtDelFileProps->BindInt(1, aComponentId);

	stmtDelFileProps->ExecuteStatement();

	// delete component files

	std::string delCompFiles("DELETE FROM ComponentsFiles WHERE ComponentId=?;");

	std::auto_ptr<CStatement> stmtCompFiles(iScrDbHandler->PrepareStatement(delCompFiles));

	stmtCompFiles->BindInt(1, aComponentId);

	stmtCompFiles->ExecuteStatement();

	// delete component localizables

	std::string delCompLocs("DELETE FROM ComponentLocalizables WHERE ComponentId=?;");

	std::auto_ptr<CStatement> stmtCompLocs(iScrDbHandler->PrepareStatement(delCompLocs));

	stmtCompLocs->BindInt(1, aComponentId);

	stmtCompLocs->ExecuteStatement();

	// delete component dependencies

	std::string delCompDeps("DELETE FROM ComponentDependencies WHERE GlobalIdHash IN \

				(SELECT GlobalIdHash FROM Components WHERE ComponentId=?);");

	std::auto_ptr<CStatement> stmtCompDeps(iScrDbHandler->PrepareStatement(delCompDeps));

	stmtCompDeps->BindInt(1, aComponentId);

	stmtCompDeps->ExecuteStatement();

	// delete components

	std::string delComps("DELETE FROM Components WHERE ComponentId=?;");

	std::auto_ptr<CStatement> stmtComps(iScrDbHandler->PrepareStatement(delComps));

	stmtComps->BindInt(1, aComponentId);

	stmtComps->ExecuteStatement();

	}

int DbHelper::GetSelectedDrive( TInt32 aComponentId )

	{

	std::string selectDrive("SELECT IntValue FROM ComponentProperties WHERE ComponentId=? and Name='CompSelectedDrive';");

	std::auto_ptr<CStatement> stmtDrive(iScrDbHandler->PrepareStatement(selectDrive));

	stmtDrive->BindInt(1, aComponentId);

	if(stmtDrive->ProcessNextRow())

		return stmtDrive->IntColumn(0);

	return DbConstants::KDefaultInstalledDrive;

	}

bool DbHelper::InternalizeIfExists(SisRegistryObject& aSisRegistryObject, const TUint32 aUid ) const

	{

	TInt32 componentId = GetComponentId(aUid);

	if(componentId == DbHelper::Absent)

		{

		return false;

		}

	// retrieve all details from componentproperties

	GetComponentDetails(componentId, aSisRegistryObject);

	GetComponentLocalizables(componentId, aSisRegistryObject);

	// retrieve all files for this component Id from the componentfiles table

	GetFileDescriptions(componentId, aSisRegistryObject);

	GetComponentProperties(componentId, aSisRegistryObject);

	return true;

	}

bool DbHelper::SidExists(const TUint32 aSid) const

	{

	std::string selectSid("SELECT IntValue FROM ComponentProperties WHERE Name like 'CompSid%' and IntValue=?;");

	std::auto_ptr<CStatement> stmtSid(iScrDbHandler->PrepareStatement(selectSid));

	stmtSid->BindInt(1, aSid);

	if(!stmtSid->ProcessNextRow())

		return false;

	TInt32 sid = stmtSid->IntColumn(0);

	return ( sid == aSid );

	}

TUint32 DbHelper::GetUid(const TUint32 aSid) const

	{

	std::string selectUid("SELECT IntValue FROM ComponentProperties WHERE ComponentId in \

						(SELECT ComponentId from ComponentProperties where Name like 'CompSid%' and IntValue=?) and Name='CompUid';");

	std::auto_ptr<CStatement> stmtUid(iScrDbHandler->PrepareStatement(selectUid));

	stmtUid->BindInt(1, aSid);

	if(stmtUid->ProcessNextRow())

		return stmtUid->IntColumn(0);

	return DbHelper::Absent;

	}

TUint32 DbHelper::GetUid( const std::wstring& aSidFile ) const

	{

	std::string selectCompId("SELECT ComponentId FROM ComponentProperties WHERE StrValue=? and Name like 'CompSidFileName%';");

	std::auto_ptr<CStatement> stmtCompId(iScrDbHandler->PrepareStatement(selectCompId));

	stmtCompId->BindStr(1, aSidFile);

	if(!stmtCompId->ProcessNextRow())

		return DbHelper::Absent;

	TInt32 componentId = stmtCompId->IntColumn(0);

	return GetUid(componentId);

	}

std::wstring DbHelper::SidToFileName(TUint32 aSid) const

	{