/*

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

 */

#include <mtmdef.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <mmsheaders.h>

#include <mmscmds.h>

#include <mmsencode.h>

#include <mmscliententry.h>

#include <logwrap.h>

#include <logcli.h>

#include <logview.h>

#include "mmssettings.h"  //use mmssettings.h instead of cmmssettings.h

#include "mmstestbed.h"

#include "mmsreadfile.h"

#include "mmstestuitimer.h"

#include "mmsteststaticutils.h"

#include "mmstestbed.hrh"

//constants

_LIT( KMmsSender, "0601234567" );

MmsTestBed::MmsTestBed()

    {

    //start the timer

    iTimer = CTestUiTimer::NewL();

    iTimer->Cancel();

    iWait = CMsvOperationActiveSchedulerWait::NewLC();

    // don't leave iWait on cleanup stack

    CleanupStack::Pop();

    //open msvsession

    iSession = CMsvSession::OpenSyncL(*this);

    //create client registry

    iClientMtmRegistry = CClientMtmRegistry::NewL(*iSession);

    //create client mtm

    iMmsClient = (CMmsClientMtm *) iClientMtmRegistry->NewMtmL(

            KUidMsgTypeMultimedia);

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

    iFs.SetSessionPath( KRootPath );

    iSettings = CMmsSettings::NewL();

    iMmsHeaders = CMmsHeaders::NewL(iSettings->MmsVersion());

    findDefaultL();

    iServiceId = iDefaultServiceId;

    //validate the settings

    iSettings->ValidateSettings();

    iLogEvent = CLogEvent::NewL();

    iLogEvent->SetEventType(KLogMmsEventTypeUid);

    iLogClient = NULL; // we test soon if this is available

    iLogView = NULL; // needs log client

    if ( checkLogClient() )

        {

        // first we generate a general view of all events

        // we'll set the filter when we update the view

        iLogView = CLogViewEvent::NewL( *iLogClient );

        }

    iLogFilter = CLogFilter::NewL();

    // we try to filter MMS events

    iLogFilter->SetEventType(KLogMmsEventTypeUid);

    }

MmsTestBed::~MmsTestBed()

    {

    delete iLogView;

    delete iLogFilter;

    delete iLogClient;

    delete iLogEvent;

    delete iSettings;

    delete iMmsHeaders;

    if(iTimer)

    {

        iTimer->Cancel();

        delete iTimer;

    }

    //delete iMsvEntrySelection;

    delete iMmsClient;

    delete iClientMtmRegistry;

    //delete iClientMtmRegistry;

    delete iSession;

    delete iWait;

    }

void MmsTestBed::setConnectionLocal(bool value)

    {

    //value = true for global off, local on

    //value = false for global on, local off

    iSettings->LoadSettingsL();

    iSettings->SetLocalMode( value );

    iSettings->SaveSettingsL();

    }

void MmsTestBed::fromOutboxToMmsc()

    {

    CMsvEntry* cEntry = NULL;

    // Get List of services

    cEntry = iSession->GetEntryL(KMsvGlobalOutBoxIndexEntryIdValue);

    CleanupStack::PushL(cEntry);

    // Get all mms messages of outbox

    CMsvEntrySelection* selection = cEntry->ChildrenWithMtmL(

            KUidMsgTypeMultimedia);

    CleanupStack::PushL(selection);

    // Change state to "KMsvSendStateUnknown" in case the entry has been suspended earlier

    for (TInt i = 0; i < selection->Count(); ++i)

        {

        cEntry->SetEntryL(selection->At(i));

        TMsvEntry entry = cEntry->Entry();

        entry.SetReadOnly(EFalse);

        entry.SetSendingState(KMsvSendStateUnknown);

        cEntry->ChangeL(entry);

        }

    selection->InsertL(0, iServiceId);

    CMsvOperation * op = NULL;

    TCommandParameters parameters; // initialized to zero

    TCommandParametersBuf paramPack(parameters);

    op = iSession->TransferCommandL(*selection, EMmsSend, paramPack,

            iWait->iStatus);

    CleanupStack::PushL(op);

    iWait->Start();

    while (iWait->iStatus.Int() == KRequestPending)

        {

        if (!iTimer->IsActive())

            {

            iTimer->IssueRequest();

            }

        CActiveScheduler::Start();

        }

    if (iWait->iStatus.Int() != KErrNone)

        {

        //DEBUG(_L("Testbed tried to send, return status %d"), iWait->iStatus.Int());

        }

    iTimer->Cancel();

    CleanupStack::PopAndDestroy(); // op

    CleanupStack::PopAndDestroy(); // selection

    CleanupStack::PopAndDestroy(); //cEntry

    }

