/**

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

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

	qDebug()<<"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 ( )

	{

	qDebug()<<"Inside SmfPluginManager::~SmfPluginManager()";

	// delete file watcher

	if(m_fileWatcher)

		delete m_fileWatcher;

	if(m_tempStruct)

		delete m_tempStruct;

	// delete the plugin information hash

	if(m_waitingPluginHash.count() > 0)

		{

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

			delete str;

		}

	// delete the SmfPluginManagerUtil class instance

	if(m_util)

		delete m_util;

	// Close the database

	if(m_pluginDataBase.isOpen())

		{

		m_pluginDataBase.close();

		m_pluginDataBase.removeDatabase("SmfPluginsInfoDatabase");

		QFile::remove("SmfPluginsInfoDatabase");

		}

	// unload all loaded plugins

	unload(m_pluginLoaderHash.keys());

	// Finally remove the existing singleton instance of plugin manager itself

	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 SmfError The result of the operation. It can be :-

 * SmfPluginNoError (if the request is sent successfully) or 

 * SmfPluginLoadError (if plugin could not be loaded) or

 * SmfPluginNotAuthorised (if the plugin is not authorised) or

 * SmfPluginUnknownPluginService (if the requested service is not known or unsupported) or

 * SmfPluginRequestCreationFailed (if request creation has failed) or

 * SmfPluginSOPCheckFailed (if plugins request doesnot comply to the Same Origin Policy) or

 * SmfPluginRequestSendingFailed (if request could not be sent) or 

 * SmfPluginUnknownHttpService (if the plugin requested any unknown http 

 * method other than get, post, put, head or delete)  

 */

SmfError SmfPluginManager::createRequest ( const quint32& aSessionID, 

		const QString& aPluginID, 

		const SmfRequestTypeID& aOperation, 

		QByteArray& aInputData )

	{

	qDebug()<<"Inside SmfPluginManager::createRequest()";

	SmfError result = SmfUnknownError;

	// Load the plugin

	QObject *plugin = load(aPluginID, result);

	// Check if plugin is loaded

	if(plugin && (SmfNoError == result))

		{

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

		if(instance)

		{

		QList<QUrl> urlList;

		SmfPluginRequestData reqData;

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

			{

			qDebug()<<"Plugin authorised";

			// call the utility method to create plugin specific request

			result = SmfUnknownError;

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

			if( SmfNoError == result )

				{

				qDebug()<<"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;

				// send the request

				sendRequest ( reqData, result, urlList );

				}

				else

					qDebug()<<"Plugin request creation failed!!!, error = "<<result;

			}

		else

			{

			// plugin not authorised, so unload

			qDebug()<<"Plugin not authorised!!!";

			unload(instance);

				result = SmfPMPluginNotAuthorised;

			}

		}

		else

			{

			// plugin instance cannot be casted, so unload

			qDebug()<<"Plugin instance cannot be casted to SmfPluginBase*!!!";

			unload(instance);

			result = SmfPMPluginLoadError;

			}

		}

	else

		{

		// plugin not loaded

		qDebug()<<"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 )

	{

	qDebug()<<"Inside SmfPluginManager::responseAvailable()";

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

	SmfWaitingPluginInfoStruc* info = NULL;

	info = m_waitingPluginHash.value(aReply);

	if(info)

			{

			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;

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

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

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

			qDebug()<<"m_util->responseAvailable() return = "<<retValue;

			// remove the plugin from the waiting list

			delete m_waitingPluginHash.value(aReply);

			m_waitingPluginHash.remove(aReply);

			QByteArray arr;

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

			if( SmfNoError == retValue )

				{

				qDebug()<<"Parsing of response is successful";

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

				serializeResult(operation, &result, stream);

				// Send the response data to the server

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

				}

			// Send the request again

			else if( SmfPMPluginSendRequestAgain == retValue )

				{

				qDebug()<<"Send request again";

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

				}

			// Error

			else

				{

				qDebug()<<"Plugin responseAvailable() failed!!!, error = "<<retValue;

				// Error in parsing, sent to server

// ToDo :- For testing:-

				stream<<result.toString();

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

			}

		}

	else

		qDebug()<<"No outstanding requests for this QNetworkReply!!!";

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

	aReply->deleteLater();

	}

/**

 * Method to cancel the service request

 * @param aPluginId The plugin whose current operation is to be cancelled.

 * If the plugin is not loaded currently, this method just returns true.

 * @return Returns true if the plugin operation could be cancelled 

 * else returns false.

 */

bool SmfPluginManager::cancelRequest ( const QString& aPluginId )

	{

	bool retValue = true;

	qDebug()<<"Inside SmfPluginManager::cancelRequest()";

	// Get the plugin for which cancel is requested

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

		{

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

			{

			qDebug()<<"Plugin to be cancelled found in the waiting list";

			// Notify Transport Manager

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

			}

		else

			retValue =  true;

		}

	return retValue;

	}

/**

 * Method called to initialize the file watcher watching the file  

 * system for adition/upgradation/removal of plugins

 */

void SmfPluginManager::initializeFileWatcher ( )

	{

	qDebug()<<"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());

	connect(m_fileWatcher, SIGNAL(directoryChanged(const QString&)), 

			this, SLOT (directoryChanged(const QString&)));

	connect(m_fileWatcher, SIGNAL(fileChanged(const QString&)), 

				this, SLOT (directoryChanged(const QString&)));

	}

/**

 * 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

 * @return Returns true the database is successfully created and updated, 

 * else returns false

 */

bool SmfPluginManager::initializeSmfPluginDataBase ( )

	{

	qDebug()<<"Inside SmfPluginManager::initializeSmfPluginDataBase()";

	// Find QSQLite driver and create a connection to database

	QFile::remove("SmfPluginsInfoDatabase");

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

	m_pluginDataBase.setDatabaseName("SmfPluginsInfoDatabase");

	// Open the database

	bool opened = m_pluginDataBase.open();

	if(!opened)

		{

		qDebug()<<"Database could not be opened, returning !!!";	

		return false;

		}

	qDebug()<<"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)

		{

		qDebug()<<"Table not created!!!, error = "<<query.lastError().text();

		// Close the database

		m_pluginDataBase.close();

		return false;

		}

	qDebug()<<"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"))

		{

		qDebug()<<"Smf/plugin folder exists";

		// Get each interface folders names

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

			{

			dir.cd(intfName);

			qDebug()<<"Interface name : "<<dir.dirName();

			// Get each plugin in this folder

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

				{

				qDebug()<<"plugins for this Interface : "<<pluginName;

				// load this plugin

				QPluginLoader pluginLoader(dir.absoluteFilePath(pluginName));

				QObject *instance = pluginLoader.instance();