/**

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

 * Private implementation of music related services

 * 

 */

#include <qdebug.h>

#include <smfmusicrating.h>

#include <smfcomment.h>

#include <smfmusicfingerprint.h>

#include <smfcontact.h>

#include "smfmusic.h"

#include "smfmusic_p.h"

#ifdef Q_OS_SYMBIAN

	#include "smfclientsymbian.h"

#else

	#include "smfclientqt.h"

#endif

//SmfMusicServicePrivate start

SmfMusicServicePrivate::SmfMusicServicePrivate(SmfMusicService* aMusicService)

		:m_musicService(aMusicService)

	{

#ifdef Q_OS_SYMBIAN

	//private impl for symbian

	m_SmfClientPrivate = CSmfClientSymbian::NewL(this);

#else

	//TODO:- Use private impl for other platforms or else Qt impl

#endif

	}

SmfMusicServicePrivate::~SmfMusicServicePrivate()

	{

	if(m_SmfClientPrivate)

		{

		delete m_SmfClientPrivate;

		m_SmfClientPrivate = NULL;

		}

	}

SmfError SmfMusicServicePrivate::userMusicInfo()

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QString intfName(musicServiceInterface);

	int maxalloc = SmfMusicProfileMaxSize;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName, 

			SmfMusicGetUserInfo, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::searchArtist ( SmfArtists artist, int pageNum, int perPage )

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<artist;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<pageNum;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<perPage;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	int maxalloc = SmfMusicProfileMaxSize*perPage;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

			SmfMusicSearchArtist, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::searchAlbum ( SmfAlbum album, int pageNum, int perPage )

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<album;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<pageNum;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<perPage;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	int maxalloc = SmfMusicProfileMaxSize*perPage;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

			SmfMusicSearchAlbum, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::searchEvents ( SmfEvent event, int pageNum, int perPage )

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<event;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<pageNum;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<perPage;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	int maxalloc = SmfMusicProfileMaxSize*perPage;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

			SmfMusicSearchEvent, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::searchVenue ( SmfLocation location, int pageNum, int perPage )

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<location;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<pageNum;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<perPage;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	int maxalloc = SmfMusicProfileMaxSize*perPage;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

			SmfMusicSearchVenue, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::searchUser(SmfLocation venue, int pageNum, int perPage)

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<venue;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<pageNum;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<perPage;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	int maxalloc = SmfMusicProfileMaxSize*perPage;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

	SmfMusicSearchUser, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::customRequest ( const int& operationId, QByteArray* customData )

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<operationId;

	if(customData)

		{

		streamToPlugin<<m_argFlag;

		streamToPlugin<<*customData;

		}

	else

		{

		m_argFlag = 0;

		streamToPlugin<<m_argFlag;

		}

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	//ToDo:- How much size to allocate for custo data? keeping SmfMusicProfileMaxSize for now

	int maxAlloc = SmfMusicProfileMaxSize;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

			SmfMusicServiceCustomRequest, maxAlloc);

	return err;

	}

SmfError SmfMusicServicePrivate::postCurrentPlaying(SmfTrackInfo track) 

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*(m_baseProvider);

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<track;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	//TODO:-revisit all the maxalloc

	int maxalloc = 1000;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

			SmfMusicPostCurrentPlaying, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::postRating(SmfTrackInfo track, SmfMusicRating rate) 

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*(m_baseProvider);

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<track;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<rate;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	//TODO:-revisit all the maxalloc

	int maxalloc = 1000;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

	SmfMusicPostRating, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::postComments(SmfTrackInfo track, SmfComment comment) 

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray 

	SmfProvider* m_baseProvider = m_musicService->getProvider();

	m_serializedDataToServer.clear();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*(m_baseProvider);

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<track;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<comment;

	write<<dataToPlugins;

	QString intfName(musicServiceInterface);

	//TODO:-revisit all the maxalloc

	int maxalloc = 1000;

	//call private impl's send method

	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

			SmfMusicPostComment, maxalloc);

	return err;

	}

SmfError SmfMusicServicePrivate::cancelRequest()

	{

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

	QByteArray notused;

	QByteArray retData = m_SmfClientPrivate->sendSyncRequest(notused,SmfCancelRequest,1000, notused);

	//De-serialize it into SmfError

	QDataStream reader(&retData,QIODevice::ReadOnly);

	int val;

	reader>>val;

	SmfError error = (SmfError) val;

	return error;

	}

