/*
 * Copyright (c) 2007 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:  This class helps CS Cache in processing the data.
 *
 */

// INCLUDE FILES
// SYSTEM INCLUDE FILES
#include <ccsdefs.h>
#include <ccsconversationentry.h>
#include <ccsclientconversation.h>

// USER INCLUDE FILES
#include "ccsconversationcachehelper.h"
#include "ccsconversationcache.h"
#include "ccsconversation.h"
#include "ccsconversationentry.h"
#include "ccsconversationevent.h"
#include "ccscontactsmanager.h"
#include "ccscontactsresolver.h"
#include <xqconversions.h>
#include "ccsdebug.h"

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

// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::NewL
// Two Phase Construction
// ----------------------------------------------------------------------------
CCsConversationCacheHelper*
CCsConversationCacheHelper::NewL(CCsConversationCache* aConversationCache)
{
    PRINT ( _L("Enter CCsConversationCacheHelper::NewL") );

    CCsConversationCacheHelper* self =
            new (ELeave) CCsConversationCacheHelper(aConversationCache);

    CActiveScheduler::Add(self);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);

    PRINT ( _L("End CCsConversationCacheHelper::NewL") );

    return self;
}

// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::CCsConversationCacheHelper
// Construtor
// ----------------------------------------------------------------------------
CCsConversationCacheHelper::CCsConversationCacheHelper(
                                                       CCsConversationCache* aConversationCache) :
    CActive(EPriorityLow), iConversationCache(aConversationCache)
{
}

// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::ConstructL
// Second phase constructor
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::ConstructL()
{
    iConversationEvent = NULL;
    iConversationIndex = KErrNotFound;
    iCurrentConversationIndex = KErrNotFound;

    //initialize the event list
    iConversationEventList
            = new (ELeave) RPointerArray<CCsConversationEvent> ();

    // now create all special type of conversations
    // like BT, IRDA, Unknown Drafts etc.
    TInt loop = 0;
    for (loop = 0; loop < KMaxSpecialConversations; loop++)
    {
        CreateSpecialConversationL();
    }
}

// ----------------------------------------------------------------------------
// CCsConversationCache::CreateSpecialConversationL
// Second part of constructL
// This shall create all special type of messages like BT, Unknown Draft, IRDA etc.
// Pls note this shall be placed by order at starting of cache
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::CreateSpecialConversationL()
{
    // Create a conversation for Drafts Unknown case and set it in
    // 0th position and the conversation Id for drafts unknown case is
    // KDratsUnknownConversationId
    CCsConversation* conversation = CCsConversation::NewL();

    conversation->SetConversationId(GetNextRowId());

    // add into the list
    iConversationCache->ConversationList()->AppendL(conversation);
}

// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::CCsConversationCacheHelper
// Destructor
// ----------------------------------------------------------------------------
CCsConversationCacheHelper::~CCsConversationCacheHelper()
{
    Cancel();

    // delete the event list
    if (iConversationEventList)
    {
        iConversationEventList->ResetAndDestroy();
        iConversationEventList->Close();
        delete iConversationEventList;
        iConversationEventList = NULL;
    }
}
// -----------------------------------------------------------------------------
// CCsConversationCacheHelper::DoCancel()
// DoCancel implementation from CActive Object
// -----------------------------------------------------------------------------
//
void CCsConversationCacheHelper::DoCancel()
{
    // do nothing    
}
// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::Run
// Called from the scheduler
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::RunL()
{
    switch (iState)
    {
        case ECsProcessConversation:
        {
            HandleProcessConversationL();
        }
            break;

        case ECsSpecialConversation:
        {
            HandleSpecialConversationL();
        }
            break;

        case ECsConversationFoundInCache:
        {
            HandleConversationInCacheL();
        }
            break;

        case ECsResolveConversation:
        {
            ResolveContact(iConversationEvent);
        }
            break;
    }
}
// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::StartCacheUpdate
// this shall start looking at cache data and update if entry already exist
// shall put request to phonebook in case new data
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::StartCacheUpdate()
{
    iState = ECsProcessConversation;
    IssueRequest();
}
// ---------------------------------------------------------------------------
// CCsConversationCacheHelper::HandleProcessConversationL()
// Process Conversation and update cache
// ---------------------------------------------------------------------------
//
void CCsConversationCacheHelper::HandleProcessConversationL()
{
    iConversationEvent = GetNextEvent();
    // check to see if all the events are consumed
    // then mark cache as caching done..
    if (!iConversationEvent)
    {
        iConversationCache->CachingCompletedL();
        return;
    }

    CCsConversationEntry* conEntry =
            iConversationEvent->ClientConversation()->GetConversationEntry();

    //handle add, modify events
    if (iConversationEvent->Event() != KConversationEventDelete)
    {
        TUint8 SpecialId = NeedsSpecialProcessing(conEntry);

        if (SpecialId)
        {
            // this is for draft(unlnown)/BT/IR processing            
            iState = ECsSpecialConversation;
        }
        // check only if contact is a valid address
        else if (conEntry->Contact())
        {
            iCurrentConversationIndex
                    = iConversationCache->FindConversation(* (conEntry->Contact()));
            if (iCurrentConversationIndex != KErrNotFound)
            {
                iState = ECsConversationFoundInCache;
            }
            else
            {
                iState = ECsResolveConversation;
            }
        }
        else
        {
            // this is when contact number is NULL
            // delete the entry from temp list
            DeleteEvent(*iConversationEvent);
            iState = ECsProcessConversation;
        }
    }
    else
    {
        //handle delete event
        DeleteConversationEntryL(conEntry);
        DeleteEvent(*iConversationEvent);
        iState = ECsProcessConversation;
    }
    //move to other state
    IssueRequest();
}
// ---------------------------------------------------------------------------
// CCsConversationCacheHelper::HandleSpecialConversationL()
// Hnadle the case when the conversation has no contact,
// BlueTooth/IrDa messages
// ---------------------------------------------------------------------------
//
void CCsConversationCacheHelper::HandleSpecialConversationL()
{
    CCsConversationEntry* conEntry =
        iConversationEvent->ClientConversation()->GetConversationEntry();

    if (ECsBlueTooth == conEntry->GetType())
    {
        AddConversationEntryL(conEntry, KBluetoothMsgsConversationId);
    }
    else
    {
        AddConversationEntryL(conEntry, KUnknownConversationId);
    }
    DeleteEvent(*iConversationEvent);
    iState = ECsProcessConversation;
    IssueRequest();

    PRINT ( _L("CCsConversationCacheHelper::HandleSpecialConversationL") );
}
// ---------------------------------------------------------------------------
// CCsConversationCacheHelper::HandleConversationInCacheL()
// Handle the case when the conversation is found in the cache
// so there is no need for resolving the contact
// ---------------------------------------------------------------------------
//
void CCsConversationCacheHelper::HandleConversationInCacheL()
{
    CCsConversationEntry* conEntry =
            iConversationEvent->ClientConversation()->GetConversationEntry();

    AddConversationEntryL(conEntry, iCurrentConversationIndex);

    DeleteEvent(*iConversationEvent);

    // reset back the conversation index
    iCurrentConversationIndex = KErrNotFound;
    iState = ECsProcessConversation;
    IssueRequest();
}
// ----------------------------------------------------------------------------
// This function identifies if the conentry needs special processing
// Drafts message with NULL contact/Bluetooth/IRDA etc
// ----------------------------------------------------------------------------
TUint8 CCsConversationCacheHelper::NeedsSpecialProcessing(
                                                          CCsConversationEntry* aConversationEntry)
{
    if (ECsBlueTooth == aConversationEntry->GetType())
    {
        return 1;
    }
    return 0;
}

// ---------------------------------------------------------------------------
// Move to next state
// ---------------------------------------------------------------------------
//
void CCsConversationCacheHelper::IssueRequest()
{
    if (!IsActive())
    {
        iStatus = KRequestPending;
        TRequestStatus* status = &iStatus;
        SetActive();
        User::RequestComplete(status, KErrNone);
    }
}

// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::ContactResolved
// Handle a contact resolved in the contact database
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::ResolveContact(
                                                CCsConversationEvent* aConverastionEvent)
{
    CCsContactDetail contactDetail;

    //get contact from event
    CCsConversationEntry* ConvEntry =
            aConverastionEvent->ClientConversation()->GetConversationEntry();

    if (ConvEntry)
    {
        HBufC* Contact = ConvEntry->Contact();
        if (Contact)
        {
            QString contactAddress =
                    XQConversions::s60DescToQString(Contact->Des());

            iConversationCache->ContactsManager()->resolver()->resolveContact(contactAddress,
                                                                              contactDetail);

            int contactId = contactDetail.contactId;
            TInt cIndex = iConversationCache->FindConversation(contactId);

            if (cIndex == KErrNotFound)
            {
                // Add as new conversation
                HBufC* displayName = NULL;
                if(!contactDetail.displayName.isEmpty())
                {
                    displayName=XQConversions::qStringToS60Desc(contactDetail.displayName);
                }
                TRAPD(error, AddNewConversationL( aConverastionEvent->
                                ClientConversation()->GetConversationEntry(),
                                contactId,
                                displayName));

                if (displayName) delete displayName;                

                if (error != KErrNone)
                {
                    // handle error
                }
            }
            else
            {
                // this is when two contacts are having same contact Id,
                // in that case it should add into an existing conversation
                TRAPD(error, AddConversationEntryL( 
                        aConverastionEvent->ClientConversation(
                                )->GetConversationEntry(), cIndex));
                if (error != KErrNone)
                {
                    // handle error
                }
            }

            // now remove the entry from event list
            DeleteEvent(*aConverastionEvent);

            // call start update cache
            StartCacheUpdate();
        }
    }
}

// ----------------------------------------------------------------------------
// Handles the case where conversation is already in cache
// This will add new conversation entry into the corresponding conversation
// pls note there is already a conversation exist for this entry
// hence this entry gets appended inside conversation list
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::AddConversationEntryL(
                                                       CCsConversationEntry *aConEntry,
                                                       TInt aConversationIndex)
{
    RPointerArray<CCsConversation>* conversationList =
            iConversationCache->ConversationList();

    CCsConversation* conversation = (*conversationList)[aConversationIndex];

    CCsConversationEntry* prevLatestEntry = conversation->GetLatestEntryL();

    if (prevLatestEntry)
    {
        prevLatestEntry = prevLatestEntry->CloneL();
    }
    else
    {
        prevLatestEntry = aConEntry->CloneL();
    }

    CleanupStack::PushL(prevLatestEntry);

    // save the previous unread message count
    TUint16 prevUnreadCount = conversation->GetUnreadMessageCount();

    TUint32 event;
    conversation->UpdateEntryL(aConEntry, event);

    // Send update notify to conversation list
    if (IsNotifyRequiredL(conversation,
                          prevLatestEntry,
                          KConversationListEventUpdate,
                          prevUnreadCount))
    {
        CCsConversationEntry* convEntry = conversation->GetLatestEntryL();
        CCsClientConversation* clientConvLatest =
                iConversationCache->CreateClientConvLC(conversation, convEntry);
        
        // THIS IS USED FOR SHOWING NOTIFICATIONS. NOTIFICATION IS SHOWN ONLY
        // WHEN ECsAttributeNewEntryAdded IS SET. 
        if(iConversationEvent->IsUpdateConversationEventSet() 
                && event == KConversationEventNew)
            {
            clientConvLatest->GetConversationEntry()->
            ChangeAttributes(ECsAttributeNewEntryAdded,ECsAttributeNone);
            }
        
        iConversationCache->NotifyL(clientConvLatest,
                                    KConversationListEventUpdate);
        CleanupStack::PopAndDestroy(clientConvLatest);
    }

    // Send update notify to conversations
    CCsClientConversation* clientConv =
            iConversationCache->CreateClientConvLC(conversation, aConEntry);
    iConversationCache->NotifyL(clientConv, event);

    // Cleanup
    CleanupStack::PopAndDestroy(clientConv);
    CleanupStack::PopAndDestroy(prevLatestEntry);
}

