/**

 * 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;

	m_server->writeLog("Inside SmfPluginManager::SmfPluginManager()");

	// 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 ( )

	{

	m_server->writeLog("Inside 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

 * @return SmfPluginManagerResult The result of the operation

 * @see smfglobal.h

 */

SmfPluginManagerResult SmfPluginManager::createRequest ( const quint32& aSessionID, 

		const QString& aPluginID, 

		const SmfRequestTypeID& aOperation, 

		QByteArray& aInputData )

	{

	m_server->writeLog("Inside SmfPluginManager::createRequest()");

	SmfPluginManagerResult result = SmfPluginUnknownError;

	// Load the plugin

	QObject *plugin = load(aPluginID, result);

	// Check if plugin is loaded

	if(plugin && (SmfPluginLoaded == result))

		{

		m_server->writeLog("Plugin 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 ))

			{

			m_server->writeLog("Plugin authorised");

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

			if( SmfPluginRequestCreated == result )

				{

				m_server->writeLog("Plugin request creation successful");

				m_tempStruct = new SmfWaitingPluginInfoStruc();

				m_tempStruct->iSessionID = aSessionID;

				m_tempStruct->iPluginId = aPluginID;

				m_tempStruct->iInstance = instance;

				m_tempStruct->iOperation = aOperation;

				m_tempStruct->iInputData = aInputData;

				m_tempStruct->iUrlList = urlList;

				// send the request

				sendRequest ( reqData, result, urlList );

				}

			}

		else

			{

			// plugin not authorised, so unload

			m_server->writeLog("Plugin not authorised!!!");

			unload(instance);

			result = SmfPluginNotAuthorised;

			}

		}

		else

			{

			// plugin instance cannot be casted, so unload

			m_server->writeLog("Plugin instance cannot be casted to SmfPluginBase*!!!");

			unload(instance);

			result = SmfPluginLoadError;

			}

		}

	else

		{

		// plugin not loaded

		m_server->writeLog("Plugin not loaded!!!");

		result = SmfPluginLoadError;

		}

	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 )

	{

	m_server->writeLog("Inside SmfPluginManager::responseAvailable()");

	// For request success or For request cancellation

	if((SmfTransportOpNoError == aTransportResult) || 

			(SmfTransportOpOperationCanceledError == aTransportResult))

			{

		m_server->writeLog("no transport error/ cancellation");

			// get the details of the plugin which made this request

			SmfWaitingPluginInfoStruc* info = m_waitingPluginHash.value(aReply);

			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;

			m_server->writeLog("Before m_util->responseAvailable");

			// call the utility method to send response to appropriate plugins

			SmfPluginManagerResult retValue = m_util->responseAvailable( info->iInstance, operation, 

				aTransportResult, aResponse, &result, retType, pageResult );

			// remove the plugin from the waiting list

			delete m_waitingPluginHash.value(aReply);

			m_waitingPluginHash.remove(aReply);

			QByteArray arr;

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

			if( SmfPluginResponseParsed == retValue )

				{

				m_server->writeLog("Parsing successful");

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

				serializeResult(operation, &result, stream);

				////TODO:- send error in enums-by manasij

				// Send the response data to the server

				m_server->resultsAvailable(sessionId, &arr, SmfNoError);

				}

			// Send the request again

			else if( SmfPluginSendRequestAgain == retValue )

				{

				m_server->writeLog("Send request again");

				// create the request again (with same paramaters)

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

				}

			// Error

			else

				{

				m_server->writeLog("Parsing failed!!");

				// Error in parsing, sent to server

				m_server->resultsAvailable(sessionId, &arr, SmfpluginResponseParseFailure);

				}

			// delete aReply later, when event loop is re-entered

			aReply->deleteLater();

			}

	// Any other error

	else

		{

		m_server->writeLog("Error in SmfPluginManager::responseAvailable, Transport failure code : ");

		QString err = QString::number(aTransportResult);

		m_server->writeLog(err);

		//Added by manasij, send all kind of errors to the server

		//TODO:- to be refined by PM owner

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

		QByteArray arr;

		m_server->resultsAvailable(sessionId, &arr, SmftransportInitNetworkNotAvailable);

		}

	}

