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

#include "smfserver.h"
#include "smfpluginmanager.h"
#include "smftransportmanager.h"
#include "smfclientglobal.h"
#include <smfprovider.h>
#include <smfpost.h>
#include <smflocation.h>
#include <smfcontact.h>
#include <smfpicture.h>
#include <smfcomment.h>
//#ifdef NO_OTHER_MODULES
#include <QImage>
#include <QUrl>
#include <smfgroup.h>
#include <QTextStream>
#include <QFile>
//#endif
#ifdef Q_OS_SYMBIAN
#include "smfserversymbian_p.h"
#else
#include "smfserverqt_p.h"
#endif

SmfServer::SmfServer(QObject* parent): QObject(parent)
	{
	}
bool SmfServer::startServer()
	{
	bool success = false;
	//Initialize all the component handles
	writeLog("Not doing SmfTransportManager::getInstance");
	//m_transportManager = SmfTransportManager::getInstance();
	writeLog("Not doing m_transportManager->initializeTransport");
	//checking the network status, no need to proceed if not permitted
	//SmfTransportInitializeResult networkStatus = m_transportManager->initializeTransport();
	writeLog("Before networkStatus");
	//TODO:-check this
	if(1/*networkStatus == SmfTransportInitNoError*/)
		{
		writeLog("Before m_pluginManager construction");
		m_pluginManager = SmfPluginManager::getInstance(this);
		writeLog("After m_pluginManager construction");
		//	m_dataStoreManager = new SmfDataStoreManager();
		//Initialize private implementation
		#ifdef Q_OS_SYMBIAN
		TRAPD(err, m_SmfServerPrivate = SmfServerSymbian::NewL(CActive::EPriorityStandard,this));
		QString log("SmfServer::startServer=");
		int errorQ = err ;
		log += errorQ;
		 writeLog(log);
		if( KErrNone != err )
			{
			return success;
			}
		TInt error = m_SmfServerPrivate->Start( KSmfServerName );
		errorQ = error ;
		log.clear();
		log = QString("m_SmfServerPrivate->Start=");
		log += QString::number(error);
		 writeLog(log);
		if( KErrNone == error ) 
			{
			success = true;
			}
		else 
			{
			//error
			return success;
			}
		#else
		m_SmfServerPrivate = new SmfServerQt();
		success = m_SmfServerPrivate->start();
		if (!success) 
			{
			return success;
			}
		#endif
		//request CM server for auth expiry info, note:- we should resend the request everytime we get expiry
		//notification
		//TODO:- Do it after CM implementation
		//CMclient->requestAuthExpiryNotify();
		//connect(CMClient,SIGNAL(authExpiryNotify(NotificationType,SmfPluginID),this,SLOT(NotificationType,SmfPluginID));
		}
    return success;
	}
//Note:- Almost all the following APIs are called by private impl via the handle
/**
 * This called first once a session is created by the private impl
 * @param clientID some unique client process ID, SID for symbian platform
 * TODO:-How to get the pid for rest of the platforms?
 * @return true if client is already athorized, else false
 * 
 */
bool SmfServer::isClientAuthorized(SmfClientAuthID clientID)
	{
	//TODO:- once CM is complete do it properly
	Q_UNUSED(clientID);
	return true;
	}
/**
 * This API is called by the private impl when isClientAuthorized returns false
 * @param clientID client Id (SID for symbian platform), provided by the private impl
 * Note:- The session(and in turn the client) will be blocked untill authorization completes.
 */
void SmfServer::authorizeClient(SmfClientAuthID clientID)
	{
	//TODO:- once CM is complete, do it properly
	//CMclient->authorizeClient(clientID)
	//connect(CMClient,SIGNAL(clientAuthorizationFinished(bool,SmfClientAuthID)),this,SLOT(clientAuthorizationFinished(bool,SmfClientAuthID)));
	Q_UNUSED(clientID);	
	}
/**
 * This API is called by the private impl when client is authorized
 * @param interfaceID Interface id, provided by the private impl (it gets it from client)
 * @param pluginIDMap Map of plugins who implement this interface and corresponding provider,
 * this is returned to the private impl
 * It calls PM to get the list. Note:- PM may return SmfProviderBase which is superset of SmfProvider.
 * TODO:- session should store this map for future ref?
 */