void MmsTestBed::fromMmscToInbox()

    {

    CMsvEntrySelection* msvEntrySelection = new CMsvEntrySelection;

    CleanupStack::PushL(msvEntrySelection);

    // if we have a selected service, insert it into selection

    if (iServiceId != KMsvNullIndexEntryId)

        {

        msvEntrySelection->InsertL(0, iServiceId);

        }

    CMsvOperation * op = NULL;

    TCommandParameters parameters; // initialized to zero

    TCommandParametersBuf paramPack(parameters);

    op = iMmsClient->InvokeAsyncFunctionL(EMmsReceive, *msvEntrySelection,

            paramPack, iWait->iStatus);

    CleanupStack::PushL(op);

    iWait->Start();

    while (iWait->iStatus.Int() == KRequestPending)

        {

        if (!iTimer->IsActive())

            {

            iTimer->IssueRequest();

            }

        CActiveScheduler::Start();

        }

    if (iWait->iStatus.Int() != KErrNone)

        {

        //DEBUG(_L("Testbed tried to receive, return status %d"),iWait->iStatus.Int());

        }

    iTimer->Cancel();

    CleanupStack::PopAndDestroy(); // op

    CleanupStack::PopAndDestroy(); //msvEntrySelection

    }

void MmsTestBed::findDefaultL()

    {

    iSettings->LoadSettingsL();

    iDefaultServiceId = iSettings->Service();

    }

void MmsTestBed::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1,

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

    {

    iEvent = aEvent;

    if (aEvent == EMsvGeneralError)

        {

        return;

        }

    TMsvId parentId = KMsvNullIndexEntryId;

    if (aArg2 != NULL)

        {

        parentId = *(TMsvId*) aArg2;

        }

    CMsvEntrySelection* selection = (CMsvEntrySelection*) aArg1;

    TMsvEntry tEntry;

    TMsvId service;

    TInt error = KErrNone;

    error = iSession->GetEntry(selection->At(0), service, tEntry);

    CMsvEntry* cEntry = NULL;

    switch (aEvent)

        {

        case EMsvEntriesCreated:

            {

            if (parentId == KMsvGlobalInBoxIndexEntryIdValue)

                {

                // emit signal for new entry into INBOX

                emit entryCreatedInInbox(tEntry.Id());

                }

            else if (parentId == KMsvDraftEntryIdValue)

                {

                // emit signal for new entry into Draft

                emit entryCreatedInDraft(tEntry.Id());

                }

            else if (parentId == iServiceId)

                {

                // emit signal for new Entry into SERVICE

                }

            else

                {

                // do nothing

                }

            }

            break;

        case EMsvEntriesChanged:

            {

            TMsvId id;

            CMsvEntrySelection* selection = (CMsvEntrySelection*) aArg1;

            if (selection == NULL)

                {

                // no selection, cannot handle

                return;

                }

            id = selection->At(0);

            //DEBUG Entry changed"));

            if (parentId == KMsvGlobalInBoxIndexEntryIdValue)

                {

/*

                cEntry = iSession->GetEntryL( parentId );

                CleanupStack::PushL( cEntry );

                TRAPD (error, cEntry->SetEntryL( id ));

                if ( error != KErrNone )

                    {

                    CleanupStack::PopAndDestroy(); // cEntry

                    return;

                    }

                TMsvEntry tEntry = cEntry->Entry();

                if ( tEntry.Visible() )

                    {

                    // generate fake delivery report

                    CMsvStore* store = cEntry->ReadStoreL();

                    CleanupStack::PushL( store );

                    CMmsHeaders* mmsHeaders = CMmsHeaders::NewL( iSettings->MmsVersion() );

                    CleanupStack::PushL( mmsHeaders );

                    mmsHeaders->RestoreL( *store );

                    iEncodeBuffer->ResizeL( 0 );

                    generateDeliveryReport( mmsHeaders );

                    CleanupStack::PopAndDestroy( 2 ); // mmsHeaders, store

                    }

                CleanupStack::PopAndDestroy(); // cEntry

*/

                }

            }

            break;

        case EMsvEntriesDeleted:

            {

            //emit signal for entry deleted

            }

            break;

        case EMsvEntriesMoved:

            {

            if (parentId == KMsvGlobalOutBoxIndexEntryIdValue)

                {

                // entry moved to outbox

                emit entryMovedToOutbox(tEntry.Id());

                }

            else if (parentId == KMsvSentEntryIdValue)

                {

                // entry moved to sent folder

                emit entryMovedToSent(tEntry.Id());

                }

            else

                {

                // do nothing

                }

            }

            break;

        default:

            break;

        }

    }

