/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

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

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 * 

 * Description: Main test class definition for MMS Data Plugin

 */

#include <QtTest/QtTest>

#include <QtDebug>

#include <QTimer>

#include <QSignalSpy>

#include <mmsclient.h>

#include <mmssettings.h>

#include <CMsvMimeHeaders.h>

#include <f32file.h>

#include "debugtraces.h"

#include "convergedmessageaddress.h"

#include "testunidatamodelmmsplugin.h"

#include "testunidatamodelmmsplugin.ini"

#include "xqconversions.h"

#include "unidatamodelplugininterface.h"

#include "unidatamodelloader.h"

//---------------------------------------------------------------

// TestUniDataModelPlugin::initTestCase

//---------------------------------------------------------------

void TestUniDataModelMMSPlugin::initTestCase()

    {

    iObserver = new (ELeave) TestObserverMMS();

    // Create a new messaging server session..

    TRAPD(err,iMSession = CMsvSession::OpenSyncL(*iObserver));

    if(err)

        {

        TInt x = err;

        }

    // Create the client mtm registry

    CClientMtmRegistry* mtmReg = CClientMtmRegistry::NewL(*iMSession);

    // Get the MMS clientmtm

    iMmsClientMtm = static_cast<CMmsClientMtm*> (mtmReg->NewMtmL(KUidMsgTypeMultimedia));

    //Connecting to File Server Session

    User::LeaveIfError( iFs.Connect() );

    iFs.SetSessionPath( KRootPath );

    //Getting Service ID for MMS

    CMmsSettings* settings = CMmsSettings::NewL();

    settings->LoadSettingsL();

    iServiceId = settings->Service();

    iMessageId = 0;

    //Saving the Timestamp before Message is created

    retTimeStamp = QDateTime::currentDateTime();

    // Get the MMS data modelplugin

    pluginLoader = new UniDataModelLoader;

    pluginInterface = pluginLoader->getDataModelPlugin(ConvergedMessage::Mms);

    }

//---------------------------------------------------------------

// TestUniDataModelPlugin::init

//---------------------------------------------------------------

void TestUniDataModelMMSPlugin::init()

{

}

//---------------------------------------------------------------

// TestUniDataModelPlugin::testInboxMessage

//---------------------------------------------------------------

void TestUniDataModelMMSPlugin::testInboxMessage()

    {

	//Create the MMS First

	createMMS(KMsvGlobalInBoxIndexEntryIdValue,ETrue);

	QTest::qWait(50000);  //to ensure path completion

	//MMS Message created, will now be validated

	//Checking if Another Instance of MMS Data Plugin can be created form an existing one

	QObject* anotherInstance = pluginInterface->createInstance();

    QVERIFY(anotherInstance != NULL);

    delete anotherInstance;

    //Setting a Message ID, thereby populating the MMS message at the Plugin

    QVERIFY(pluginInterface->setMessageId(iMessageId) == KErrNone);

    //Verifying the MMS message size

    QVERIFY(pluginInterface->messageSize() == msgSize);

    //Verifying the MMS timestamp

    QVERIFY(pluginInterface->timeStamp() == retTimeStamp);

    //Verifying is the MMP Plugin works file afetr it has been Reset and Restored

    pluginInterface->reset();

	pluginInterface->restore(*iMmsClientMtm);

	QVERIFY(pluginInterface->setMessageId(iMessageId) == KErrNone);

	//Subject Verification

    QVERIFY(pluginInterface->subject().compare(QString(TEST_MSG_SUBJECT)) == 0);

    //MMS message have no Body String

    QString body;

    pluginInterface->body(body);

    QVERIFY(body == QString(""));

    //Message type verification

    QVERIFY(pluginInterface->messageType().compare(QString("mms")) == 0);

    //Fetch the To List

    ConvergedMessageAddressList recipientList;

    pluginInterface->toRecipientList(recipientList);

    QVERIFY(recipientList.count() != 0);

    QVERIFY(recipientList[0]->address().compare(QString(TEST_MSG_RECIEPIENT1)) == 0);

    //Fetch the CC List

    ConvergedMessageAddressList recipientList2;

    pluginInterface->ccRecipientList(recipientList2);

    QVERIFY(recipientList2.count() != 0);

    QVERIFY(recipientList2[0]->address().compare(QString(TEST_MSG_RECIEPIENT2)) == 0);

    //Fetch the BCC List

    ConvergedMessageAddressList recipientList3;

    pluginInterface->bccRecipientList(recipientList3);

    QVERIFY(recipientList3.count() != 0);

    QVERIFY(recipientList3[0]->address().compare(QString(TEST_MSG_RECIEPIENT3)) == 0);

    //Fetch the From Address

    QString recepient(TEST_MSG_FROM1);

    QString fromaddress;

    pluginInterface->fromAddress(fromaddress);

    QVERIFY(recepient == fromaddress);

    //Verifying Attachments

    UniMessageInfoList attList = pluginInterface->attachmentList();

    QVERIFY(attList.count() == 0);

    QVERIFY(pluginInterface->hasAttachment() == false);

    QVERIFY(pluginInterface->attachmentCount() == 0);

    QVERIFY(pluginInterface->messagePriority() == 1);

    //Verifying various objects added to the MMS Message during creation

    QVERIFY(pluginInterface->objectCount() == 2);

    UniMessageInfoList objectlist = pluginInterface->objectList();

    QVERIFY(!objectlist.isEmpty());

    QVERIFY(objectlist[1]->path().contains(QString("TestUnidataModelMMSPluginPhoto.jpg"), Qt::CaseInsensitive) == true);

	QVERIFY(objectlist[1]->mimetype().contains(QString("image/jpeg"), Qt::CaseInsensitive) == true);

    QVERIFY(pluginInterface->slideCount() == 1);

    QVERIFY(pluginInterface->slideContent(0)[0]->path().contains(QString("Story.txt"), Qt::CaseInsensitive) == true);

    QVERIFY(pluginInterface->slideContent(0)[0]->mimetype().contains(QString("text/plain"), Qt::CaseInsensitive) == true);

    //Verifying if the plugin returns the correct session, thus will correctly delete the MMS we just created

    CMsvSession* msvSession = pluginInterface->session();

    QVERIFY(msvSession != NULL);

    msvSession->RemoveEntry(iMessageId);

    qDebug() << "Verified Test MMS Successfully";    

    }