void SmfServer::getPlugins(SmfInterfaceID interfaceID, QMap<SmfPluginID,SmfProvider>& pluginIDMap)
	{
	pluginIDMap.clear();
	m_pluginManager->getPlugins(interfaceID,pluginIDMap);
	}

SmfPluginID SmfServer::getPlugin(SmfInterfaceID interfaceID,SmfProvider provider)
	{
	//TODO:- do it properly as per PM implementation
	//return PM->getplugin(interfaceID,provider);
	//TODO:- PM is not yet ready
	SmfPluginID id;
	m_pluginManager->getPluginId(interfaceID,provider, id);
	return id;
	//testing purpose only
	}
/**
 * This API is called by the private impl to get a list of authorized plugins from CM
 * @param list List of plugins to be filtered
 * @param authList List of authorised plugins filled by CM
 * this is returned to the private impl
 * It calls CMclient to get the list synchronously
 * TODO:- session should store this for future ref?
 */
void SmfServer::getAuthorizedPlugins(QList<SmfPluginID>& list,QList<SmfPluginID>& authList)
	{
	//TODO:- do it properly as per CMclient implementation
	//CMclient->getAuthorizedPlugins(list,authList);
	//testing purpose only
#ifdef NO_OTHER_MODULES
	authList = list;
#endif
	}
/**
 * This API is called by the private impl to request the PM to do the actual request/parsing asynchronously
 * Note:- the sever private impl (SmfServerSymbian for symbian platform) maintains a map of session ptr and some randomely
 * generated number.For the time being we are allowing only one outstanding request per session, so no need to store
 * both session and msg ptr, but in future we may need to.
 * @param requestID Request id (corresponds to the key of the mapmaintained by SmfServerSymbian).
 * @param pluginID PluginID, provided by the session
 * @param interfaceID InterfaceID provided by session
 * @requestTypeID Request Opcode, provided by session
 */
void SmfServer::getRequestedData(int requestID,SmfPluginID pluginID,SmfInterfaceID interfaceID, SmfRequestTypeID requestTypeID,QByteArray dataForPlugin)
	{
		//TODO:- cross check the params with PM owner
		//PM->getData(requestID,pluginID,interfaceID,requestTypeID);
		m_SmfServerPrivate->writeLog("SmfServer::getRequestedData");
		m_SmfServerPrivate->writeLog(QString::number(requestID));
		m_SmfServerPrivate->writeLog(pluginID);
		m_SmfServerPrivate->writeLog(interfaceID);
		m_SmfServerPrivate->writeLog(QString::number(requestTypeID));
		bool defaultCase = false;
		//serializedInfo contains base provider info+ other data depending on requestTypeID
		QDataStream reader(&dataForPlugin,QIODevice::ReadOnly);
		QByteArray dataTobeSent;
		switch(requestTypeID)
			{
			case SmfContactPost:
				{
				SmfProvider provider;
				SmfPost post;
				SmfLocation loc;
				reader>>provider;
				reader>>post;
				reader>>loc;
				//now form the serialized bytearray with only SmfPost and SmfPlace
				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
				writer<<post;
				writer<<loc;
				}
				break;
			case SmfContactUpdatePost:
				{
				SmfProvider provider;
				SmfPost post;
				reader>>provider;
				reader>>post;
				//now form the serialized bytearray with only SmfPost
				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
				writer<<post;
				}
				break;
			case SmfContactPostDirected:
				{
				SmfProvider provider;
				SmfPost post;
				SmfContact contact;
				SmfLocation place;
				reader>>provider;
				reader>>post;
				reader>>contact;
				reader>>place;
				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
				writer<<post;
				writer<<contact;
				writer<<place;
				}
				break;
			case SmfContactSharePost:
				{
				SmfProvider provider;
				SmfPost post;
				SmfContact contact;
				bool edited;
				reader>>provider;
				reader>>post;
				reader>>contact;
				reader>>edited;
				//now form the serialized bytearray with only SmfPost
				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
				writer<<post;
				writer<<contact;
				writer<<edited;
				}
				break;
			case SmfPictureDescription:
			case SmfPictureUpload:
				{
				SmfProvider provider;
				SmfPicture picture;
				reader>>provider;
				reader>>picture;
				//now form the serialized bytearray with only SmfPicture
				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
				writer<<picture;
				}
				break;
			case SmfPictureMultiUpload:
				{
				SmfProvider provider;
				SmfPictureList pictureList;
				reader>>provider;
				reader>>pictureList;
				//now form the serialized bytearray with only SmfPicture
				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
				writer<<pictureList;
				}
				break;
			case SmfPicturePostComment:
				{
				SmfProvider provider;
				SmfPicture picture;
				SmfComment comment;
				reader>>provider;
				reader>>picture;
				reader>>comment;
				//now form the serialized bytearray with only SmfPicture
				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
				writer<<picture;
				writer<<comment;
				}
				break;
			default:
				defaultCase = true;
				break;
			}
		//When xtra info to be sent to plugin manager
		if(!defaultCase)
			{
				m_pluginManager->createRequest(requestID,pluginID,requestTypeID,dataTobeSent);
			}
		//when plugin manager needs to xtra info
		else
			{
			QByteArray arr;
			m_pluginManager->createRequest(requestID,pluginID,requestTypeID,arr);
			}
	}
