/*

* Copyright (c) 2008 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 <textresolver.h> // from CommonEngine

#include <mtclreg.h>

#include <mmsnotificationclient.h>

#include <mmssettings.h>

#include <xqconversions.h> // from xqutils

#include <mmsconst.h>

#include <QDateTime>

#include "conversationmsgstorehandler.h"

#include "draftsmodel.h"

#include "MuiuOperationWait.h"

#include "msgbiouids.h"

#include "UniEditorGenUtils.h"

// SYSTEM INCLUDES

#include <StringLoader.h>

#include <ccsdefs.h> 

#include <msvids.h>

#include <mmserrors.h>

#include <msvuids.h>

#include <smut.h>

#include <SendUiConsts.h>

#include <featmgr.h>

#include <gsmerror.h> 

// CONSTANTS

const TUid KSmsMtmUid ={KSenduiMtmSmsUidValue};

const TUid KMmsMtmUid ={KSenduiMtmMmsUidValue};

_LIT(KUnixEpoch, "19700000:000000.000000");

#define BYTES_TO_KBYTES_FACTOR 1024

// TODO: read global setting of formats on the phone

const QString DATE_FORMAT("dd/MM");

const QString TIME_FORMAT("hh:mm");

// ================= MEMBER FUNCTIONS =======================

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

// Default constructor.

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

//

ConversationMsgStoreHandler::ConversationMsgStoreHandler():

    iMsvSession(NULL),iDraftEntry(NULL),iDraftMessages(NULL),mDraftsModel(NULL),

    iMtmReg(NULL),iMmsClient(NULL),iNotificationClient(NULL)

    {

    TRAP_IGNORE(InitL());

    }

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

// Destructor.

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

//

ConversationMsgStoreHandler::~ConversationMsgStoreHandler()

    {

    if ( iDraftEntry )

        {

        delete iDraftEntry;

        iDraftEntry = NULL;

        }

    if ( iDraftMessages )

        {

        iDraftMessages->Reset();

        delete iDraftMessages;

        iDraftMessages = NULL;

    }

    if (iMmsClient)

    {

        delete iMmsClient;

        iMmsClient = NULL;

    }

    if (iNotificationClient)

    {

        delete iNotificationClient;

        iNotificationClient = NULL;

    }

    if (iMtmReg)

    {

        delete iMtmReg;

        iMtmReg = NULL;

    }

    if (iMsvSession)

    {

        delete iMsvSession;

        iMsvSession = NULL;

        }

    }

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

// 

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

//

void ConversationMsgStoreHandler::InitL( )

    {

    TInt err = KErrNone;

    TRAP(err,iMsvSession = CMsvSession::OpenSyncL(*this));

    if(err != KErrNone)

        {

        iMsvSession = NULL;

        return;

        }

    TRAP(err,iMtmReg = CClientMtmRegistry::NewL(*iMsvSession));

    if(err != KErrNone)

        {

        iMtmReg = NULL;

        return;

        }

	 // Get if offline is supported

    FeatureManager::InitializeLibL();

    if (FeatureManager::FeatureSupported(KFeatureIdOfflineMode))

    {

        iOfflineSupported = ETrue;

    }

    else

    {

        iOfflineSupported = EFalse;

    }

    FeatureManager::UnInitializeLib();

    }

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

// ConversationMsgStoreHandler::HandleSessionEventL()

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

//

void ConversationMsgStoreHandler::HandleSessionEventL(TMsvSessionEvent aEvent,

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

    {   

    //args

    if(aArg1 == NULL || aArg2 == NULL)

        {   

        return;

        }

    //start, processing the event

    CMsvEntrySelection* selection=NULL;

    TMsvId target = 0;

    TMsvId source = 0;

    selection= (CMsvEntrySelection*)aArg1;

    target = *(TMsvId*)aArg2; // target (current) parent

    if(aArg3 != NULL)

        {

        source = *(TMsvId*)aArg3; // source parent

        }

    //process for draft messages only

    if ( target == KMsvDraftEntryIdValue)

        {

        switch( aEvent )

            {

            //case EMsvEntriesCreated:

            case EMsvEntriesChanged:

            case EMsvEntriesMoved:

                {

                TMsvEntry entry;

                TMsvId service;

                TInt error= KErrNone;

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

                    {

                    error = iMsvSession->GetEntry(selection->At(i),service,entry);

                    if (KErrNone == error)

                        {

                        // process only visible entries

                        if (entry.Visible() && IsMtmSupported(entry.iMtm.iUid))

                            {

                                if(mDraftsModel && mDraftsModel->isReady())

                                {

                                    mDraftsModel->addRow(entry);

                                }

                            }

                        }

                    }

                }

                break;

            case EMsvEntriesDeleted:

                {

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

                    {

                    TMsvId id = selection->At( i );

                    if(mDraftsModel && mDraftsModel->isReady())

                        {

                        mDraftsModel->deleteRow(id);

                        }

                    }

                }

                break;

            }//end switch 

        }

    else if(KMsvDraftEntryIdValue == source)

        {

        //if message is moved from drafts to other folder

        // it needs to be removed.

        if(aEvent == EMsvEntriesMoved)

            {

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

                {

                TMsvId id = selection->At( i );

                if(mDraftsModel && mDraftsModel->isReady())

                    {

                    mDraftsModel->deleteRow(id);

                    }

                }

            }

        }

    }

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

// ConversationMsgStoreHandler::MsgStatus

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

//

TCsMmsNotificationMsgState ConversationMsgStoreHandler::

MmsNotificationStatus( TInt aMsvId )

    {

    TMsvId dummy = 0x0;

    TMsvEntry entry;

    iMsvSession->GetEntry(aMsvId, dummy, entry);

    TCsMmsNotificationMsgState status = EMsgStatusNull;

    TTime currentTime;

    currentTime.HomeTime( );

    TTime expiryTime = iNotificationClient->ExpiryDate( );

    TLocale locale;

    expiryTime += locale.UniversalTimeOffset();

    if (locale.QueryHomeHasDaylightSavingOn())          

    {

        TTimeIntervalHours daylightSaving(1);          

        expiryTime += daylightSaving;

    }

    // operationMask includes operation type. It is not bitmap but ordinal number. 

    // It does not include operation status and result

    TInt operationMask = (entry.iMtmData2 & KMmsOperationIdentifier) ;

    // Note! Ongoing operation resets every bit of operation type, operation status

    // and result. E.g. If message has been forwarded and then fetching starts, 

    // information about forwarding is lost

    if( ( entry.iMtmData1 & KMmsMessageTypeMask ) == KMmsMessageMNotificationInd )

        {

        if(     operationMask == KMmsOperationFetch 

                &&  OperationOngoing( entry ) )

            { 

            // It's in retrieving state

            status = EMsgStatusRetrieving;

            }

        else if(    operationMask == KMmsOperationForward

                &&  OperationOngoing( entry ) )

            { 

            // It's in forwarding state

            status = EMsgStatusForwarding;

            }

        else if(    operationMask == KMmsOperationForward

                &&  OperationFinished( entry )

                &&  !( entry.iMtmData2 & KMmsOperationResult ) )

            { 

            // It's been forwarded succesfully

            status = EMsgStatusForwarded;

            }

        else if(    operationMask == KMmsOperationFetch 

                &&  OperationFinished( entry )

                &&   (  entry.iMtmData2 & KMmsOperationResult 

                ||  entry.iError ) )

            { 

            // Fetch has been failed

            status = EMsgStatusFailed;

            }

        else if(    operationMask == KMmsOperationDelete

                &&  OperationFinished( entry )

                &&  !( entry.iMtmData2 & KMmsOperationResult ) )

            { 

            // It's been deleted succesfully

            status = EMsgStatusDeleted;

            }

        else if( currentTime > expiryTime )

            {

            status = EMsgStatusExpired;

            }

        else 

            {   // Normal waiting state

            status = EMsgStatusReadyForFetching;

            }

        }

    return status;

    }

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

// ConversationMsgStoreHandler::OperationOngoing

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

//

TBool ConversationMsgStoreHandler::OperationOngoing( const TMsvEntry& aEntry ) const

    {

    return (    aEntry.iMtmData2 & KMmsOperationOngoing 

            &&  !( aEntry.iMtmData2 & KMmsOperationFinished ) );

    }

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

// ConversationMsgStoreHandler::OperationFinished

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

//

TBool ConversationMsgStoreHandler::OperationFinished( 

    const TMsvEntry& aEntry ) const

    {

    return (    aEntry.iMtmData2 & KMmsOperationFinished

            &&  !( aEntry.iMtmData2 & KMmsOperationOngoing ) );

    }

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

// ConversationMsgStoreHandler::MarkMessagesReadL

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

//

void ConversationMsgStoreHandler::MarkMessagesReadL(RArray<TInt>& aIdArray)

    {    

    for ( int index = 0; index < aIdArray.Count(); index++ )

        {

        TMsvId id = aIdArray[index];

        CMsvEntry* cEntry = NULL;

        TRAPD(err, cEntry = iMsvSession->GetEntryL(id));

        if ( err == KErrNotFound )

            continue; // Entry is already deleted.

        TMsvEntry entry = cEntry->Entry();

        if ( entry.Unread() ) 

            {

            // Mark the entry as read

            entry.SetUnread( EFalse );

            cEntry->ChangeL( entry );

            }

        delete cEntry;

        }

    }

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

// ConversationMsgStoreHandler::DeleteMessages

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

//

void ConversationMsgStoreHandler::DeleteMessages(RArray<TInt>& aIdArray)

{

    for(int index=0;index < aIdArray.Count() ;++index)

    {

        TMsvId id = aIdArray[index];

        iMsvSession->RemoveEntry(id);

    }   

}

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

// ConversationMsgStoreHandler::DeleteAllDraftMessages

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

//

void ConversationMsgStoreHandler::DeleteAllDraftMessagesL()

{

    // Cancel the processing of draft messages.

    iIdle->Cancel();

    CMsvEntry *draftsEntry = iMsvSession->GetEntryL(KMsvDraftEntryIdValue);

    CleanupStack::PushL(draftsEntry);

    CMsvEntrySelection *draftsSelection = draftsEntry->ChildrenL();

    CleanupStack::PushL(draftsSelection);

    if ( draftsSelection->Count() > 0 )

        {

        CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();

        CMsvOperation *operation = draftsEntry->DeleteL(*draftsSelection, wait->iStatus);

        wait->Start();

        CleanupStack::PopAndDestroy(wait);

        delete operation;

        }

    CleanupStack::PopAndDestroy(2, draftsEntry);

}

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

// ConversationMsgStoreHandler::DeleteMessagesL

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

//

CMsvSession& ConversationMsgStoreHandler::GetMsvSession()

{

    return *iMsvSession;

}

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

// ConversationMsgStoreHandler::FetchDraftsMessages

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

//

void ConversationMsgStoreHandler::FetchDraftMessages(DraftsModel* draftsModel)

    {

    mDraftsModel = draftsModel;

    iState = EReadDrafts;

    TCallBack callback = TCallBack(ProcessDraftMessages, (TAny*) this);

    TRAPD(err, iIdle = CIdle::NewL(CActive::EPriorityStandard));

    if(err == KErrNone)

        {

        iIdle->Start(callback);    

        }

    }

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

// ConversationMsgStoreHandler::ProcessDraftMessages

// CIdle callback 

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

//

TInt ConversationMsgStoreHandler::ProcessDraftMessages(TAny* aArg)

    {

    ConversationMsgStoreHandler* handler = (ConversationMsgStoreHandler*) aArg; 

    TInt ok = 0;

    TRAPD(err, ok = handler->ProcessDraftMessagesL());

    return ((err == KErrNone) && ok);

    }

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

// ConversationMsgStoreHandler::ProcessDraftMessagesL

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

//

TInt ConversationMsgStoreHandler::ProcessDraftMessagesL()

    {

    switch(iState)

        {

        case EReadDrafts:

            {

            iDraftEntry = iMsvSession->GetEntryL(KMsvDraftEntryIdValue);

            iDraftMessages = iDraftEntry->ChildrenL();

            iDraftMessageCount = iDraftEntry->Count();

            if ( iDraftMessageCount ) 

                {

                iState = EProcessDrafts;

                }

            else

                {

                iState = EComplete; // no draft messages

                mDraftsModel->setReady(); //ready to handle dynamic events

                CleanupL();

                return 0; //DONE

                }

            return 1;

            }

        case EProcessDrafts:

            {

            if ( iDraftMessageCount ) 

                {

                iDraftMessageCount--;

                TMsvEntry entry = iDraftEntry->ChildDataL(

                        iDraftMessages->At(iDraftMessageCount));

                // process only visible entries

                if (entry.Visible() && IsMtmSupported(entry.iMtm.iUid))

                {

                //add message to model

                mDraftsModel->addRow(entry);

                }

                //continue to process other draft messages

                iState = EProcessDrafts;

                }

            else

                {

                iState = EComplete;

                mDraftsModel->setReady(); //ready to handle dynamic events

                CleanupL();

                return 0; // DONE

                }

            return 1; 

            }

        }

    return 0;

    }

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

// ConversationMsgStoreHandler::CleanupL()

// Helper function for state machine cleanup

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

//

void ConversationMsgStoreHandler::CleanupL()

    {

    if ( iDraftEntry )

        {

        delete iDraftEntry;

        iDraftEntry = NULL;

        }

    if ( iDraftMessages )

        {

        iDraftMessages->Reset();

        delete iDraftMessages;

        iDraftMessages = NULL;

        }

    iDraftMessageCount = 0;

    }

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

// ConversationMsgStoreHandler::IsMtmSupported()

// 

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

//

TBool ConversationMsgStoreHandler::IsMtmSupported(long uid)	

    {

    if ( KSenduiMtmSmsUidValue == uid || KSenduiMtmMmsUidValue == uid )

        {

        return ETrue;

        }	

    return EFalse;

    }

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

// ConversationMsgStoreHandler::ResendMessage(TMsvId aId)

//