/*

* Copyright (c) 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:  Definitions for the class CATBase.

*

*/

#include "../inc/CATBase.h"

#include "../inc/CATParseXML.h"

// -----------------------------------------------------------------------------

// CATBase::CATBase

// Constructor.

// -----------------------------------------------------------------------------

CATBase::CATBase(void)

{

	LOG_FUNC_ENTRY("CATBase::CATBase");

}

// -----------------------------------------------------------------------------

// CATBase::~CATBase

// Destructor.

// -----------------------------------------------------------------------------

CATBase::~CATBase(void)

{

	LOG_FUNC_ENTRY("CATBase::~CATBase");

}

// -----------------------------------------------------------------------------

// CATBase::ChangeToLower

// Converts any uppercase letter to lowercase.

// -----------------------------------------------------------------------------

void CATBase::ChangeToLower( string& sInput )

{

	LOG_LOW_FUNC_ENTRY("CATBase::ChangeToLower");

	int iLength = (int)sInput.size();

	for( int i = 0 ; i < iLength ; i++ )

	{

		sInput[i] = (char)tolower( sInput[i] );

	}

}

// -----------------------------------------------------------------------------

// CATBase::ChangeToUpper

// Converts any uppercase letter to lowercase.

// -----------------------------------------------------------------------------

void CATBase::ChangeToUpper( string& sInput )

{

	LOG_LOW_FUNC_ENTRY("CATBase::ChangeToUpper");

	int iLength = (int)sInput.size();

	for( int i = 0 ; i < iLength ; i++ )

	{

		sInput[i] = (char)toupper( sInput[i] );

	}

}

// -----------------------------------------------------------------------------

// CATBase::TrimString

// Remove spaces and tabulatures from beginning and

// end of given string.

// -----------------------------------------------------------------------------

void CATBase::TrimString( string& sInput )

{

	LOG_LOW_FUNC_ENTRY("CATBase::TrimString");

	if( sInput.empty() )

		return;

	//Remove spaces and tabulatures from beginning of string

	while( !sInput.empty() && ( sInput[0] == SPACE_CHAR_VALUE || sInput[0] == TAB_CHAR_VALUE ) )

	{

		sInput.erase( 0, 1 );

	}

	//Remove spaces and tabulatures from end of string

	while( !sInput.empty() && ( sInput[sInput.size()-1] == SPACE_CHAR_VALUE || sInput[sInput.size()-1] == TAB_CHAR_VALUE ) )

	{

		sInput.erase( sInput.size()-1, 1 );

	}

}

// -----------------------------------------------------------------------------

// CATBase::SearchFileWithExtension

// Searches files with given extension from path.

// -----------------------------------------------------------------------------

bool CATBase::SearchFileWithExtension( const char* pPathAndExt, bool bPrintErrors, string& sErrorLog )

{

	LOG_FUNC_ENTRY("CATBase::SearchFileWithExtension");

	WIN32_FIND_DATA FindFileData;

	HANDLE hFind;

	string sTemp( pPathAndExt );

	//Find file

	hFind = FindFirstFile( sTemp.c_str(), &FindFileData );

	if (hFind == INVALID_HANDLE_VALUE)

	{

		string sErrorString( "No " );

		//Get extension

		string sExt( pPathAndExt );

		sExt.erase( 0, sExt.find_last_of( "." ) );

		sErrorString.append( sExt );

		sErrorString.append( " files in directory: " );

		string sWithoutExt( pPathAndExt );

		sWithoutExt.erase( sWithoutExt.find_last_of( "." )-1, string::npos );

		sErrorString.append( sWithoutExt );

		if( bPrintErrors )

		{

			//string sTemp( pPathAndExt );

			//printf( "Can not find: %s.\n", pPathAndExt );

			printf( sErrorString.c_str() );

		}

		else

		{

			//Add line change if sErrorString not empty

			if( !sErrorLog.empty() )

				sErrorString.insert( 0, "\n" );

			sErrorLog.append( sErrorString );

		}

		return false;

	} 

	else 

	{

		FindClose(hFind);

		return true;

	}

}

// -----------------------------------------------------------------------------

// CATBase::GetPathOrFileName

// Returns path to file or file name.

