/*

* 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 utilities.

*

*/

#include "mifconv.h"

#include "mifconv_util.h"

#include "mifconv_exception.h"

#include "mifconv_argumentmanager.h"

#include <sys/stat.h>   // for stat

#ifdef WIN32

    #include <direct.h>     // for _getcwd, _chdir, _mkdir

#else

    #include <unistd.h>

#endif

#include <stdlib.h>     // for _MAX_PATH

#include <stdio.h>

#ifndef _MAX_PATH

#define _MAX_PATH   (260)

#endif

MifConvUtil::MifConvDebugMode MifConvUtil::iDebugMode = DebugMode_Unknown;

MifConvString MifConvUtil::iDebugFile = "";

MifConvString MifConvUtil::iTempDirectory = "";

/**

 *

 */

MifConvString MifConvUtil::FileExtension( const MifConvString& fileName )

{	

	size_t indexOfDot; // index of '.' character in the given string

	// Find last occurence of the '.' character

	if( ( indexOfDot = fileName.find_last_of('.') ) == MifConvString::npos )

	{

		// Not found, return empty string

		return MifConvString("");

	}

	// Return the substring starting after the '.' character

	return MifConvString( fileName.begin()+indexOfDot+1, fileName.end() );

}

/**

 *

 */

MifConvString MifConvUtil::FilenameWithoutExtension( const MifConvString& fileName )

{	

	size_t indexOfDot; // index of '.' character in the given string

	// Find last occurence of the '.' character

	if( ( indexOfDot = fileName.find_last_of('.') ) == MifConvString::npos )

	{

		// Not found, return the whole name

		return fileName;

	}

	// Return the substring preceding the last '.' character

	return MifConvString( fileName.begin(), fileName.begin() + indexOfDot );

}

/**

 *

 */

MifConvString MifConvUtil::FilenameWithoutPath( const MifConvString& fileName )

{	

	size_t indexOfDirSeparator; // index of directory separator in the given string

	// Find last occurence of the '.' character

	if( ( indexOfDirSeparator = fileName.find_last_of(DIR_SEPARATOR2) ) == MifConvString::npos )

	{

		// Not found, return the whole name

		return fileName;

	}

	// Return the substring beginnig after the last directory separator

	return MifConvString( fileName.begin()+indexOfDirSeparator+1, fileName.end() );

}

/**

 *

 */

bool MifConvUtil::FileExists( const MifConvString& fileName )

{

  struct stat fileInfo;   

  int retVal = 0; 

  // Try to get file attributes to see if the file exists or not:

  retVal = stat( fileName.c_str(), &fileInfo); 

  return retVal == 0;

}

/**

 *

 */

size_t MifConvUtil::FileSize( const MifConvString& fileName )

{

  struct stat fileInfo;   

  int retVal = 0; 

  // Try to get file attributes to see if the file exists or not:

  retVal = stat( fileName.c_str(), &fileInfo); 

  if( retVal != 0 )

  {

      THROW_ERROR_COMMON("File not found: " + fileName, MifConvString(__FILE__), __LINE__);

  }

  return fileInfo.st_size;

}

/**

 *

 */

MifConvFileData MifConvUtil::FileContents( const MifConvString& fileName )

{

    unsigned int fileLen = (unsigned int) (MifConvUtil::FileSize(fileName)/sizeof(char));

    ifstream fs( fileName.c_str(), FILE_IN_BINARY_NOCREATE_FLAGS );

    if (!fs.is_open())

    {

        THROW_ERROR_COMMON("Unable to open file for reading! " + fileName, MifConvString(__FILE__), __LINE__);

    }

    char* buffer = new char[fileLen];

    fs.read(buffer, fileLen);

    return MifConvFileData(buffer, fileLen);

}

/**

 *

 */

void MifConvUtil::ReplaceChar( MifConvString& str, char replaceFrom, char replaceTo)

{

    if( str.length() > 0 )

    {        

        MifConvString::size_type index = 0;

        while( (index = str.find(replaceFrom, index)) != MifConvString::npos )

        {     

            str.replace(index,1,1,replaceTo);

        }

    }

}

/**

 *

 */