void SmfMusicServicePrivate::resultsAvailable(QByteArray result, SmfRequestTypeID opcode, SmfError error)

	{

	//note:- "result" is serialized and we need to de-serialize it as per opcode

	//Order of serialization Error value followed by data

	QDataStream reader(&result,QIODevice::ReadOnly);

	//Now de-serialize it based on opcode

	switch(opcode)

		{

		case SmfMusicGetUserInfo:

			{

			SmfMusicProfile* m_profile = new SmfMusicProfile;

			reader>>*m_profile;

			emit m_musicService->userMusicInfoAvailable(m_profile,error);

			break;

			}

		case SmfMusicSearchArtist:

			{

			SmfArtistsList *m_List = new SmfArtistsList;

			reader>>*m_List;

			//ToDo :- not incorporating paging now

			SmfResultPage page;

			emit m_musicService->searchArtistInfoAvailable(m_List, error, page);

			break;

			}

		case SmfMusicSearchAlbum:

			{

			SmfAlbumList *m_List = new SmfAlbumList;

			reader>>*m_List;

			//ToDo :- not incorporating paging now

			SmfResultPage page;

			emit m_musicService->searchAlbumInfoAvailable(m_List, error, page);

			break;

			}

		case SmfMusicSearchEvent:

			{

			SmfEventList *m_List = new SmfEventList;

			reader>>*m_List;

			//ToDo :- not incorporating paging now

			SmfResultPage page;

			emit m_musicService->searchEventsInfoAvailable(m_List, error, page);

			break;

			}

		case SmfMusicSearchVenue:

			{

			SmfLocationList *m_List = new SmfLocationList;

			reader>>*m_List;

			//ToDo :- not incorporating paging now

			SmfResultPage page;

			emit m_musicService->searchVenueInfoAvailable(m_List, error, page);

			break;

			}

		case SmfMusicSearchUser:

			{

			SmfMusicProfileList* m_profileList = new SmfMusicProfileList;

			reader>>*m_profileList;

			//ToDo :- not incorporating paging now

			SmfResultPage page;

			emit m_musicService->searchUserInfoAvailable(m_profileList, error, page);

			break;

			}

		case SmfMusicPostCurrentPlaying:

		case SmfMusicPostRating:

		case SmfMusicPostComment:

			{

			emit m_musicService->postfinished(error);

			break;

			}

		case SmfMusicServiceCustomRequest:

   			{

   			int operationId;

   			QByteArray *data = new QByteArray;

   			reader>>operationId;

   			reader>>*data;

   			qDebug()<<"operationId = "<<operationId;

   			qDebug()<<"data size = "<<data->size();

   			emit m_musicService->customDataAvailable(operationId, data);

   			break;

   			}

		default:

			User::Panic(_L("Music Service Private = "),opcode);

		}

	}

//SmfMusicServicePrivate start

//SmfMusicSearchPrivate start

SmfMusicSearchPrivate::SmfMusicSearchPrivate(SmfMusicSearch *aMusicSearch)

		: m_musicSearch(aMusicSearch)

	{

#ifdef Q_OS_SYMBIAN

	//private impl for symbian

	m_SmfClientPrivate = CSmfClientSymbian::NewL(this);

#else

	//TODO:- Use private impl for other platforms or else Qt impl

#endif

	}

SmfMusicSearchPrivate::~SmfMusicSearchPrivate()

	{

	if(m_SmfClientPrivate)

		{

		delete m_SmfClientPrivate;

		m_SmfClientPrivate = NULL;

		}

	}

SmfError SmfMusicSearchPrivate::recommendations(SmfTrackInfo track, int pageNum, int perPage)

	{

	SmfError err = SmfNoError;

	//We need to pass Opcode and SmfProvider serialized into bytearray

	m_serializedDataToServer.clear();

	SmfProvider* m_baseProvider = m_musicSearch->getProvider();

	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

	write<<*m_baseProvider;

	QByteArray dataToPlugins;

	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

	m_argFlag = 1;

	streamToPlugin<<m_argFlag;

	streamToPlugin<<track;