/*
* 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 MIF converters class.
*
*/


#include "mifconv.h"
#include "mifconv_mifconverter.h"
#include "mifconv_util.h"
#include "mifconv_exception.h"
#include "mifconv_argumentmanager.h"

// File versions:
// V1 - first version.
// V2 - stores information if icon location (MIF/MBM) inside the MIF file (bitmap offsets array).
// This way, icon IDs in MBG header can be always the same regardless of which icons are in MIF
// file and which in MBM file.
static const int KFileVersion(2);
static const int KIconVersion(1);

static const int FileHeaderSizeInBytes = 4*4;
static const int IconHeaderSizeInBytes = 4*8;
static const int KUidAvkonMultiIconFile(0x034232342);
static const int KUidAvkonMultiIcon(0x034232343);

//static const int IconFormatType_BMP(0);
//static const int IconFormatType_SVG(1);

static const unsigned int svgbSignatureLow (0x03FA56CC); //66737868
static const unsigned int svgbSignatureHigh(0x03FA56CF); //66737871

static const unsigned int nvgSignatureLow (0x0067766E); //('n'+'v'+'g'+0)
static const unsigned int nvgSignatureHigh(0xFF67766E); //('n'+'v'+'g'+255)

/**
 *
 */
MifConvMifConverter::MifConvMifConverter()
{
    MifConvArgumentManager* argMgr = MifConvArgumentManager::Instance();
    iTargetFilename = argMgr->TargetFile();
}

/**
 *
 */
MifConvMifConverter::~MifConvMifConverter()
{
    // Delete file contents
    for( StringPtrVector::iterator i = iContentPointers.begin(); i != iContentPointers.end(); ++i )
    {
        delete[] *i;
    }
}

/**
 *
 */
void MifConvMifConverter::Init()
{
    CleanupTargetFiles();
}

/**
 *
 */
void MifConvMifConverter::CleanupTargetFiles()
{
	if( MifConvUtil::FileExists(iTargetFilename) )
	{
        // Try to remove file MIFCONV_MAX_REMOVE_TRIES times, no exception in case of failure:
	    MifConvUtil::RemoveFile(iTargetFilename, MIFCONV_MAX_REMOVE_TRIES, true);
	}
}

/**
 *
 */
void MifConvMifConverter::AppendFile( const MifConvSourceFile& sourcefile )
{     
	if( MifConvUtil::FileExtension( sourcefile.Filename() ) == BMP_FILE_EXTENSION ||
        MifConvUtil::FileExtension( sourcefile.Filename() ) == SVG_FILE_EXTENSION ||
        MifConvUtil::FileExtension( sourcefile.Filename() ) == SVGB_BINARY_FILE_EXTENSION )
	{        
		iSourceFiles.push_back( sourcefile );
	}
}

void MifConvMifConverter::Convert()
{
 	ReadFileContents();
    cout << "Writing mif: " << MifConvArgumentManager::Instance()->TargetFile() << endl;
	ConvertToMif();
}

void MifConvMifConverter::ReadFileContents()
{   
    for( MifConvSourceFileList::iterator i = iSourceFiles.begin(); i != iSourceFiles.end(); ++i )
    {        
        // Just read the contents of the .svgb files
        if( MifConvUtil::FileExtension( i->Filename() ) != BMP_FILE_EXTENSION )
        {            
            if( MifConvUtil::FileExists(i->Filename()) == false )
            {
                THROW_ERROR_COMMON("Unable to open file for reading! " + i->Filename(), MifConvString(__FILE__), __LINE__ );
            }            
            cout << "Loading file: " << i->Filename() << endl;
            MifConvFileData retVal = MifConvUtil::FileContents(i->Filename());
            iContentPointers.push_back(retVal.first); // Save pointer for deleting it later
            i->SetContent(retVal.first, retVal.second);
        }
    }
}


void MifConvMifConverter::Cleanup(bool err)
{
	CleanupTempFiles();
	if( err )
	{
	    CleanupTargetFiles();
	}
}

void MifConvMifConverter::ConvertToMif()
{  
    try {
        OpenTargetFile();
    }
    catch( MifConvException& e )
    {
        // If file creation/opening was not successful, give warning and return:
        MifConvString debugStr("WARNING: Target file " + iTargetFilename + " cannot be opened for writing.");
        cout <<  debugStr  << endl;
        MifConvUtil::DebugLog(debugStr);
        return;
    }
    WriteTargetHeader();
    WriteIconArray();
    WriteIcons();
}

