/**

 * Copyright (c) 2010 Sasken Communication Technologies Ltd.

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the "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:

 * Chandradeep Gandhi, Sasken Communication Technologies Ltd - Initial contribution

 *

 * Contributors:

 * Manasij Roy, Nalina Hariharan

 * 

 * Description:

 * The Plugin Manager class manages the loading and unloading of plug-ins

 *

 */

#include <QDir>

#include <QLibraryInfo>

#include <QFileSystemWatcher>

#include <QPluginLoader>

#include <QList>

#include <smfpluginbase.h>

#include <smfpluginutil.h>

#include <smfprovider.h>

#include "smfpluginmanager.h"

#include "smfpluginmanagerutil.h"

#include "smftransportmanagerutil.h"

// Static data initialisation

SmfPluginManager* SmfPluginManager::m_myInstance = NULL;

/**

 * Method to get the instance of SmfPluginManager class

 * @param aServer The Smf server instance

 * @return The instance of SmfPluginManager class

 */

SmfPluginManager* SmfPluginManager::getInstance ( SmfServer *aServer)

	{

	if(NULL == m_myInstance)

		m_myInstance = new SmfPluginManager(aServer);

	return m_myInstance;

	}

/**

 * Constructor with default argument

 * @param aServer The Smf server instance

 */

SmfPluginManager::SmfPluginManager ( SmfServer *aServer )

	{

	// Save the server instance

	m_server = aServer;

	// initialize the file watcher to monitor plugin addition/upgradation/removal

	initializeFileWatcher ( );

	// create a database to store the folder structure of the path "c://resource//qt//plugins"

	initializeSmfPluginDataBase ( );

	// create teh Plugin Manager utility class instance

	m_util = new SmfPluginManagerUtil(this);

	// Get handle to the Transport MAnager utility instance

	m_transMngrUtil = SmfTransportManagerUtil::getInstance();

	}

/**

 * Destructor

 */

SmfPluginManager::~SmfPluginManager ( )

	{

	if(m_fileWatcher)

		delete m_fileWatcher;

	if(m_tempStruct)

		delete m_tempStruct;

	if(m_waitingPluginHash.count() > 0)

		{

		foreach(SmfWaitingPluginInfoStruc *str, m_waitingPluginHash.values())

			delete str;

		}

	if(m_util)

		delete m_util;

	if(m_pluginDataBase.isOpen())

		{

		m_pluginDataBase.close();

		m_pluginDataBase.removeDatabase("SmfPluginsInfoDatabase");

		}

	// unload all loaded plugins

	unload(m_pluginLoaderHash.keys());

	if(m_myInstance)

		delete m_myInstance;

	}

/**

 * Method called by Smf server to create a web query.

 * Plugin Manager calls the appropriate web query creation method 

 * using the aOperation and aInputData parameters. Once the web request 

 * is ready, it calls the appropriate methods exposed by the Transport 

 * Manager to send the network request.

 * @param aSessionID The session ID provided by Smf Server

 * @param aPluginID The plugin ID that need to perform this operation

 * @param aOperation The type of operation to be performed

 * @param aInputData The data required to create the web query

 */

		const QString& aPluginID, 

		const SmfRequestTypeID& aOperation, 

		QByteArray& aInputData )

	{

	// Load the plugin

	QObject *plugin = load(aPluginID, result);

	// Check if plugin is loaded

		{

		SmfPluginBase* instance = qobject_cast<SmfPluginBase *>(plugin);

		if(instance)

		{

		// Get the registration token of the plugin

		QString regToken = instance->getProviderInfo()->smfRegistrationId();

		QList<QUrl> urlList;

		SmfPluginRequestData reqData;

		// check if the plugin is authorised (with CSM)

		if( authorisePlugin(regToken, urlList ))

			{

			// call the utility method to create plugin specific request

			m_util->createRequest(plugin, aOperation, aInputData, reqData, result);

			// If the request is created successfully, call the TM method to send the request

				{

				m_tempStruct = new SmfWaitingPluginInfoStruc();

				m_tempStruct->iSessionID = aSessionID;

				m_tempStruct->iPluginId = aPluginID;

				m_tempStruct->iInstance = instance;

				m_tempStruct->iOperation = aOperation;

				m_tempStruct->iInputData = aInputData;

				// send the request

				sendRequest ( reqData, result, urlList );

				}

			}

		else

			{

			// plugin not authorised, so unload

			unload(instance);

			}

		}

		else

			{

			// plugin instance cannot be casted, so unload

			unload(instance);

			}

		}

	else

		{

		// plugin not loaded

		}

	return result;

	}

/**

 * Method called by Transport Manager when network response is available

 * @param aTransportResult The result of Transport Operation

 * @param aReply The QNetworkReply instance that requested 

 * this transaction

 * @param aResponse The network response data, may be NULL for error

 */

