/*

* 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:  Mifconv argument manager class.

*

*/

#include "mifconv.h"

#include "mifconv_argumentmanager.h"

#include "mifconv_exception.h"

#include "mifconv_util.h"

// Static singleton initialization

MifConvArgumentManager* MifConvArgumentManager::iInstance = 0;

/**

 * Returns pointer to the singleton object

 */

MifConvArgumentManager* MifConvArgumentManager::Instance()

{

    if( iInstance == 0 )

    {

        iInstance = new MifConvArgumentManager();

    }

    return iInstance;

}

/**

 * Free the allocated memory

 */

void MifConvArgumentManager::Reset()

{

    delete iInstance;

    iInstance = 0;

}

/**

 *

 */

inline void MifConvArgumentManager::THROW_USAGE_EXCEPTION() const

{

	MifConvString usageStr;

	SetUsageString(usageStr);

	throw MifConvException(usageStr, MifConvString(__FILE__), __LINE__);

}

inline void MifConvArgumentManager::THROW_ERROR( const MifConvString& errorMsg, const MifConvString& file, int line ) const

{    

    throw MifConvException( MifConvString("ERROR: " + errorMsg + "\nType mifconv -? for help\n"), file, line);

}

/**

 *

 */

MifConvArgumentManager::MifConvArgumentManager()

:

iEpocRoot(DEFAULT_EPOCROOT)

{

    GetMifEnv();

}

/**

 *

 */

MifConvArgumentManager::~MifConvArgumentManager()

{}

/**

 * This function checks if the given argument is boolean type of argument.

 * Boolean type arguments are listed in a <code>MifConvBooleanArguments</code> table

 * and this function checks if the given string matches any of those. Returns the length

 * of the argument name if found, zero otherwise.

 */

size_t MifConvArgumentManager::IsBooleanArgument( const MifConvString& argName ) const

{

	if( IsArgument(argName) )

	{

		try {

			int tblSize = sizeof(MifConvBooleanArguments) / sizeof(MifConvString);

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

			{

				size_t tmpLen = MifConvBooleanArguments[i].length();

				if( argName.length() > tmpLen )

				{

                    if( MifConvUtil::CompareIgnoreCase(MifConvString(argName.begin()+1, argName.begin() + 1 + tmpLen), MifConvBooleanArguments[i]) == 0 )

					{

						return tmpLen;

					}

				}

			}

		}

		catch(...)

		{

			THROW_USAGE_EXCEPTION();

		}

	}

	return 0;

}

/**

 * This function checks if the given argument is a help argument.

 * Help arguments are listed in a <code>MifConvHelpArguments</code> table

 * and this function checks if the given string matches any of those. Returns the length

 * of the argument name if found, zero otherwise.

 */

size_t MifConvArgumentManager::IsHelpArgument( const MifConvString& argName ) const

{

	if( IsArgument(argName) )

	{

		try {

			int tblSize = sizeof(MifConvHelpArguments) / sizeof(MifConvString);

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

			{

				size_t tmpLen = MifConvHelpArguments[i].length();

                // Following check separates -H from -Hheadername.mbg parameter:

                if( argName.length() == tmpLen+1 )

				{

                    if( MifConvUtil::CompareIgnoreCase(MifConvString(argName.begin()+1, argName.begin() + 1 + tmpLen), MifConvHelpArguments[i]) == 0 )

					{

						return tmpLen;

					}

				}

			}

		}

		catch(...)

		{

			THROW_USAGE_EXCEPTION();

		}

	}

	return 0;

}

/**

 * This function checks if the given argument is string type of argument.

 * String type arguments are listed in a <code>MifConvStringArguments</code> table

 * and this function checks if the given string matches any of those. Returns the length

 * of the argument name if found, zero otherwise.

 */

size_t MifConvArgumentManager::IsStringArgument( const MifConvString& argName ) const