void MmsTestBed::createMmsService()

    {

    CMmsSettings * settings = CMmsSettings::NewL();

    CleanupStack::PushL( settings );

    settings->CreateNewServiceL( *iSession );

    CleanupStack::PopAndDestroy(); // settings

    return;

    }

void MmsTestBed::cleanup()

    {

    TMsvId entryToBeKilled;

    // Get access to root index

    CMsvEntry* cEntry = iSession->GetEntryL(KMsvRootIndexEntryId);

    CleanupStack::PushL(cEntry);

    entryToBeKilled = iSettings->Service();

    cEntry->SetSortTypeL( TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) );

    while (entryToBeKilled != KMsvNullIndexEntryId)

        {

        // delete child of root entry

        deleteEntry(entryToBeKilled, *cEntry);

        entryToBeKilled = iSettings->Service();

        }

    CleanupStack::PopAndDestroy(); // cEntry

    // We deleted everything!

    iDefaultServiceId = KMsvNullIndexEntryId;

    iServiceId = KMsvNullIndexEntryId;

    }

void MmsTestBed::deleteEntry(TMsvId aEntryId, CMsvEntry& aClientEntry)

    {

    aClientEntry.DeleteL(aEntryId);

    }

void MmsTestBed::cleanupAndCreateNewService()

    {

    cleanup();

    // all old service entries have been destroyed, create a new one

    createMmsService();

    }