void MifConvUtil::SplitPath( const MifConvString& sourcePath, MifConvString& drive, MifConvString& path)

    {    

        if( sourcePath.length() > 0 )

        {

            size_t driveSeparatorPos = sourcePath.find(':');

            if( driveSeparatorPos != MifConvString::npos )

            {

                drive = MifConvString(sourcePath.begin(), sourcePath.begin() + driveSeparatorPos );

                path = MifConvString(sourcePath.begin() + driveSeparatorPos + 1, sourcePath.end() );

            }

            else

            {

                path = sourcePath;

            }

        }

        else

        {

            drive = MifConvString("");

            path = MifConvString("");

        }

}

/**

 *

 */

MifConvString MifConvUtil::CurrentPath()

{

    char temp[_MAX_PATH];

#ifdef WIN32    

    _getcwd(temp, _MAX_PATH);    

#else

    getcwd(temp, _MAX_PATH);

#endif

    return MifConvString(temp);

}

/**

 *

 */

int MifConvUtil::CompareIgnoreCase( const MifConvString& lhs, const MifConvString& rhs )

{

    MifConvString lhsCopy(lhs);

    MifConvString rhsCopy(rhs);

    return ToLower(lhsCopy).compare(ToLower(rhsCopy));

}

/**

 *

 */

MifConvString& MifConvUtil::ToLower( MifConvString& str )

{

    MifConvString::iterator it(str.begin());

    for(; it != str.end(); ++it)

    {

        *it = (char) tolower((unsigned char)*it);

    }

    return str;

}

/**

 *

 */

void MifConvUtil::EnsurePathExists( const MifConvString& destFileName, bool ignoreLast )

    {

    MifConvString currentPath;

    MifConvString tmpDrive;    

    MifConvString tmpPath;

    // Parse a drive of a destination path; if any

    SplitPath( destFileName, tmpDrive, tmpPath );

    // Save current directory    

    currentPath = CurrentPath();

    // Change drive if needed:

    if( tmpDrive.length() > 0 )

    {        

        tmpDrive += ":";

        tmpDrive += DIR_SEPARATOR;

        ChangeDirectory(tmpDrive);        

    }

    // Split desination path to separate directories:

    MifConvStringList destDirList;

    // Check if the root is given first and add it to dir list:

    if( tmpPath.length() > 0 && tmpPath.at(0) == DIR_SEPARATOR2 )

    {

        destDirList.push_back(DIR_SEPARATOR);

    }

    // Add other directories to destination dir list:

    SplitString( tmpPath, DIR_SEPARATOR, destDirList );

    // Remove last component from the list if it should be ignored:

    if( ignoreLast )

    {

        destDirList.pop_back();

    }

    unsigned int i = 0;

    while( i < destDirList.size() )

    {        

        const MifConvString& dir = destDirList[i++];         

        if( !FileExists(dir) )

        {

            if( !CreateDirectory( dir ) )

            {

                // Change back to original directory:

                ChangeDirectory( currentPath );

                THROW_ERROR_COMMON("Directory " + tmpPath + " cannot be created", MifConvString(__FILE__), __LINE__);

            }

        }

        ChangeDirectory( dir );        

    }

    // Change back to original directory:

    ChangeDirectory( currentPath );

}

/**

 *

 */

void MifConvUtil::RemoveDuplicateDirSeparators( MifConvString& str )

{    

    MifConvString searchString(DIR_SEPARATOR);

    searchString += DIR_SEPARATOR;

    size_t pos = str.find(searchString);

    while(pos != MifConvString::npos)

    {

        str.erase(pos, 1);

        pos = str.find(searchString); 

    }

}

/**

 *

 */

bool MifConvUtil::CreateDirectory( const MifConvString& path )

{    

#ifdef WIN32

    return _mkdir( path.c_str() ) == 0;

#else

    return mkdir( path.c_str(), 0777 ) == 0;

#endif

}

/**

 *

 */

void MifConvUtil::SplitString( const MifConvString& str, const MifConvString& separator, MifConvStringList& components )

{

    size_t beginPos = 0;

    size_t endPos = 0;

    while( (endPos = str.find(separator, beginPos)) != MifConvString::npos )

    {

        if( endPos - beginPos > 0 )

        {

            components.push_back( MifConvString( str.begin()+beginPos, str.begin()+endPos ) );            

        }

        beginPos = endPos+1;

    }

    if( str.begin()+beginPos != str.end() )

    {

        components.push_back( MifConvString(str.begin()+beginPos, str.end()) );

    }

}

/**

 *

 */

MifConvString MifConvUtil::UnadornedFilename( const MifConvString& filename )