// -----------------------------------------------------------------------------

string CATBase::GetPathOrFileName( bool bFileName, string sInput )

{

	LOG_LOW_FUNC_ENTRY("CATBase::GetPathOrFileName");

	string sRet;

	sInput = ChangeSlashToBackSlash( sInput );

	//Find character '\' starting from end of string

	while( iPos > 0 && sInput[iPos] != '\\' )

	{

		iPos--;

	}

	if( iPos > 0 )

	{

		//Return file name

		if( bFileName )

		{

			sInput.erase( 0, iPos+1 );

			sRet = sInput;

		}

		else //Return file path

		{

			sInput.erase( iPos+1, string::npos );

			sRet = sInput;

		}

	}

	else

	{

		if( !bFileName )

			return sRet;

		sRet = sInput;

	}

	return sRet;

}

// -----------------------------------------------------------------------------

// CATBase::GetFileNameUsingExt

// Searches files with given extension from path.

// -----------------------------------------------------------------------------

string CATBase::GetFileNameUsingExt( const char* pPathAndExt )

{

	LOG_FUNC_ENTRY("CATBase::GetFileNameUsingExt");

	WIN32_FIND_DATA FindFileData;

	HANDLE hFind;

	string sRet;

	//Find file

	hFind = FindFirstFile( pPathAndExt, &FindFileData );

	if (hFind == INVALID_HANDLE_VALUE)

	{

		//if( bPrintErrors )

		printf( "Can not find: %s.\n", pPathAndExt );

		return sRet;

	} 

	else 

	{

		sRet.append( FindFileData.cFileName );

		FindClose(hFind);

		return sRet;

	}

}

// -----------------------------------------------------------------------------

// CATBase::GetStringUntilNextSpace

// Function returns string from begin of given string until next space,

// characters until next space are removed from sInput string.

// -----------------------------------------------------------------------------

string CATBase::GetStringUntilNextSpace( string& sInput, bool bEraseFromInput )

{

	LOG_LOW_FUNC_ENTRY("CATBase::GetStringUntilNextSpace");

	string sTemp( sInput );

	size_t iSize = sTemp.find_first_of(' ');

	if( iSize != string::npos )

	{

		sTemp.resize( iSize );

		if( bEraseFromInput )

			sInput.erase( 0, (iSize+1) );

	}

	else

	{

		if ( bEraseFromInput )

			sInput.clear();

	}

	return sTemp;

}

// -----------------------------------------------------------------------------

// CATBase::ChangeSlashToBackSlash

// Function changes all BackSlash characters to Slash character from

// given string.

// -----------------------------------------------------------------------------

string CATBase::ChangeSlashToBackSlash( string sInput )

{

	LOG_LOW_FUNC_ENTRY("CATBase::ChangeSlashToBackSlash");

	for( unsigned int i = 0 ; i < sInput.length() ; i++ )

	{

		if( sInput[i] == '/' )

		{

			sInput[i] = '\\';

		}

	}

	return sInput;

}

// -----------------------------------------------------------------------------

// CATBase::FileExists

// Check if given file exists.

// -----------------------------------------------------------------------------

bool CATBase::FileExists( const char * pFilename )

{

	LOG_FUNC_ENTRY("CATBase::FileExists");

	DWORD dwRet = GetFileAttributes( pFilename );

	if( dwRet == INVALID_FILE_ATTRIBUTES )

	{

		return false;

	}

	else

	{

		//Is file directory?

		if( dwRet & FILE_ATTRIBUTE_DIRECTORY )

		{

			return false;

		}

	}

	return true;

}

bool CATBase::IsFileReadOnly( const char* pFilename )

{

	LOG_FUNC_ENTRY("CATBase::IsFileReadOnly");

	DWORD dwRet = GetFileAttributes( pFilename );

	if( dwRet == INVALID_FILE_ATTRIBUTES )

		return false;

	if( dwRet & FILE_ATTRIBUTE_READONLY )

		return true;

	return false;

}

bool CATBase::SetFileReadOnly( const char* pFileName )