// ----------------------------------------------------------------------------
// CCsConversationCache::DeleteConversationL
// Delete conversation entry from conversation list
// there are few checks of how to notify the UI about the changes 
// for the various use cases. 
// Delete requires the conversation Id and type (SMS, MMS etc.)
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::DeleteConversationEntryL(
                                                          CCsConversationEntry* aConversationEntry)
{
    // For MMS, search the entry inside all conversations and delete.
    // For SMS, stop on first match.
    TBool stopOnFirstMatch = ETrue;

    RPointerArray<CCsConversation>* conversationList =
            iConversationCache->ConversationList();

    // the deletion needs search the entryId inside whole conversation
    // search the entry id and delete the entry
    for (TInt loop = 0; loop < iConversationCache->ConversationList()->Count(); loop++)
    {
        CCsConversation* conversation =
                static_cast<CCsConversation*> ( (*conversationList)[loop]);

        TInt indexDeletion = conversation->FindEntry(aConversationEntry);

        if (indexDeletion != KErrNotFound)
        {
            // Get the entry from cache to check the type
            CCsConversationEntry* cacheEntry =
                    conversation->GetEntryL(indexDeletion);

            if (cacheEntry->GetType() == ECsMMS || cacheEntry->GetType()
                    == ECsAudio)
            {
                stopOnFirstMatch = EFalse;
            }
            
            TUint16 prevUnreadCount = conversation->GetUnreadMessageCount();

            // Delete the conversation entry from this conversation
            conversation->DeleteEntryL(indexDeletion);

            // Notify client of conversation list change.
            if (IsNotifyRequiredL(conversation,
                                  aConversationEntry,
                                  KConversationListEventDelete,
                                  prevUnreadCount))
            {
                // Delete
                CCsClientConversation
                        * clientConv =
                                iConversationCache->CreateClientConvLC(conversation,
                                                                       aConversationEntry);
                iConversationCache->NotifyL(clientConv,
                                            KConversationListEventDelete);
                CleanupStack::PopAndDestroy(clientConv);

                // Update with latest entry
                CCsConversationEntry* conEntry =
                        conversation->GetLatestEntryL();
                if (conEntry)
                {
                    CCsClientConversation
                            * clientConv =
                                    iConversationCache->CreateClientConvLC(conversation,
                                                                           conEntry);
                    iConversationCache->NotifyL(clientConv,
                                                KConversationListEventNew);
                    CleanupStack::PopAndDestroy(clientConv);
                }
            }

            // Notify client of conversation change
            if (!conversation->IsDeleted())
            {
                CCsClientConversation
                        * clientConv =
                                iConversationCache->CreateClientConvLC(conversation,
                                                                       aConversationEntry);
                iConversationCache->NotifyL(clientConv,
                                            KConversationEventDelete);
                CleanupStack::PopAndDestroy(clientConv);
            }

            // check if all entries are deleted then 
            // delete the conversation from cache
            if (conversation->GetEntryCount() == 0
                    && !conversation->IsSpecialConversation())
            {
            
            conversationList->Remove(loop);
            delete conversation;
            //reset the counters
            loop -= 1;
            }

            // Stop searching    
            if (stopOnFirstMatch) break;
        }
    } // for
}

// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::AddNewConversationL
// add new conversation into cache
// this shall be called after resolving entry from phonebook
// ----------------------------------------------------------------------------
void CCsConversationCacheHelper::AddNewConversationL(
                                                     CCsConversationEntry* aConversationEntry,
                                                     TInt32 aContactId,
                                                     const HBufC* aDisplayName)
{
    CCsConversation* conversation = CCsConversation::NewL();
    CleanupStack::PushL(conversation);

    //set conversation entry id
    // by default just set the count of list as of now, as it will be unique
    conversation->SetConversationId(GetNextRowId());

    // add the conversation entry
    conversation->AddEntryL(aConversationEntry);

    // fill firstname and lastname and contact Id
    if(aDisplayName)
   		conversation->AddContactDetailsL(aContactId,
                                     aDisplayName);

    // fill the phone number
    if (aConversationEntry->Contact())
    {
        conversation->AddContactDetailsL(* (aConversationEntry->Contact()));
    }

    // add into the list
    iConversationCache->ConversationList()->AppendL(conversation);

    // Send add notify to conversation list
    CCsClientConversation* clientConv =
            iConversationCache->CreateClientConvLC(conversation,
                                                   aConversationEntry);
    
    // THIS IS USED FOR SHOWING NOTIFICATIONS. NOTIFICATION IS SHOWN ONLY
    // WHEN ECsAttributeNewEntryAdded IS SET.
    if(iConversationEvent->IsUpdateConversationEventSet()) 
        {
        clientConv->GetConversationEntry()->
        ChangeAttributes(ECsAttributeNewEntryAdded,ECsAttributeNone);
        }

    iConversationCache->NotifyL(clientConv, KConversationListEventNew);
    // send the new conversation event as well, so that if there are nay listeners for the cv
    // then they will get the notification.
    iConversationCache->NotifyL(clientConv, KConversationEventNew);
    CleanupStack::PopAndDestroy(clientConv);

    CleanupStack::Pop(conversation);

    PRINT ( _L("CCsConversationCacheHelper::AddNewConversationL - Conversation Added") );
}