//---------------------------------------------------------------

// TestUniDataModelPlugin::cleanup

//---------------------------------------------------------------

void TestUniDataModelMMSPlugin::cleanup()

{

}

//---------------------------------------------------------------

// TestUniDataModelPlugin::cleanupTestCase

//---------------------------------------------------------------

void TestUniDataModelMMSPlugin::cleanupTestCase()

    {

	//Cleanup

	delete pluginInterface;

	delete pluginLoader;

    delete iMmsClientMtm;

    delete iMSession;

    delete iObserver;

    }

//---------------------------------------------------------------

// TestUniDataModelPlugin::createMMS

//---------------------------------------------------------------

void TestUniDataModelMMSPlugin::createMMS(TMsvId pId, TBool subjectField)

    {

    TMsvEntry indexEntry;

    indexEntry.iType = KUidMsvMessageEntry;

    indexEntry.iMtm = KUidMsgTypeMultimedia;

    indexEntry.iServiceId = iServiceId;

    indexEntry.iDate.HomeTime();

    // Convert TTime to QDateTime , this will be used for comparing the time of mesage 

    // when fetched from datamodel

    TTime unixEpoch(KUnixEpoch);

    TTimeIntervalSeconds seconds;

    TTime timeStamp = indexEntry.iDate;

    timeStamp.SecondsFrom(unixEpoch, seconds);

    retTimeStamp.setTime_t(seconds.Int());

    TMsvId parentId = pId;

    CMsvEntry* entry = CMsvEntry::NewL(*iMSession,parentId,TMsvSelectionOrdering());

    CleanupStack::PushL(entry);

    entry->SetEntryL(parentId);

    entry->CreateL(indexEntry);

    entry->SetEntryL(indexEntry.Id());

    iMmsClientMtm->SwitchCurrentEntryL(entry->EntryId());

    CMsvStore* store = iMmsClientMtm->Entry().EditStoreL();

    CleanupStack::PushL(store);

    //MMS Message ID Saved

    iMessageId = indexEntry.Id();

    //Adding Subject

    if(subjectField)

        {

        QString subject(TEST_MSG_SUBJECT);

        HBufC* subj = XQConversions::qStringToS60Desc(subject);

        iMmsClientMtm->SetSubjectL(*subj);

        }

    //Adding Sender

    QString sender(TEST_MSG_FROM1);

    HBufC* addr = XQConversions::qStringToS60Desc(sender);

    if (addr)

        {

        CleanupStack::PushL(addr);

        TBuf<32> name;

        name.Copy(addr->Left(32));

        indexEntry.iDetails.Set(name);

        iMmsClientMtm->SetSenderL(*addr);

        CleanupStack::PopAndDestroy(addr);

        }

    //Adding Recipient

    QString recipient(TEST_MSG_RECIEPIENT1);

    HBufC* addr2 = XQConversions::qStringToS60Desc(recipient);

    if (addr2)

        {

        CleanupStack::PushL(addr2);

        iMmsClientMtm->AddAddresseeL(EMsvRecipientTo,*addr2);

        CleanupStack::PopAndDestroy(addr2);

        }

    //Adding cCRecipient

    QString recipient2(TEST_MSG_RECIEPIENT2);

    HBufC* addr3 = XQConversions::qStringToS60Desc(recipient2);

    if (addr3)

        {

        CleanupStack::PushL(addr3);

        iMmsClientMtm->AddAddresseeL(EMsvRecipientCc,*addr3);

        CleanupStack::PopAndDestroy(addr3);

        }

    //Adding bCCRecipient

    QString recipient3(TEST_MSG_RECIEPIENT3);

	HBufC* addr4 = XQConversions::qStringToS60Desc(recipient3);

	if (addr4)

		{

		CleanupStack::PushL(addr4);

		iMmsClientMtm->AddAddresseeL(EMsvRecipientBcc,*addr4);

		CleanupStack::PopAndDestroy(addr4);

		}

    //Create Text Attachment

    TMsvAttachmentId attaId = 0;

    TFileName attachmentFile( _L("story.txt") );

    TBufC<12> story = _L( "Hello world!" );

    iMmsClientMtm->CreateTextAttachmentL(*store, attaId, story, attachmentFile, ETrue );

    qDebug() << "Text Attachment id" << attaId;

    //Image Attachment added to the message entry

    RFile attaFile;

	// Set filename of attachment

	TFileName name( KPictureFileName );

	CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

	CleanupStack::PushL( mimeHeaders );

	// Set values to mime headers

	mimeHeaders->SetContentTypeL( _L8( "image") );

	mimeHeaders->SetContentSubTypeL( _L8( "jpeg" ) );

	_LIT8(KMimeType, "image/jpeg");

	TBufC8<10> mimeType(KMimeType);

	// CreateAttachment2L will set the content type to attachment Info

	// Open the attachment file for reading

	attaFile.Open( iFs, name, EFileShareReadersOnly | EFileRead );

	CleanupClosePushL(attaFile);

	CMsvAttachment* attaInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

	// attaInfo ownerhip will be transferred to Attachment Manager.

	// It must not be pushed onto the cleanupStack before calling 

	// CreateAttachment2L.

	iMmsClientMtm->CreateAttachment2L(*store, attaFile,mimeType,*mimeHeaders,attaInfo,attaId);

	qDebug() << "Image Attachment id" << attaId;

	// Now Attachment Manager owns the attaInfo

	CleanupStack::Pop(); // attaFile.Close()

	CleanupStack::PopAndDestroy(); // mimeHeaders

    store->CommitL();

    CleanupStack::PopAndDestroy(store); // store

    iMmsClientMtm->SaveMessageL();

    //Saving the message size for future checking

    msgSize = iMmsClientMtm->MessageSize();

    CleanupStack::Pop(entry); // entry

    }

//---------------------------------------------------------------

// TestObserverMMS::HandleSessionEventL

//---------------------------------------------------------------

void TestObserverMMS::HandleSessionEventL(TMsvSessionEvent /*aEvent*/,

                                       TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

{

}

//---------------------------------------------------------------

// main

// main entry point

//---------------------------------------------------------------

int main(int argc, char *argv[])

    { 

	int ret = -1;

	QCoreApplication app(argc, argv);

	QObject* tc = new TestUniDataModelMMSPlugin();

#ifdef __WINSCW__

	char *new_argv[3]; 

	QString str = "C:\\data\\" + QFileInfo(QCoreApplication::applicationFilePath()).baseName() + ".log";	

	QByteArray bytes = str.toAscii();	

	char arg1[] = "-o";	

	new_argv[0] = argv[0];	

	new_argv[1] = arg1;	

	new_argv[2] = bytes.data();	

	ret = QTest::qExec(tc, 3, new_argv);

#else

	ret = QTest::qExec(tc, argc, argv); 

#endif

	delete tc;

	return ret;

    }

//End of File