void MifConvMifConverter::OpenTargetFile()
{
    iTargetFile.open( iTargetFilename.c_str(), ios::out|ios::binary );

    if (!iTargetFile.is_open())
    {
        // Create path if it does not exist.
        MifConvUtil::EnsurePathExists(iTargetFilename, true);
        iTargetFile.clear();
        iTargetFile.open( iTargetFilename.c_str(), ios::out|ios::binary );
    }
    if (!iTargetFile.is_open())
    {
        THROW_ERROR_COMMON("Cannot write to file! " + iTargetFilename, MifConvString(__FILE__), __LINE__);
    }
}

void MifConvMifConverter::WriteTargetHeader()
    {
    size_t arraySize = iSourceFiles.size() * 2;
    int offset = FileHeaderSizeInBytes;
    iTargetFile.write( (char*) &KUidAvkonMultiIconFile, 4 );
    iTargetFile.write( (char*) &KFileVersion, 4 );
    iTargetFile.write( (char*) &offset, 4 );
    iTargetFile.write( (char*) &arraySize, 4 );
    }

void MifConvMifConverter::CleanupTempFiles()
{
}

void MifConvMifConverter::WriteIcons()
{    
    for( MifConvSourceFileList::iterator i = iSourceFiles.begin(); i != iSourceFiles.end(); ++i )
    {
        if( i->ContentLength() > 0 )
        {
            WriteIconHeader(*i);
            WriteIconData(*i);
        }
    }
}

MifConvDefs::IconFormatType MifConvMifConverter::ReadIconBinaryType(const MifConvSourceFile& src)
{
    MifConvDefs::IconFormatType ret = MifConvDefs::IconFormatType_SVG;
    
    if( src.ContentLength() >= 4 )
    {
        const char* iconData = src.Content();
        
        if( iconData[0] == 'n' &&
            iconData[1] == 'v' &&
            iconData[2] == 'g' )
        {
            ret = MifConvDefs::IconFormatType_NVG;
        }
    }
    
    return ret;
}

void MifConvMifConverter::WriteIconHeader(const MifConvSourceFile& src)
{
    int type = 0;
    if( MifConvUtil::FileExtension(src.Filename()) == BMP_FILE_EXTENSION )
        type = MifConvDefs::IconFormatType_BMP;
    else
        type = ReadIconBinaryType(src);
        //type = IconFormatType_SVG;

    int animated = (int) src.IsAnimated();
    int dataLen = src.ContentLength();
    int depth = src.DisplayMode();
    int mask = src.MaskDisplayMode();
    int dataoffset = IconHeaderSizeInBytes; // 8 = number of writes in this method.

    iTargetFile.write((char*)&KUidAvkonMultiIcon, 4); // 1
    iTargetFile.write((char*)&KIconVersion, 4);       // 2
    iTargetFile.write((char*)&dataoffset, 4);         // 3
    iTargetFile.write((char*)&dataLen, 4);        // 4
    iTargetFile.write((char*)&type, 4);          // 5
    iTargetFile.write((char*)&depth, 4);         // 6
    iTargetFile.write((char*)&animated, 4);      // 7
    iTargetFile.write((char*)&mask, 4);     // 8
}

void MifConvMifConverter::WriteIconData(const MifConvSourceFile& src)
{
    if( src.Content() )
    {        
        iTargetFile.write(src.Content(), src.ContentLength());
    }
}

/**
* 
*/
void MifConvMifConverter::WriteIconArray()
{
    int offset = (int) FileHeaderSizeInBytes +  (int)iSourceFiles.size()*4*2*2;
    MifConvSourceFileList::iterator i = iSourceFiles.begin();

    int mbmIndex = 0;
    int zero = 0;

    for( ; i != iSourceFiles.end(); ++i )
    {
        // MIF icon
        if( MifConvUtil::FileExtension(i->Filename()) != BMP_FILE_EXTENSION )
        {            
            int length = i->ContentLength() + IconHeaderSizeInBytes;
            iTargetFile.write( (char*) &offset, 4 );
            iTargetFile.write( (char*) &length, 4 );
            // same information for the mask...
            iTargetFile.write( (char*) &offset, 4 );
            iTargetFile.write( (char*) &length, 4 );

            offset += length;            
        }
        // MBM icon
        else
        {
            iTargetFile.write( (char*) &mbmIndex, 4 );
            iTargetFile.write( (char*) &zero, 4 );

            // Masked MBM icon -> There is own MBM index for the mask.
            if(i->MaskDepth() != IconMaskDepth_Undefined )
            {
                mbmIndex--;
            }

            iTargetFile.write( (char*) &mbmIndex, 4 );
            iTargetFile.write( (char*) &zero, 4 );

            // MBM incides are coded as negative in the 'offset' field,
            // so that they can be easily separated from the actual MIF offsets.
            mbmIndex--;
        }
    }
}