{    

    MifConvStringList splitted;

    SplitString(filename, DIR_SEPARATOR, splitted);

    MifConvString tmp(splitted.back());

    splitted.clear();

    SplitString(tmp, INCORRECT_DIR_SEPARATOR, splitted);

    tmp = splitted.back();

    splitted.clear();

    SplitString(tmp, FILE_EXTENSION_SEPARATOR, splitted);

    MifConvString fixedname;

    if( splitted.size() > 0 )

    {

        fixedname = ToLower(splitted[0]);

        if( fixedname.length() > 0 )

        {

            fixedname[0] = (char) toupper( fixedname[0] );

        }

    }

    return fixedname;

}

/**

 *

 */

void MifConvUtil::FindAndSetBitmapMaskFile( MifConvSourceFile& srcFile )

{

    if( srcFile.MaskDepth() == IconMaskDepth_Undefined )

    {

        return; // No mask file

    }

    MifConvString fileExtension(FileExtension( srcFile.Filename() ));

    if( CompareIgnoreCase(fileExtension, BMP_FILE_EXTENSION) != 0 )

    {

        return;

    }

    MifConvString maskFilename(FilenameWithoutExtension(srcFile.Filename()));

    if( srcFile.MaskDepth() == IconMaskDepth_1 )

    {

        maskFilename += "_mask.bmp";

    }

    else if( srcFile.MaskDepth() == IconMaskDepth_8 )

    {

        maskFilename += "_mask_soft.bmp";

    }

    else

    {

        THROW_ERROR_COMMON("Invalid mask depth\n", MifConvString(__FILE__), __LINE__);

    }

    if( !FileExists(maskFilename) )

    {

        cerr << endl << "*** WARNING! Missing bitmap: " << maskFilename << endl;

    }

    srcFile.SetBmpMaskFilename( maskFilename );

}

/**

 *

 */

MifConvString MifConvUtil::TemporaryFilename()

{

    MifConvString tmp(tmpnam(NULL));

    MifConvString::iterator i = tmp.begin();

    if( *i == '.' )

    {

        ++i;

    }

    if( *i == DIR_SEPARATOR2 || *i == INCORRECT_DIR_SEPARATOR2 )

    {

        ++i;

    }

    return MifConvString(i, tmp.end());

}

/**

 *

 */

bool MifConvUtil::CopyFile(const MifConvString& from, const MifConvString& to)

{

    bool retval = false;

    ifstream in(from.c_str(), ios::binary);    

    if( in )

    {

        ofstream out(to.c_str(), ios::binary);        

        if( out )

        {

            out << in.rdbuf();

            retval = out.good();

            out.close();

        }

        in.close();

    }

    return retval;

} 

/**

 *

 */

bool MifConvUtil::IsWhiteSpace(char c)

{

    return c == ' ' || c == '\n' || c == '\r' || c == '\t';

}

/**

 *

 */

void MifConvUtil::ChangeDirectory( const MifConvString& dirName )

{

#ifdef WIN32

    _chdir( dirName.c_str() );

#else

    chdir( dirName.c_str() );

#endif

}

/**

 *

 */

int MifConvUtil::RemoveDirectory( const MifConvString& dirName )

{

#ifdef WIN32

    return _rmdir( dirName.c_str() );

#else

    return rmdir( dirName.c_str() );

#endif

}

/**

 *

 */

void MifConvUtil::RemoveFile( const MifConvString& fileName, int maxTries, bool noException )

{

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

    {    

#ifdef WIN32

        int ret = _unlink(fileName.c_str());

#else

        int ret = unlink(fileName.c_str());

#endif

        if( ret == 0 )

        {        

            // Delete was successful

            return;

        }

        // Delete was not successful

        if( i >= maxTries-1 )

        {

            // Max amount of tries exceeded -> print warning or throw an exception

            if( noException )

            {

                MifConvString debugStr("WARNING: Cannot remove file " + fileName);

                DebugLog(debugStr);

            }

            else

            {

                THROW_ERROR_COMMON("Cannot remove file " + fileName, MifConvString(__FILE__), __LINE__);

            }

        }       

    }

}

/**

 *

 */

MifConvString MifConvUtil::DebugFile()

{

    char* tmpPtr = getenv(MIFCONV_DEBUG_FILE_ENV.c_str());

    if( tmpPtr )

    {

        return MifConvString(tmpPtr);        

    }

    return MifConvString();

}

/**

 *

 */

void MifConvUtil::DebugLog(const MifConvString& debugStr)

{

    if( iDebugMode == DebugMode_Unknown )

    {