{

	LOG_FUNC_ENTRY("CATBase::SetFileReadOnly");

	DWORD dw = GetFileAttributes( pFileName );

	if( dw == INVALID_FILE_ATTRIBUTES )

		return false;

	if( dw & FILE_ATTRIBUTE_READONLY )

		return true;

	dw = dw | FILE_ATTRIBUTE_READONLY ;

	if ( SetFileAttributes( pFileName, dw ) )

		return true;

	return false;

}

bool CATBase::SetFileWritable( const char* pFileName )

{

	LOG_FUNC_ENTRY("CATBase::SetFileWritable");

	DWORD dw = GetFileAttributes( pFileName );

	if( dw == INVALID_FILE_ATTRIBUTES )

		return false;

	if( ! dw & FILE_ATTRIBUTE_READONLY )

		return true;

	dw = dw ^ FILE_ATTRIBUTE_READONLY ;

	if ( SetFileAttributes( pFileName, dw ) )

		return true;

	return false;

}

// -----------------------------------------------------------------------------

// CATBase::FileCopyToPath

// Copies file to given path

// -----------------------------------------------------------------------------

bool CATBase::FileCopyToPath(const string& sFile, const string& sToPath)

{

	LOG_FUNC_ENTRY("CATBase::FileCopyToPath");

	// Display message

	cout << AT_MSG << "Copy " << sFile << AT_FILE_TO << sToPath << endl;

	if ( sFile.empty() || sToPath.empty() )

	{

		LOG_FUNC_EXIT("CATBase::FileCopyToPath Error, empty parameter");

		return false;

	}

	// Copy using windows api (seems not to work when relavite path ..

	/*

	// Full path where to copy

	string sDestination = sToPath;

	// Append '\' to string if not exists

	if ( sDestination.length() > 1 )

	{

		const char cLastChar = sDestination[ sDestination.length() -1 ];

		if ( cLastChar != DASH )

			sDestination.append("\\");

	}

	int iRet = 0;

	iRet = CopyFile( sFile.c_str(), sDestination.c_str(), false );

	if ( iRet != 0 )

	{

		return false;

	}

	*/

	string sCommand;

	sCommand.append( "copy /Y \"");

	sCommand.append( sFile );

	sCommand.append( "\" \"" );

	sCommand.append( sToPath );

	sCommand.append( "\" > nul 2>&1" );

	LOG_STRING( sCommand );

	int iRet = 0;

	iRet = (int)system( sCommand.c_str() );

	if ( iRet != 0 )

		return false;

	return true;

}

// -----------------------------------------------------------------------------

// CATBase::FileMoveToPath

// Copies file to given path

// -----------------------------------------------------------------------------

bool CATBase::FileMoveToPath(const string& sFile, const string& sToPath)

{

	LOG_FUNC_ENTRY("CATBase::FileMoveToPath");

	// Display message

	cout << AT_MSG << "Move " << sFile << AT_FILE_TO << sToPath << endl;

	if ( sFile.empty() || sToPath.empty() )

	{

		LOG_FUNC_EXIT("CATBase::FileMoveToPath Error, empty parameter");

		return false;

	}

	// Move (again windows api function does not support relative path .. in it

	/*

	// Get filename from sFile

	string sFileName = GetPathOrFileName( true, sFile );

	// Full path where to copy

	string sDestination = sToPath;

	// Append '\' to string if not exists

	if ( sDestination.length() > 1 )

	{

		const char cLastChar = sDestination[ sDestination.length() -1 ];

		if ( cLastChar != DASH )

			sDestination.append("\\");

	}

	int iRet = 0;

	iRet = MoveFile( sFile.c_str(), sDestination.c_str());

	if ( iRet != 0 )

	{

		return false;

	}

	*/

	string sCommand;

	sCommand.append( "move /Y \"");

	sCommand.append( sFile );

	sCommand.append( "\" \"" );

	sCommand.append( sToPath );

	sCommand.append( "\" > nul 2>&1" );

	LOG_STRING( sCommand );

	int iRet = 0;

	iRet = (int)system( sCommand.c_str() );

	if ( iRet != 0 )

		return false;

	return true;

}

// -----------------------------------------------------------------------------

// CATBase::CreateTempPath

// Creates temporary directory path for given mmp file

// -----------------------------------------------------------------------------

string CATBase::CreateTempPath(const string& sMmpFileWithPath)