{    

	if( IsArgument(argName) )

	{

		try {

			int tblSize = sizeof(MifConvStringArguments) / sizeof(MifConvString);

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

			{

				size_t tmpLen = MifConvStringArguments[i].length();

				if( argName.length() > tmpLen )

				{

                    if( MifConvUtil::CompareIgnoreCase(MifConvString(argName.begin()+1, argName.begin()+1+tmpLen), MifConvStringArguments[i]) == 0 )

					{

						return tmpLen;

					}

				}				

			}

		}

		catch(...)

		{

			THROW_USAGE_EXCEPTION();

		}

	}

	return 0;

}

/**

 * This function checks if the given argument is string list type of argument.

 * String list type arguments are listed in a <code>MifConvStringListArguments</code> table

 * and this function checks if the given string matches any of those. Returns the length

 * of the argument name if found, zero otherwise.

 */

size_t MifConvArgumentManager::IsStringListArgument( const MifConvString& argName ) const

{

	if( IsArgument(argName) )

	{

		try {

			int tblSize = sizeof(MifConvStringListArguments) / sizeof(MifConvString);

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

			{

				size_t tmpLen = MifConvStringListArguments[i].length();

				if( argName.length() > tmpLen )

				{

                    if( MifConvUtil::CompareIgnoreCase(MifConvString(argName.begin()+1, argName.begin()+1+tmpLen), MifConvStringListArguments[i]) == 0 )

					{

						return tmpLen;

					}

				}				

			}

		}

		catch(...)

		{

			THROW_USAGE_EXCEPTION();

		}

	}

	return 0;

}

/**

 *

 */

bool MifConvArgumentManager::IsDepthArgument( const MifConvString& argName ) const

{

	if( IsArgument(argName) )

	{

		try {

			int tblSize = sizeof(MifConvDepthArguments) / sizeof(MifConvString);

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

			{

				size_t tmpLen = MifConvDepthArguments[i].length();

                if( argName.length() > tmpLen )

				{

                    MifConvString trimmedArgument(argName.begin()+1, argName.begin() + 1 + tmpLen);                

                    if( MifConvUtil::CompareIgnoreCase(trimmedArgument, MifConvDepthArguments[i]) == 0 )

					{

						return true;

					}                    

				}

			}

		}

		catch(...)

		{

			THROW_USAGE_EXCEPTION();

		}

	}

	return false;

}

/**

 *

 */

bool MifConvArgumentManager::IsAnimatedFlag( const MifConvString& argName ) const

{

	return IsArgument( argName ) && argName.length() > MifConvAnimatedIconArg.length() && 

        MifConvUtil::CompareIgnoreCase(MifConvString(argName.begin()+1, argName.end() ), MifConvAnimatedIconArg ) == 0;

}

/**

 *

 */

void MifConvArgumentManager::SetTargetFile( const MifConvString& arg )

{

	iTargetFile = arg;

}

/**

 *

 */

const MifConvString& MifConvArgumentManager::TargetFile() const

{

	return iTargetFile;

}

/**

 *

 */

IconDisplayMode MifConvArgumentManager::ConvertToDisplayMode(IconDepth depth) const

{

    MifConvIconDisplayModeMap::const_iterator i = iDisplayModeMap.find(depth);

    if( i != iDisplayModeMap.end() )

        return i->second;

    return DisplayMode_None;    

}

/**

 *

 */

IconDisplayMode MifConvArgumentManager::ConvertToMaskDisplayMode(IconMaskDepth depth) const

{

    MifConvMaskIconDisplayModeMap::const_iterator i = iMaskDisplayModeMap.find(depth);

    if( i != iMaskDisplayModeMap.end() )

        return i->second;

    return DisplayMode_None;    

}

/**

 *

 */

IconDepth MifConvArgumentManager::ConvertToDepth( const MifConvString& depthStr ) const

{

    MifConvIconDepthMap::const_iterator i = iDepthMap.find(depthStr);

    if( i != iDepthMap.end() )

        return i->second;

    return IconDepth_Undefined;    

}

/**

 *

 */

IconMaskDepth MifConvArgumentManager::ConvertToMaskDepth( const MifConvString depthStr ) const

{

    MifConvIconMaskDepthMap::const_iterator i = iMaskDepthMap.find(depthStr);

    if( i != iMaskDepthMap.end() )

        return i->second;

    return IconMaskDepth_Undefined;    

}