/**
 * This slot is invoked when CM finishes the authorization of the client.
 * @param authID As it contains the session ptr, sever directly invokes the session's API to notify success
 */
void SmfServer::clientAuthorizationFinished(bool success,SmfClientAuthID authID )
	{
	//TODO:- implement this api in session class
	//note:- in case success is false client completes the request with SmfErrClientAuthFailed
	//TODO:- define set of smf wide error after consulting with other module owners
	authID.session->clientathorizationFinished(success);
	}
/**
 * This API is called by PM once its done with request and parsing
 * @param requestID The request id which is completed
 * @param parsedData Serialized data(as per request type) filled by PM
 * @param error Error occured
 * TODO:- should use smf wide global errors instead
 */
void SmfServer::resultsAvailable(int requestID,QByteArray* parsedData,SmfError error)
	{
	m_SmfServerPrivate->writeLog("SmfServer::resultsAvailable");
	m_SmfServerPrivate->writeLog("requestID=");
	m_SmfServerPrivate->writeLog(QString::number(requestID));
	m_SmfServerPrivate->writeLog("parsedData->size()=");
	m_SmfServerPrivate->writeLog(QString::number(parsedData->size()));
	m_SmfServerPrivate->writeLog("Error=");
	m_SmfServerPrivate->writeLog(QString::number(error));
	//Serialize error followed by actual data
	QByteArray dataWithError;
	QDataStream writer(&dataWithError,QIODevice::WriteOnly);
	writer<<error;
	writer<<*(parsedData);
	//find out the appropriate session and request id and service that
	m_SmfServerPrivate->findAndServiceclient(requestID,&dataWithError,error);
	}
/**
 * Seems reduntant in symbian as client is served with RMessage2::Complete()
 */
void SmfServer::serviceClient(QByteArray* parsedData)
	{
	Q_UNUSED(parsedData);
	}
/**
 * Used by PM to get a list of tokens
 * TODO:- cross check the params
 */
void SmfServer::getAuthenticationKeys(int pluginID,QStringList& keys,QStringList& urls)
	{
	//SMF-CM communication will be via CM client
	//TODO:- do it properly as per CM client impl
	//CMclient->getKeys(pluginID,keys,urls);
	Q_UNUSED(pluginID);
	Q_UNUSED(keys);
	Q_UNUSED(urls);
	}

/**
 * This is called when CMclient notifies client expiry.
 * @param type notification type, set of enums for future expansion
 * @param id Plugin Id for which the authentication has expired
 */
void SmfServer::authenticationKeysExpired(NotificationType type,SmfPluginID id)
	{
	//resend the notify request
	//CMclient->requestAuthExpiryNotify();
	Q_UNUSED(type);
	Q_UNUSED(id);
	}

void SmfServer::writeLog(QString log) const
	{
#ifdef WRITE_LOG
	QFile file("c:\\data\\SmfServerLogs.txt");
    if (!file.open(QIODevice::Append | QIODevice::Text))
	         ;
    QTextStream out(&file);
    out << log << "\n";
    file.close();
#else
    Q_UNUSED(log);
#endif
	}