/*
* 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: 
*
*/

#include "mpxviewpluginresolver_p.h"    // MpxViewPluginResolverPrivate
#include "mpxplugindata.h"
#include "mpxplugindataparser.h"

#include <mpxviewpluginqt.h>
#include <QHash>

const char gRequestedPluginInterfaceName [] = "org.nokia.mmdt.MpxViewPlugin/1.0";

const int gNoneScore( 0 );
const int gSupportedScore( 5 );
const int gImplementationScore( 100 ); 
const int gTypeScore( 1 );

// ----------------------------------------------------------------------------
// score
// ----------------------------------------------------------------------------
//
static int score( int , const MpxPluginData& );

// -----------------------------------------------------------------------------
//MpxViewPluginResolverPrivate
// -----------------------------------------------------------------------------
//
MpxViewPluginResolverPrivate::MpxViewPluginResolverPrivate( 
        const QList<int>& request )
:
requestedPlugins( request )
{
    //No implementation needed
}

// -----------------------------------------------------------------------------
// ~MpxViewPluginResolverPrivate
// -----------------------------------------------------------------------------
//
MpxViewPluginResolverPrivate::~MpxViewPluginResolverPrivate()
{
    //No implementation needed
}

// -----------------------------------------------------------------------------
// resolvePlugin()
// -----------------------------------------------------------------------------
//
MpxViewPlugin* MpxViewPluginResolverPrivate::resolvePlugin()
{
    MpxPluginViewInterface* retVal = 0;
    if( 0 < requestedPlugins.count() ){
        XQPluginLoader  loader;
        QList< XQPluginInfo > impls;
        if (loader.listImplementations(gRequestedPluginInterfaceName, impls)) {
            retVal = resolveAndLoadPlugins( impls );
        }
    }
    return (retVal!=0) ? retVal->viewPlugin() : 0;
}

// ----------------------------------------------------------------------------
// resolveAndLoadPlugins( const QList< XQPluginInfo >& impls );
// ----------------------------------------------------------------------------
//
MpxPluginViewInterface* MpxViewPluginResolverPrivate::resolveAndLoadPlugins( 
        const QList< XQPluginInfo >& impls )
{
    MpxPluginViewInterface* retVal = 0;
    
    //parse plugin info data 
    QHash<const XQPluginInfo*, MpxPluginData* > parsedInfo;
    QList< XQPluginInfo >::const_iterator iter( impls.begin() );
    MpxPluginDataParser parser;
    for( ; iter != impls.end(); ++iter ){
        if( 0 < ( *iter ).opaqueData().length() ){
            parser.parse( ( *iter ).opaqueData() );
            if( parser.data() ){
                parsedInfo.insert( &( *iter ), parser.takeData() );
            }
        }
    }
    
    //look for optimal plugin
    QList<int> uids( requestedPlugins );
    QList<int>::iterator currentUidIter,
                         optimalUidIter;
    QHash<const XQPluginInfo*, MpxPluginData* >::iterator 
        currentInfoIter,
        optimalInfoIter;
    int currentPluginScore( 0 ),
        optimalPluginScore( 0 );
    
    do{
        //initialize iterators with invalid objects
        optimalInfoIter = parsedInfo.end();
        
        for( currentUidIter = uids.begin();
             uids.end() != currentUidIter;
             ++currentUidIter )
        {
            for( currentInfoIter = parsedInfo.begin();
                 parsedInfo.end() != currentInfoIter;
                 ++currentInfoIter )
            {
                currentPluginScore = score( (*currentUidIter ), 
                                            (*(*currentInfoIter) ) );
                if( gNoneScore < currentPluginScore ){
                    if( parsedInfo.end() == optimalInfoIter ){
                        //first plugin with no zero score. set as optimal
                        optimalPluginScore = currentPluginScore;
                        optimalInfoIter = currentInfoIter;
                        optimalUidIter = currentUidIter;
                    }
                    if( optimalPluginScore < currentPluginScore ||
                        ( ( currentPluginScore == optimalPluginScore ) &&
                          ( ( *currentInfoIter )->priority() > ( *optimalInfoIter )->priority() ) ) )
                    {
                        //current plugin fits better then "optimal" one
                        optimalPluginScore = currentPluginScore;
                        optimalInfoIter = currentInfoIter;
                        optimalUidIter = currentUidIter;
                    }
                }
            }
        }
        if( parsedInfo.end() == optimalInfoIter ){
             //plugin was not found
             break;
         }
         XQPluginLoader loader( optimalInfoIter.key()->uid() );
         if( loader.load() ) {
             retVal = qobject_cast<MpxPluginViewInterface*>(loader.instance());
         }
         //remove already loaded plugin description
         delete ( *optimalInfoIter );
         parsedInfo.erase( optimalInfoIter );
         uids.erase( optimalUidIter );
    
    }while( NULL == retVal );
    uids.clear();
    
    //clear parsed data structures
    for( currentInfoIter = parsedInfo.begin();
         parsedInfo.end() != currentInfoIter;
         currentInfoIter = parsedInfo.erase( currentInfoIter ) ){
         delete ( *currentInfoIter );
    }
    return retVal;
}
// ----------------------------------------------------------------------------
// score
// ----------------------------------------------------------------------------
//
int score( int uid, const MpxPluginData& pluginData )
{
    int retVal( gNoneScore );
    QList< int >::const_iterator iter( pluginData.supportedId().begin() );
    for( ; iter != pluginData.supportedId().end(); ++iter ){
        if( ( *iter ) == uid ){
            retVal += gSupportedScore;
        }
    }
    if( pluginData.id() == uid ){
        retVal += gImplementationScore; 
    }
    if( pluginData.type() == uid ){
        retVal += gTypeScore;
    }
    
    qDebug(QString("Score 0x%1: %2").arg(uid, 0, 16).arg(retVal).toLatin1().data());
    
    return retVal;
}