/**

 *

 */

void MifConvArgumentManager::Init( const MifConvStringList& argList )

{	    

    // Build maps for mapping depth, mask and displaymode constants:

    PopulateDepthAndMaskMaps();

    // Allocate search paths where to search source files:    

    MifConvString epocRoot(EpocRoot());

    // Global icons folder can contain only .svg files:

    iSearchRules.push_back(MifConvSourceSearchRule(MifConvString(epocRoot + S60_ICONS_PATH), vector<MifConvString>(1, SVG_FILE_EXTENSION)));

    // Global bitmaps folder can contain only .bmp files:

    iSearchRules.push_back(MifConvSourceSearchRule(MifConvString(epocRoot + S60_BITMAPS_PATH), vector<MifConvString>(1, BMP_FILE_EXTENSION)));

    // EPOCROOT, if given in environment variables:

    if( epocRoot.length() > 0 )

    {

        iSearchRules.push_back(MifConvSourceSearchRule(epocRoot+EPOC32_PATH, vector<MifConvString>(1, MIFCONV_WILDCARD)));

    }

    AddArguments(argList);

    // check if the parameter file is given:

    const MifConvString& paramFilename = StringValue(MifConvParameterFileArg);

    if( paramFilename.length() > 0 )

    {

        // Add arguments from the parameter file:

        MifConvStringList paramListFromFile;

        ReadParameterFile( paramFilename, paramListFromFile );

        if( paramListFromFile.size() > 0 )

        {

            AddArguments(paramListFromFile, true);

        }

    }

    // Resolve file type extensions using given flags and investigating the existing files:

	FinalizeArguments();

}

/**

 * Read string argument value:

 */

MifConvString MifConvArgumentManager::ReadStringArgument(const MifConvStringList& argList, MifConvStringList::const_iterator& i, unsigned int argNameLen)

{    

    // Take the actual argument value, for example /TmyTempDir --> myTempDir    

    MifConvString argValue((*i).begin() + argNameLen, (*i).end());

    if( argValue.length() > 0 )

    {

        // String arguments can have spaces when they are enclosed with " marks (For example directory names).

        if( argValue[0] == '\"' )

        {

            MifConvString quotedArgValue(argValue);

            // Check if the last char is also ":

            if( quotedArgValue[ quotedArgValue.length()-1 ] == '\"' )

            {                

                return quotedArgValue;

            }

            // See if the next string ends with \" mark, for example "My Folder" is presented with following argument list:

            // argList[0] = "My

            // argList[1] = Folder"

            while(++i != argList.end())

            {

                MifConvString nextString((*i).begin(), (*i).end());

                quotedArgValue += " " + nextString;

                if( nextString[ nextString.length()-1 ] == '\"' )

                {                    

                    return "\"" + quotedArgValue + "\"";

                }

            }

        }

    }    

    return argValue;

}

/**

 * Read string argument value:

 */

void MifConvArgumentManager::ReadStringListArgument(MifConvStringList::const_iterator& i, unsigned int argNameLen, MifConvStringList& StringValueList)

{    

    // Take the actual argument value, for example /imyInputDir;myTempDir --> myTempDir    

    MifConvString argValue((*i).begin() + argNameLen, (*i).end());    

    MifConvUtil::SplitString( argValue, STRING_LIST_ARGUMENT_SEPARATOR, StringValueList );

}

/**

 *

 */

void MifConvArgumentManager::AddArguments( const MifConvStringList& argList, bool paramsFromFile )