// ----------------------------------------------------------------------------
// CCsConversationCache::GetPendingEventCount
// Pending event count
// ----------------------------------------------------------------------------
TInt CCsConversationCacheHelper::GetPendingEventCount()
{
    return iConversationEventList->Count();
}

// ---------------------------------------------------------------------------
// Get next event from event list
// ---------------------------------------------------------------------------
//
CCsConversationEvent* CCsConversationCacheHelper::GetNextEvent()
{
    // check in case there are no events in cache
    if (iConversationEventList->Count() > 0)
    {
        return (*iConversationEventList)[0];
    }
    return NULL;
}

// ---------------------------------------------------------------------------
// Find CCsConversationEvent from event Q based on ConversationEntryId.
// ---------------------------------------------------------------------------
TInt CCsConversationCacheHelper::FindEvent(
                                           const CCsConversationEvent& aConvEvent)
{
    // find the event inside event list and send the index
    // KErrNotFound in  case None
    TInt
            index =
                    iConversationEventList->Find(&aConvEvent,
                                                 CCsConversationEvent::CompareByEntryId);

    return index;
}

// ----------------------------------------------------------------------------
// CCsConversationCache::GetNextRowId
// Get the conversation list count where to add next conversation
// ----------------------------------------------------------------------------
TInt16 CCsConversationCacheHelper::GetNextRowId()
{
    // increment the index and return
    iConversationIndex++;
    return iConversationIndex;
}

// ---------------------------------------------------------------------------
// Find CCsConversationEvent based on ConversationEntryId and delete it.
// ---------------------------------------------------------------------------
//
void CCsConversationCacheHelper::DeleteEvent(
                                             const CCsConversationEvent& aConvEvent)
{
    TInt index = FindEvent(aConvEvent);

    if (KErrNotFound != index)
    {
        CCsConversationEvent* conversationEvent =
                (*iConversationEventList)[index];
        iConversationEventList->Remove(index);
        delete conversationEvent;
    }
}

// ----------------------------------------------------------------------------
// CCsConversationCache::IsNotifyRequiredL
// checks whether notification for conversation list is required
// ----------------------------------------------------------------------------
TBool CCsConversationCacheHelper::IsNotifyRequiredL(
                                                    CCsConversation* aConversation,
                                                    CCsConversationEntry* aConversationEntry,
                                                    TUint32 aEvent,
                                                    TUint16 aPreviousUnreadMsgsCount)
{
    TUint16 presentUnreadMessageCount = aConversation->GetUnreadMessageCount();
    CCsConversationEntry* latestEntry = aConversation->GetLatestEntryL();

    // Add & Update
    if (aEvent & KConversationListEventNew || aEvent
            & KConversationListEventUpdate)
    {
        // Check whether deleted is ongoing. Don't Notify.
        if (aConversation->IsDeleted())
        {
            return EFalse;
        }

        // Check whether latest entry is same and unread count has not changed. Don't Notify.
        if (CCsConversationEntry::Compare(*latestEntry, *aConversationEntry)
                == 0 && (presentUnreadMessageCount == aPreviousUnreadMsgsCount)
                && (latestEntry->GetSendState()
                        == aConversationEntry->GetSendState()))
        {
            return EFalse;
        }
    }

    // Delete
    if (aEvent & KConversationListEventDelete)
    {
        // Not Last entry during delete. Don't Notify.
        if (aConversation->IsDeleted() && aConversation->GetEntryCount() > 0)
        {
            return EFalse;
        }
    }

    // Notify.
    return ETrue;
}

// ----------------------------------------------------------------------------
// CCsConversationCacheHelper::ConversationEventList
// Pls refer to .h file
// ----------------------------------------------------------------------------
RPointerArray<CCsConversationEvent>*
CCsConversationCacheHelper::ConversationEventList()
{
    return iConversationEventList;
}

//end of file
