/*
* Copyright (c) 2007-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:  Active Object Implementation for providing data asynchronously
*
*/


#include "mulasyncdataprovider.h"

#include <osn/osnnew.h>
#include <algorithm> //for find algorithm

#include "mullog.h"

namespace Alf
    {

// ---------------------------------------------------------------------------
// MulAsyncDataProvider
// ---------------------------------------------------------------------------
//
MulAsyncDataProvider::MulAsyncDataProvider( IMulModelProvider& aDataProvider,
                                            const MulPageDataWindow& aDataWindow )
                     :CActive( EPriorityNormal ),
                      mDataProvider(aDataProvider),
                      mDataWindow(aDataWindow)
    {
    MUL_LOG_ENTRY_EXIT("MUL::MulAsyncDataProvider::MulAsyncDataProvider");
    CActiveScheduler::Add(this);
    }

// ---------------------------------------------------------------------------
// ~MulAsyncDataProvider
// ---------------------------------------------------------------------------
//
MulAsyncDataProvider::~MulAsyncDataProvider()
    {
    MUL_LOG_ENTRY_EXIT("MUL::MulAsyncDataProvider::~MulAsyncDataProvider");  
    Cancel();
    mDataQueue.clear();
    }

// ---------------------------------------------------------------------------
// RunL
// ---------------------------------------------------------------------------
//
void MulAsyncDataProvider::RunL()
    {  
    vector<MulAsyncData>::iterator iter = mDataQueue.begin();
    if( iter < mDataQueue.end() )
        {
        bool inDataWindow = false;
        MulAsyncData asyncData = *iter;
        
        if(mDataWindow.IsItemInDataWindow(asyncData.mStartIndex) /*&& mDataWindow->IsItemInDataWindow(mStartIndex+ITEMS)*/)
            { 
            if( asyncData.mRange < mDataWindow.WindowSize() )
                {
                mDataProvider.ProvideData( asyncData.mStartIndex, asyncData.mRange, asyncData.mPath); 
                }
            else
                {
                mDataProvider.ProvideData( asyncData.mStartIndex, mDataWindow.WindowSize() , asyncData.mPath); 
                }
            inDataWindow = true;
            }
                  
        asyncData.mStartIndex += mDataWindow.WindowSize();
        asyncData.mRange -= mDataWindow.WindowSize();
        mDataQueue.erase(iter);
        
       if( asyncData.mRange > 0 && inDataWindow )
            {     
            mDataQueue.insert( iter, asyncData ); 
            if( !IsActive() )
                {
                ActivateAndComplete();
                }
            }
         else if(mDataQueue.begin() < mDataQueue.end())
            {  
            if( !IsActive() )
                {
                ActivateAndComplete();
                }
            }
        }     
    }

// ---------------------------------------------------------------------------
// DoCancel
// ---------------------------------------------------------------------------
//
void MulAsyncDataProvider::DoCancel()
    {
    //does this function required??
    }
//    
// ---------------------------------------------------------------------------
// ProvideData
// ---------------------------------------------------------------------------
//
void MulAsyncDataProvider::ProvideData( int aStartIndex, int aRange, const MulDataPath& aPath, const bool aIsSync )
    { 
    if( aIsSync )
        {
        mDataProvider.ProvideData( aStartIndex, aRange, aPath);
        return;
        }
    MulAsyncData asyncData;
    asyncData.mStartIndex = aStartIndex;
    asyncData.mRange = aRange;
    asyncData.mPath = aPath;
    if( std::find( mDataQueue.begin(), mDataQueue.end(), asyncData ) ==  mDataQueue.end())
        {
        mDataQueue.push_back( asyncData );
        }
                 
    for( int i = 0 ; i < mDataQueue.size() ; ++i )
        {
        MulAsyncData data = mDataQueue[i]; 
        if ( (mDataWindow.IsItemInDataWindow( data.mStartIndex ) &&
              !mDataWindow.IsItemInDataWindow( data.mStartIndex + data.mRange - 1 ) ) )
            {
            int index = GetFirstIndexForWhichDataIsPresent(data.mStartIndex , data.mStartIndex + data.mRange - 1 );
            if( index!= -1 &&( index - data.mStartIndex + 1) > 0)
                {
                mDataQueue.erase(mDataQueue.begin() + i);
                data.mRange = index - data.mStartIndex + 1;
                mDataQueue.insert(mDataQueue.begin() + i, data);
                }
            else
                {
                mDataQueue.erase(mDataQueue.begin() + i);
                i--;
                }    
            
            }
        else if ( (!mDataWindow.IsItemInDataWindow( data.mStartIndex ) &&
              mDataWindow.IsItemInDataWindow( data.mStartIndex + data.mRange - 1 ) ) )
            {
            int index = GetFirstIndexForWhichDataIsPresent(data.mStartIndex , data.mStartIndex + data.mRange - 1 );
            if( index!= -1 &&( data.mStartIndex + data.mRange - index ) > 0 )
                {
                mDataQueue.erase(mDataQueue.begin() + i);
                int endIndex = (data.mStartIndex + data.mRange - 1);
                data.mStartIndex = index;
                data.mRange = (endIndex - index + 1);
                mDataQueue.insert(mDataQueue.begin() + i, data);
                }
            else
                {
                mDataQueue.erase(mDataQueue.begin() + i);
                i--;
                }
            }
        else if ( (!mDataWindow.IsItemInDataWindow( data.mStartIndex ) &&
              !mDataWindow.IsItemInDataWindow( data.mStartIndex + data.mRange - 1 ) ) )
           {
           mDataQueue.erase(mDataQueue.begin() + i);
           i--;
           MUL_LOG_INFO2( "MUL::MulAsyncDataProvider::ProvideData Removing From Q: startIndx=%d,range=%d", data.mStartIndex, data.mRange ); 
           }
        }
    
    if( !IsActive() )
        { 
        ActivateAndComplete();
        }
    }
// ---------------------------------------------------------------------------
// GetFirstIndexForWhichDataIsPresent
// ---------------------------------------------------------------------------
//
int MulAsyncDataProvider::GetFirstIndexForWhichDataIsPresent(int aStartIndex, int aEndIndex)
    {
    if ( aStartIndex > aEndIndex )
        {
        return -1;
        }
    int mid = (aStartIndex + aEndIndex)/2;
    if(mDataWindow.IsItemInDataWindow(aStartIndex))
        {
        if(mid == aStartIndex)
            {
            return mid;
            }
        if(mDataWindow.IsItemInDataWindow(mid))
            {
            return GetFirstIndexForWhichDataIsPresent(mid, aEndIndex);
            }
        else
            {
            return GetFirstIndexForWhichDataIsPresent(aStartIndex, mid);
            }
        }
     else if(mDataWindow.IsItemInDataWindow(aEndIndex))
        {
        if(mid == aStartIndex)
            {
            return (mid + 1);
            }
        if(mDataWindow.IsItemInDataWindow(mid))
            {
            return GetFirstIndexForWhichDataIsPresent(aStartIndex, mid);
            }
        else
            {
            return GetFirstIndexForWhichDataIsPresent(mid, aEndIndex);
            }           
        }   
    return -1;
    }
  
// ---------------------------------------------------------------------------
// ActivateAndComplete
// ---------------------------------------------------------------------------
//
 void MulAsyncDataProvider::ActivateAndComplete()
    {
    TRequestStatus* lStatus = &iStatus;
    iStatus = KRequestPending;
    SetActive();
    User::RequestComplete(lStatus, KErrNone);
    }
 
    } // End of namespace Alf .


// End of file