/*

* 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 converter manager class.

*

*/

#include "mifconv.h"

#include "mifconv_convertermanager.h"

#include "mifconv_argumentmanager.h"

#include "mifconv_util.h"

#include "mifconv_bitmapconverter.h"

#include "mifconv_bitmapheaderconverter.h"

#include "mifconv_iconbinaryconverter.h"

#include "mifconv_mifconverter.h"

// Static singleton initialization

MifConvConverterManager* MifConvConverterManager::iInstance = 0;

/**

 * Returns pointer to the singleton object

 */

MifConvConverterManager* MifConvConverterManager::Instance()

{

    if( iInstance == 0 )

    {

        iInstance = new MifConvConverterManager();

    }

    return iInstance;

}

/**

 * Free the allocated memory

 */

void MifConvConverterManager::Reset()

{

    delete iInstance;

    iInstance = 0;

}

/**

 * Constructor

 */

MifConvConverterManager::MifConvConverterManager()

{

}

/**

 *

 */

void MifConvConverterManager::Init()

{

    // Add bmp --> mbm converter:

    MifConvBitmapConverter* bitmapConverter = new MifConvBitmapConverter();

    iAllConverters.push_back(bitmapConverter);

    // Add headerfile (mbg) converter:

    MifConvBitmapHeaderConverter* headerConverter = new MifConvBitmapHeaderConverter();    

    iAllConverters.push_back(headerConverter);

    // Add svg --> svgb converter:

    MifConvIconBinaryConverter* svgConverter = new MifConvIconBinaryConverter();

    iAllConverters.push_back(svgConverter);

    // Add mif converter:

    MifConvMifConverter* mifConverter = new MifConvMifConverter();

    iAllConverters.push_back(mifConverter);

    // Add file converters for .BMP files:

    MifConvFileConverterList bmpConverters;

    bmpConverters.push_back(bitmapConverter);

    bmpConverters.push_back(headerConverter);

    bmpConverters.push_back(mifConverter);

    iFileConverters.insert(std::make_pair(MifConvString(BMP_FILE_EXTENSION), bmpConverters));

    // Add file converters for .SVG files:

    MifConvFileConverterList svgConverters;

    svgConverters.push_back(headerConverter);

    svgConverters.push_back(svgConverter);

    if( MifConvArgumentManager::Instance()->BooleanValue(MifConvDisableSvgCompression) )

    {        

        // SVG files will be added to mif-file without compression (i.e. don't use svgtbinencode for them).

        svgConverters.push_back(mifConverter); 

    }

    iFileConverters.insert(std::make_pair(MifConvString(SVG_FILE_EXTENSION), svgConverters));

    // Add file converters for .SVGB files:

    MifConvFileConverterList svgbConverters;  

    svgbConverters.push_back(headerConverter);

    if( !MifConvArgumentManager::Instance()->BooleanValue(MifConvDisableSvgCompression) )

    {     

        // SVG files will be compressed first.

        svgbConverters.push_back(mifConverter);

    }

    iFileConverters.insert(std::make_pair(MifConvString(SVGB_BINARY_FILE_EXTENSION), svgbConverters));

    // Initialize converters

    for( MifConvFileConverterList::iterator i = iAllConverters.begin(); i != iAllConverters.end(); ++i )

    {

    	(*i)->Init();

    }

}

/**

 * Destructor

 */

MifConvConverterManager::~MifConvConverterManager()

{

    for( MifConvFileConverterList::iterator conv = iAllConverters.begin(); conv != iAllConverters.end(); ++conv )

    {

        delete *conv;    

    }

}

/**

 * Adds source files to converters and converts them

 */

void MifConvConverterManager::ProcessIcons()

{

    MifConvArgumentManager* argMgr = MifConvArgumentManager::Instance();

    // Loop all the source files and append them to correct converters:

    const MifConvSourceFileList& sourcefiles = argMgr->SourceFiles();

    for( MifConvSourceFileList::const_iterator i = sourcefiles.begin(); i != sourcefiles.end(); ++i )

	{        

        MifConvFileConverterList& converters = GetConverters(*i);

        for( MifConvFileConverterList::iterator converter = converters.begin(); converter != converters.end(); ++converter )

        {            

            (*converter)->AppendFile(*i);            

        }

    }

    // Run all the converters:

    for( MifConvFileConverterList::iterator conv = iAllConverters.begin(); conv != iAllConverters.end(); ++conv )

    {

        (*conv)->Convert();

    }

}

/**

 *

 */

void MifConvConverterManager::Cleanup(bool error)

{

    for( MifConvFileConverterList::iterator conv = iAllConverters.begin(); conv != iAllConverters.end(); ++conv )

    {

        try {

            (*conv)->Cleanup(error);

        }

        catch(...) {

        // Exception should not be thrown if cleaning after error situation

            if( !error )

                throw;

        }

    }           

}

/**

 *

 */

MifConvFileConverterList& MifConvConverterManager::GetConverters(const MifConvSourceFile& source)

{    

    return GetConverters(source.Filename());

}

/**

 *

 */

MifConvFileConverterList& MifConvConverterManager::GetConverters(const MifConvString& filename)

{

    MifConvString extension(MifConvUtil::FileExtension(filename));

    FileConverterMap::iterator i = iFileConverters.find(extension);

    if( i != iFileConverters.end() )

    {

        return i->second;

    }

    return iDummyConverterList;

}