/**

 * Method to cancel the service request

 * @param aPluginId The plugin whose current operation 

 * is to be cancelled

 */

bool SmfPluginManager::cancelRequest ( const QString& aPluginId )

	{

	bool retValue = false;

	m_server->writeLog("Inside SmfPluginManager::cancelRequest()");

	// Get the plugin for which cancel is requested

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

		{

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

			{

			m_server->writeLog("Plugin to be cancelled found in the waiting list");

			// Notify Transport Manager

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

			// Notify the plugin that the request has been cancelled

			SmfPluginRetType retType;

			SmfResultPage pageResult;

			SmfPluginError ret = iPluginInfo->iInstance->responseAvailable( SmfTransportOpCancelled, 

					NULL, NULL, retType, pageResult );

			// Remove that plugin from the waiting list

			delete (m_waitingPluginHash.value(m_waitingPluginHash.key(iPluginInfo)));

			m_waitingPluginHash.remove(m_waitingPluginHash.key(iPluginInfo));

			if(SmfPluginErrNone == ret)

				retValue = true;

			}

		//else , cancel requested for a plugin which is not loaded, do nothing

		else

			{

			m_server->writeLog("Plugin to be cancelled not found in the waiting list!!! - do nothing");

			retValue =  false;

		}

		}

	return retValue;

	}

/**

 * Method called to initialize the file watcher watching the file  

 * system for adition/upgradation/removal of plugins

 */

void SmfPluginManager::initializeFileWatcher ( )

	{

	m_server->writeLog("Inside 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 ( )

	{

	m_server->writeLog("Inside SmfPluginManager::initializeSmfPluginDataBase()");

	// Find QSQLite driver and create a connection to database

	m_pluginDataBase.removeDatabase("SmfPluginsInfoDatabase");

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

	m_pluginDataBase.setDatabaseName("SmfPluginsInfoDatabase");

	// Open the database

	bool opened = m_pluginDataBase.open();

	if(!opened)

		return false;

	m_server->writeLog("Database opened");

	// 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)

		{

		m_server->writeLog("Table not created, error = "+query.lastError().text());

		return false;

		}

	m_server->writeLog("Table created");

	// Get the directory having the Qt plugin stubs

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

	// If Smf folder exists

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

		{

		m_server->writeLog("Smf/plugin folder exists");

		// Get each interface folders names

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

			{

			dir.cd(intfName);

			m_server->writeLog("Interface name : "+dir.dirName());

			// Get each plugin in this folder

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

				{

				m_server->writeLog("plugins for this Interface : "+pluginName);

				// load this plugin

				QPluginLoader pluginLoader(dir.absoluteFilePath(pluginName));

				QObject *instance = pluginLoader.instance();

				if (instance)

					{

					m_server->writeLog("instance found");

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

				    if (plugin)

				    	{

						m_server->writeLog("SmfPluginBase found");

						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.");

						m_server->writeLog("intfImplemented=");

						m_server->writeLog(intfImplemented);

						// 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)

							m_server->writeLog("This Plugin's information is added to database : "+id+""

									", "+intfImplemented+", "+serProv);

						else

							m_server->writeLog("plugins data not written to database, error = "+query.lastError().text());

				    	}

				    else

				    	{

						m_server->writeLog("Plugin could not be converted to SmfpluginBase* - returning");

						// Close the database

						m_pluginDataBase.close();

				    	return false;

				    	}

				    pluginLoader.unload();

					}

				else

					{

					m_server->writeLog("Plugin could not be loaded - returning");

					// Close the database

					m_pluginDataBase.close();

					return false;

				}

				}

			dir.cdUp();

			}

		}

	else

		m_server->writeLog("No Smf plugins installed!!!");

	// Close the database

	m_pluginDataBase.close();

	return true;

	}

/**

 * Method to load a plugin using its Plugin Id.

 * @param aPluginId The unique ID of the plugin 

 * @param aLoadResult [out] Output paramater indicating the result 

 * of the loading

 * @return The instance of the loaded plugin if loaded, else NULL

 */

QObject* SmfPluginManager::load ( const QString &aPluginId,

		SmfPluginManagerResult &aLoadResult)

	{

	m_server->writeLog("Inside SmfPluginManager::load()");

	QPluginLoader *pluginLoader;

	// Find the plugin Path