{

	MifConvStringList::const_iterator i = argList.begin();

	if( i == argList.end() )

	{		

        THROW_ERROR("No arguments", MifConvString(__FILE__), __LINE__);	

	}

    // Check if help is needed:

    while( i != argList.end() )

    {

        if( IsHelpArgument(*i) )

        {

            THROW_USAGE_EXCEPTION();

        }

        ++i;

    }

    i = argList.begin();

	while( i != argList.end() )

	{	        

		unsigned int argLen = 0;

		if( i == argList.begin() && paramsFromFile == false )

		{

			// First command line argument must be the target file.

            // If the given list (argList) is read from the file, then

            // the first one is not target file.

			if( !IsArgument(*i) )

			{           

			    MifConvString targetFile(ReadStringArgument( argList, i, 0 ));			    

			    // Make sure that the file extension is .mif:

			    targetFile = MifConvUtil::FilenameWithoutExtension(targetFile);

			    targetFile += MifConvString(FILE_EXTENSION_SEPARATOR) + MifConvString(MIF_FILE_EXTENSION);

				SetTargetFile(targetFile);                

			}

			else

			{

                THROW_ERROR( "Target file must be given as first argument.", MifConvString(__FILE__), __LINE__ );                

			}

			++i;

            if( i == argList.end() )

            {

                THROW_ERROR("Missing arguments", MifConvString(__FILE__), __LINE__);

            }

		}

		else if( IsBooleanArgument(*i) )

		{

			// Insert boolean type argument to the boolean arguments list:

			MifConvString argName((*i).begin()+1, (*i).end());

            MifConvUtil::ToLower(argName); // Lower the cases to make comparison easier later

            std::pair<BooleanArgMap::iterator, bool> res = iBooleanArguments.insert(std::make_pair<MifConvString, MifConvBooleanArgument>(

				argName, MifConvBooleanArgument( argName, true )));

            if( res.second == false )

            {

                // parameter already exists in the map, update the value:

                res.first->second = MifConvBooleanArgument( argName, true );

            }

			++i;

		}

		else if( (argLen = (unsigned int) IsStringArgument(*i) ) > 0 )

		{			

			MifConvString argName((*i).begin()+1, (*i).begin() + 1 + argLen);

            MifConvUtil::ToLower(argName); // Lower the cases to make comparison easier later			

            MifConvString argValue(ReadStringArgument( argList, i, argLen+1 ));            

			if( argValue.length() == 0 )

			{

				// Do not accept string arguments with zero length (E.g. "/H")

                THROW_ERROR( "Missing argument value for " + *i, MifConvString(__FILE__), __LINE__ );                

			}

			// Insert string type argument to the string arguments list:

			std::pair<StringArgMap::iterator, bool> res = iStringArguments.insert(std::make_pair<MifConvString, MifConvStringArgument>(

				argName, MifConvStringArgument( argName, argValue )));

            if( res.second == false )

            {

                // parameter already exists in the map, update the value:

                res.first->second = MifConvStringArgument( argName, argValue );

            }

			++i;

		}

        else if( (argLen = (unsigned int) IsStringListArgument(*i)) > 0 )

        {

            MifConvString argName((*i).begin()+1, (*i).begin() + 1 + argLen);

            MifConvUtil::ToLower(argName); // Lower the cases to make comparison easier later			

            MifConvStringList argValue;

            ReadStringListArgument( i, argLen+1, argValue );

            if( argValue.size() == 0 )

			{

				// Do not accept string arguments with zero length (E.g. "/H")

                THROW_ERROR( "Missing argument value for " + *i, MifConvString(__FILE__), __LINE__ );                

			}

			// Insert string list type argument to the string arguments list:

			std::pair<StringListArgMap::iterator, bool> res = iStringListArguments.insert(std::make_pair<MifConvString, MifConvStringListArgument>(

				argName, MifConvStringListArgument( argName, argValue )));

            if( res.second == false )

            {

                // parameter already exists in the map, update the value:

                res.first->second = MifConvStringListArgument( argName, argValue );

            }

			++i;

        }

		else if( IsDepthArgument(*i) )

		{

			// Let's build source file argument...

			// ... first is depth and mask:

			MifConvString depthAndMask(*i);

            MifConvUtil::ToLower(depthAndMask); // Lower the cases to make comparison easier later

			++i;

            // Check that there is still an argument:

            if( i == argList.end() )

            {

                THROW_ERROR( "Missing source file argument.", MifConvString(__FILE__), __LINE__ );                

            }

			// Then we check if animated flag is given next:

			bool isAnimated = IsAnimatedFlag(*i);

			if( isAnimated )

			{

				// This was an animated flag, so next must be filename:

				++i;

                // Check that there is still an argument:

                if( i == argList.end() )