void SmfPluginManager::responseAvailable ( 

		const SmfTransportResult &aTransportResult, 

		QNetworkReply *aReply,

		QByteArray *aResponse )

	{

			{

			quint32 sessionId = m_waitingPluginHash.value(aReply)->iSessionID;

			QString pluginId = m_waitingPluginHash.value(aReply)->iPluginId;

			SmfRequestTypeID operation = m_waitingPluginHash.value(aReply)->iOperation;

			QByteArray inputData = m_waitingPluginHash.value(aReply)->iInputData;

			QVariant result;

			SmfPluginRetType retType = SmfRequestError;

			SmfResultPage pageResult;

			// remove the plugin from the waiting list

			delete m_waitingPluginHash.value(aReply);

			m_waitingPluginHash.remove(aReply);

			QByteArray arr;

			QDataStream stream(&arr, QIODevice::ReadWrite);

				{

				// serialize the response to suitable class and pass the data to server

				serializeResult(operation, &result, stream);

				// Send the response data to the server

				}

			// Send the request again

				{

				retValue = createRequest( sessionId, pluginId, operation, inputData );

				}

			// Error

			else

				{

				// Error in parsing, sent to server

			}

	else

	}

/**

 * Method to cancel the service request

 */

bool SmfPluginManager::cancelRequest ( const QString& aPluginId )

	{

	// Get the plugin for which cancel is requested

	foreach(SmfWaitingPluginInfoStruc* iPluginInfo, m_waitingPluginHash.values())

		{

		if( 0 == iPluginInfo->iPluginId.compare(aPluginId))

			{

			// Notify Transport Manager

			m_transMngrUtil->cancelRequest(m_waitingPluginHash.key(iPluginInfo));

			}

		else

		}

	return retValue;

	}

/**

 * Method called to initialize the file watcher watching the file  

 * system for adition/upgradation/removal of plugins

 */

void SmfPluginManager::initializeFileWatcher ( )

	{

	// Create the file watcher for the plugins in /Smf folder of the Qt plugin directory

	m_fileWatcher = new QFileSystemWatcher(this);

	// Get the directory having the Qt plugin stubs

	QDir dir(QLibraryInfo::location(QLibraryInfo::PluginsPath));

	// If Smf folder exists

	if(dir.cd("smf/plugin"))

		{

		// Add each service provider folders to the file watcher

		foreach(QString folder, dir.entryList(QDir::AllDirs))

			{

			dir.cd(folder);

			m_fileWatcher->addPath(dir.absolutePath());

			dir.cdUp();

			}

		}

	else

		m_fileWatcher->addPath(dir.absolutePath());

	}

/**

 * Method called to initialize the database holding the plugin 

 * directory sructure information. This is called only once when 

 * the Plugin Manager is instantiated.

 * This method creates and updates m_pluginIdPathHash member 

 * of this class

 */

bool SmfPluginManager::initializeSmfPluginDataBase ( )

	{

	// Find QSQLite driver and create a connection to database

	m_pluginDataBase = QSqlDatabase::addDatabase("QSQLITE");

	m_pluginDataBase.setDatabaseName("SmfPluginsInfoDatabase");

	// Open the database

	bool opened = m_pluginDataBase.open();

	if(!opened)

		return false;

	// Create a query to create the DB table for Plugin Manager (if it doesn't exists)

	QSqlQuery query;

	bool tableCreated = false;

	tableCreated = query.exec("CREATE TABLE IF NOT EXISTS pluginDetails ("

			"pluginId TEXT PRIMARY KEY, interfaceName TEXT, serviceProvider TEXT, "

			"description TEXT, serviceUrl TEXT, authAppId TEXT)");

	// Error - table not created, Plugin Manager might not work properly

	if(!tableCreated)

		{

		return false;

		}

	// Get the directory having the Qt plugin stubs

	QDir dir(QLibraryInfo::location(QLibraryInfo::PluginsPath));

	// If Smf folder exists

	if(dir.cd("smf/plugin"))

		{

		// Get each interface folders names

		foreach(QString intfName, dir.entryList(QDir::AllDirs))

			{

			dir.cd(intfName);

			// Get each plugin in this folder

			foreach(QString pluginName, dir.entryList(QDir::Files))

				{

				// load this plugin

				QPluginLoader pluginLoader(dir.absoluteFilePath(pluginName));

				QObject *instance = pluginLoader.instance();

				if (instance)

					{

					SmfPluginBase* plugin = qobject_cast<SmfPluginBase *>(instance);

				    if (plugin)

				    	{

						plugin->initialize(SmfPluginUtil::getInstance());

						// get the plugin id

						QString id = plugin->getProviderInfo()->pluginId();

						// get the interface implemented by the plugin

						QString intfImplemented = dir.dirName();

						intfImplemented.prepend("org.symbian.smf.plugin.");

						// get the service provider

						QString serProv = plugin->getProviderInfo()->serviceName();

						//get the description

						QString desc = plugin->getProviderInfo()->description();

						// get the service URL

						QString servURL = plugin->getProviderInfo()->serviceUrl().toString();

						// get the authentication application id

						QString str;

						QStringList list;

						QString authAppId = plugin->getProviderInfo()->authenticationApp(

								str, list, QIODevice::ReadWrite);

						// Update m_pluginIdPathHash

						m_pluginIdPathHash.insert(id, dir.absoluteFilePath(pluginName));

						QSqlQuery rowInsertQuery;

						// insert into database

						bool rowInserted = rowInsertQuery.exec(QString("INSERT INTO pluginDetails VALUES ('%1', "

								"'%2', '%3', '%4', '%5', '%6')").arg(id).arg(intfImplemented).arg(serProv)

								.arg(desc).arg(servURL).arg(authAppId));

						if(rowInserted)

						else

				    	}

				    else

				    	{

						// Close the database

						m_pluginDataBase.close();

				    	return false;

				    	}

				    pluginLoader.unload();

					}

				else

					{

					// Close the database

					m_pluginDataBase.close();

					return false;

				}

			dir.cdUp();

			}

		}

	else

	// Close the database

	m_pluginDataBase.close();

	return true;

	}