{

	LOG_FUNC_ENTRY("CATBase::CreateTempPath");

	string sTempPath = GetPathOrFileName( false, sMmpFileWithPath );

	sTempPath.append( AT_TEMP_DIR );

	sTempPath.append( "\\" );

	return sTempPath;

}

// -----------------------------------------------------------------------------

// CATBase::RemovePathAndExt

// Removes extension from file name and returns file name without extension.

// -----------------------------------------------------------------------------

string CATBase::RemovePathAndExt( string sFileName, bool bReverseFindExt)

{

	LOG_LOW_FUNC_ENTRY("CATBase::RemovePathAndExt");

	string sRet;

	sFileName = GetPathOrFileName( true, sFileName );

	if ( bReverseFindExt )

	{

		// Remove extension from reverse

		size_t iPos = sFileName.find_last_of('.');

		if( iPos != string::npos )

		{

			sFileName.resize( sFileName.find_last_of('.') );

			sRet = sFileName;

		}

	}

	else

	{

		// Remove extension finding first .

		size_t iPos = sFileName.find_first_of('.');

		if( iPos != string::npos )

		{

			sFileName.resize( sFileName.find_first_of('.') );

			sRet = sFileName;

		}

	}

	return sRet;

}

// -----------------------------------------------------------------------------

// CATBase::IsTargetTypeSupported

// Checks from constant array is this target unsupported

// -----------------------------------------------------------------------------

bool CATBase::IsTargetTypeSupported(string sTargetType)

{

	LOG_FUNC_ENTRY("CATBase::IsTargetTypeSupported");

	// compare to list

	int iArraySize = sizeof( UNSUPPORTED_TARGET_TYPES ) / sizeof( string );

	for ( int i=0 ; i < iArraySize ; i++ )

	{

		string sUnsupported = UNSUPPORTED_TARGET_TYPES[i];

		// lowercase both

		ChangeToLower(sTargetType);

		ChangeToLower(sUnsupported);

		// compare

		if ( sUnsupported.compare( sTargetType ) == 0 )

		{

			return false;

		}

	}

	return true;

}

// -----------------------------------------------------------------------------

// CATBase::IsTargetTypeKernelSide

// Checks from constant array is this target type kernel side

// -----------------------------------------------------------------------------

bool CATBase::IsTargetTypeKernelSide(string sTargetType)

{

	LOG_FUNC_ENTRY("CATBase::IsTargetTypeKernelSide");

	// compare to list

	int iArraySize = sizeof( KERNEL_SIDE_TARGET_TYPES ) / sizeof( string );

	for ( int i=0 ; i < iArraySize ; i++ )

	{

		string sUnsupported = KERNEL_SIDE_TARGET_TYPES[i];

		// lowercase both

		ChangeToLower(sTargetType);

		ChangeToLower(sUnsupported);

		// compare

		if ( sUnsupported.compare( sTargetType ) == 0 )

		{

			return true;

		}

	}

	return false;

}

bool CATBase::CheckVariant( const string& sEpocRoot, const string& sVariant )

{

	LOG_FUNC_ENTRY("CATBase::CheckVariant");

	string sFileToCheck;

	// Add epoc root

	if( sEpocRoot.size() > 1 )

		sFileToCheck.append( sEpocRoot );

	// Add path

	sFileToCheck.append( VARIANT_DIR ) ;

	// Add variant

	sFileToCheck.append( sVariant );

	// Add extension

	sFileToCheck.append( VARIANT_FILE_EXTENSION );

	// check does FileExists

	return FileExists( sFileToCheck.c_str() );

}

bool CATBase::IsDefaultVariant( const string& sEpocRoot )

{

	LOG_FUNC_ENTRY("CATBase::IsDefaultVariant");

	string sFileToCheck;

	// Add epoc root

	if( sEpocRoot.size() > 1 )

		sFileToCheck.append( sEpocRoot );

	// Add path

	sFileToCheck.append( VARIANT_DIR ) ;

	// Add variant

	sFileToCheck.append( "DEFAULT" );

	// Add extension

	sFileToCheck.append( VARIANT_FILE_EXTENSION );

	// check does FileExists

	return FileExists( sFileToCheck.c_str() );

}

// -----------------------------------------------------------------------------