void MmsTestBed::testFile(TFileName& aFilePath, TInt aCommand /* = 0 */, TMsvId aBox /* = KMsvGlobalOutBoxIndexEntryId */ )

    {

    // update settings in mmsclient

    iMmsClient->RestoreSettingsL();

    iSettings->CopyL( iMmsClient->MmsSettings() );

    RFileReadStream readStream;

    readStream.PushL();

//    TMsvId id = KMsvNullIndexEntryId;

    CBufFlat* encodeBuffer = NULL;

    CMmsEncode* encoder = NULL;

    // Open the file

    TInt err = readStream.Open(iFs, aFilePath, EFileShareReadersOnly );

    if (err != KErrNone) User::Leave( err );

    TInt   retCode = 0;

    CMmsReadFile* readFile = NULL;

    readFile = CMmsReadFile::NewL( iFs, readStream );

    CleanupStack::PushL( readFile );

    TInt messageCounter = 0;

    CMsvEntry* cEntry = NULL;

    while(!retCode)

        {

        // READ MESSAGE TO BUFFERS

        iMmsHeaders->Reset(iSettings);

        // put in some message type just for fun (testing...)

        iMmsHeaders->SetMessageType( KMmsMessageTypeForwardReq );

        retCode = readFile->CompleteTestL( messageCounter++, *iMmsHeaders );

        if(readFile->iMessageType == ETestNewMessage)

            {

            // CREATE MESSAGE ENTRY

            switch ( aCommand )

                {

                case ECreateToInbox:

                case ECreateNotification:

                    cEntry = iSession->GetEntryL(KMsvGlobalInBoxIndexEntryId);

                    break;

                case ECreateToSentItems:

                    cEntry = iSession->GetEntryL(KMsvSentEntryId);

                    break;

                case ECreateToDrafts:

                    cEntry = iSession->GetEntryL(KMsvDraftEntryId);

                    break;

                case ECreateHeadersFromFile:

                    // here we just encode headers, no message entry

                    // the entry is fake.

                    break;

                case ECreateMMBoxViewConf:

                    if ( iMmsHeaders->MessageType() == KMmsMessageTypeMboxViewConf )

                        {

                        // entry is not created for the description items

                        // they become attachments

                        cEntry = iSession->GetEntryL(KMsvDraftEntryId);

                        }

                    break;

                default:

                    cEntry = iSession->GetEntryL(aBox);

                    break;

                }

            // if we are just playing with headers we have no entry

            if ( aCommand != ECreateHeadersFromFile && aCommand != ECreateMMBoxViewConf )

                {

                CleanupStack::PushL(cEntry);

                iMmsClient->SwitchCurrentEntryL(cEntry->EntryId());

                // CREATE MESSAGE

                iMmsClient->CreateMessageL(iServiceId);

                }

            else if ( aCommand == ECreateMMBoxViewConf )

                {

                if ( iMmsHeaders->MessageType() == KMmsMessageTypeMboxViewConf )

                    {

                    CleanupStack::PushL(cEntry);

                    iMmsClient->SwitchCurrentEntryL(cEntry->EntryId());

                    // CREATE MESSAGE

                    iMmsClient->CreateMessageL(iServiceId);

                    }

                else

                    {

                    encodeBuffer = CBufFlat::NewL( 4 * 1024 ); // should be plenty

                    CleanupStack::PushL( encodeBuffer );

                    encoder = CMmsEncode::NewL( iFs );

                    CleanupStack::PushL( encoder );

                    // encode headers to a binary file

                    encoder->EncodeHeadersL( *iMmsHeaders, *encodeBuffer );

                    iFilename = KMmsMMBoxDescriptionDirectory;

                    TMmsTestUtils::Dump( *encodeBuffer, iFilename, iParse, iFs );

                    CleanupStack::PopAndDestroy( 2 ); // encodeBuffer, encoder

                    encodeBuffer = NULL;

                    encoder = NULL;

                    }

                }

            else

                {

                encodeBuffer = CBufFlat::NewL( 4 * 1024 ); // should be plenty

                CleanupStack::PushL( encodeBuffer );

                encoder = CMmsEncode::NewL( iFs );

                CleanupStack::PushL( encoder );

                // encode headers to a binary file

                encoder->EncodeHeadersL( *iMmsHeaders, *encodeBuffer );

                iFilename = KMmsDumpDirectory;

                TMmsTestUtils::Dump( *encodeBuffer, iFilename, iParse, iFs );

                CleanupStack::PopAndDestroy( 2 ); // encodeBuffer, encoder

                encodeBuffer = NULL;

                encoder = NULL;

                }

            }

        if ( aCommand != ECreateHeadersFromFile &&

            ( aCommand != ECreateMMBoxViewConf || iMmsHeaders->MessageType() == KMmsMessageTypeMboxViewConf ) )

            {

            if(readFile->iMessageType == ETestSettings)

                {

                TMsvId ServiceId = iMmsClient->DefaultServiceL();

                iMmsClient->RestoreSettingsL();

                iSettings->CopyL( iMmsClient->MmsSettings() );

                }

            TMemoryInfoV1Buf memory;

            UserHal::MemoryInfo( memory );

            TInt available = memory().iFreeRamInBytes;

//            TMmsLogger::Log(_L("Free memory before CreateMessageL %d"), available );

            TRAP (err, readFile->CreateMessageL(iMmsClient, iMmsHeaders));

            available = memory().iFreeRamInBytes;

//            TMmsLogger::Log(_L("Free memory after CreateMessageL %d"), available );

            if(readFile->iMessageType == ETestNewMessage)

                {

                TMsvEntry tEntry = iMmsClient->Entry().Entry();

                TMsvId id = tEntry.Id();

                if ( err == KErrNone )

                    {

                    // SAVE MESSAGE

                    iMmsClient->SaveMessageL();

                    // If we are creating a MMBox View confirmation,

                    // we add all binary files from KMmsMMBoxDirectory

                    // as attachments.

                    if ( iMmsHeaders->MessageType() == KMmsMessageTypeMboxViewConf )

                        {

                        addMMBoxDescriptions();

                        }

                    // reload the entry in case mms client put something into it

                    // MESSAGE MUST BE SET VISIBLE

                    tEntry = iMmsClient->Entry().Entry();

                    if ( iMmsClient->MessageClass() == EMmsClassAdvertisement )

                        {

                        tEntry.iMtmData1 |= KMmsMessageAdvertisement;

                        }