/*
 * 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:  ?Description
 *
 */

#include "conversationchangehandler.h"
// SYSTEM INCLUDES
#include <ccsconversationentry.h>

// USER INCLUDES
#include "conversationsengine.h"
#include "conversationsengine_p.h"
#include "conversationsmodel.h"

const TInt WindowSize = 7;

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
ConversationsChangeHandler::ConversationsChangeHandler(
    ConversationsEnginePrivate* convEnginePrivate,
    ConversationsModel* conversationsModel) :
    CActive(EPriorityStandard), 
    mCurrentState(EInit),
    mFirstWindowCached(EFalse),
    mCurrentIndex(-1), 
    mConversationsModel(conversationsModel), 
    mConvEnginePrivate(convEnginePrivate)

{
    CActiveScheduler::Add(this);
}

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
ConversationsChangeHandler::~ConversationsChangeHandler()
{
    mConversationEntryList.ResetAndDestroy();
    // Cancel the active object
    Cancel();
}

// ---------------------------------------------------------------------------
// This is for handling GetConversation results asynchronusly
// from the server.
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::ConversationsL(RPointerArray<
        CCsConversationEntry>& aConversationEntryList, TInt& aTotalCount)
{
    
    mTotalCount = aTotalCount;

    for (TInt i = 0; i < aConversationEntryList.Count(); ++i)
    {
        CCsConversationEntry *entry = aConversationEntryList[i]->CloneL();
        mConversationEntryList.AppendL(entry);
    }
    if (aConversationEntryList.Count() > 0)
    {
        mCurrentState = EInitialCache;
        IssueRequest();
    }
    else
    {
        //This is done for safety
        mConvEnginePrivate->registerForConversationUpdatesL();
        mCurrentState = EListenToEvents;
    }
}
// ---------------------------------------------------------------------------
// This is for resetting the values before initiating a request 
// for fetching entries for a new conversation
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::ResetValuesForNewConversation()
{
	mConvEnginePrivate->registerForConversationUpdatesL();
    mCurrentIndex = 0;
    mFirstWindowCached = EFalse;
    mConversationEntryList.ResetAndDestroy();
    

}

// ---------------------------------------------------------------------------
// Handling addition of new conversation entry from the server
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::AddConversation(
    const CCsConversationEntry& aConvEntry)
{
    mConversationsModel->addRow(aConvEntry, true);
    ConversationsEngine::instance()->emitConversationModelUpdated();
}

// ---------------------------------------------------------------------------
// Handling modification of existing conversation entry from the server
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::ModifyConversation(
    const CCsConversationEntry& aConvEntry)
{
    mConversationsModel->addRow(aConvEntry, true);
}

// ---------------------------------------------------------------------------
// Handling deletion of conversation entry from the server
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::DeleteConversation(
    const CCsConversationEntry& aConvEntry)
{
    mConversationsModel->deleteRow(aConvEntry.EntryId());
    
    //check if the CV model row count has become zero
    // then needs to emit signal
    if (mConversationsModel->rowCount() == 0)
    {
        mConversationsModel->emitConversationViewEmpty();
    }
}

//-----------------------------------------------------------------------
// This is for handling modify conversation event asynchronusly from the server
//-----------------------------------------------------------------------
//
void ConversationsChangeHandler::RefreshConversation()
{
}

// ---------------------------------------------------------------------------
// RunL
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::RunL()
{
    if (iStatus != KErrNone)
    {
        return;
    }
    //process
    switch (mCurrentState)
    {
        case EInitialCache:
            HandleConversationsL();
            break;
        case EFetchMoreConversations:
            FetchRemainingConversations(mConversationEntryList.Count());
            break;
    }
}

// ---------------------------------------------------------------------------
// DoCancel
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::DoCancel()
{
    mCurrentState = EListenToEvents;
}

// ---------------------------------------------------------------------------
// Make the active object alive.
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::IssueRequest()
{
    if (!IsActive())
    {
        iStatus = KRequestPending;
        TRequestStatus* status = &iStatus;
        SetActive();
        User::RequestComplete(status, KErrNone);
    }
}

// ---------------------------------------------------------------------------
//  Handles Conversations received from server and updates into model
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::HandleConversationsL()
{
    for (int i = 0; i < WindowSize; ++i)
    {
        if (mCurrentIndex < mConversationEntryList.Count())
        {
            mConversationsModel->addRow(
                * (mConversationEntryList[mCurrentIndex]));
            mCurrentIndex++;
        }
        else
        {
            break;
        }
    }
    if (mCurrentIndex < mConversationEntryList.Count())
    {
        if (!mFirstWindowCached)
        {
            ConversationsEngine::instance()->emitConversationModelPopulated();
            mFirstWindowCached = ETrue;
            return;
        }
        IssueRequest();
        return;
    }
    //if more entries have to be fetched , issue a request,
    // else listen for events.
    if(mCurrentIndex < mTotalCount )
    {
        //fetch more
        mCurrentState = EFetchMoreConversations;
        IssueRequest();
    }
    else
    {
        if (!mFirstWindowCached)
        {
            ConversationsEngine::instance()->emitConversationModelPopulated();
            mFirstWindowCached = ETrue;
        }
        mConversationEntryList.ResetAndDestroy();
        mCurrentState = EListenToEvents;
    }
}

// ---------------------------------------------------------------------------
//  Fetches remaining conversations from the server 
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::FetchRemainingConversations(TInt aTotalCount)
{
    mConvEnginePrivate->fetchRemainingConversations(aTotalCount);
    
}
// ---------------------------------------------------------------------------
//  Starts fetching remaining conversations
// ---------------------------------------------------------------------------
//
void ConversationsChangeHandler::restartHandleConversations()
{
    IssueRequest();
}

//EOF