/*

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

#include "HgScrollBufferManager.h"

#include "trace.h"

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

// HgScrollBufferManager::HgScrollBufferManager()

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

//

HgScrollBufferManager::HgScrollBufferManager(

        int bufferSize,

        int bufferTreshold,

        int initialPosition,

        int totalCount )

:   mBufferSize( bufferSize ),

    mBufferTreshold( bufferTreshold ),

    mBufferPosition( initialPosition ),

    mDiff(0),

    mTotalCount( totalCount ),

    mResetOrdered(false),

    mRequestStart(0),

    mRequestCount(0),

    mReleaseStart(0),

    mReleaseCount(0)

    {

    init();

    }

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

// HgScrollBufferManager::init()

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

//

void HgScrollBufferManager::init()

    {

    mResetOrdered = ETrue;

    mTimer.setSingleShot(true);

    connect(&mTimer, SIGNAL(timeout()), this, SLOT(timeout()));

    }

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

// HgScrollBufferManager::~HgScrollBufferManager()

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

//

HgScrollBufferManager::~HgScrollBufferManager()

    {

    mTimer.stop();

    }

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

// HgScrollBufferManager::resetBuffer()

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

//

void HgScrollBufferManager::resetBuffer( int aPosition, int totalCount )

    {

    if( !mResetOrdered )

        {

        // release Old buffer

        mReleaseStart = mBufferPosition;

        mReleaseCount = mBufferSize;

        }

    // set position and count

    mBufferPosition = aPosition - (mBufferSize / 2);

    mTotalCount = totalCount;

    mDiff = 0;

    if( mBufferPosition + mBufferSize > mTotalCount - 1 )

        {

        mBufferPosition = mTotalCount - mBufferSize;

        }

    if(mBufferPosition < 0 )

        {

        mBufferPosition = 0;

        }

    //request new Buffer

    mRequestStart = mBufferPosition;

    mRequestCount = mBufferSize;

    mResetOrdered = ETrue;

    asyncUpdate();

    }

void HgScrollBufferManager::scrollPositionChanged( int newPosition )

    {

    // If all the items fit in the buffer no need to move the buffer.

    if( mTotalCount <= mBufferSize ) return;

    bool forceUpdate = EFalse;

    newPosition -= mBufferSize / 2; // normalize index to Buffer start

    if(newPosition < 0)

        {

        newPosition = 0;

        forceUpdate = ETrue;

        }

    else if( newPosition > mTotalCount - mBufferSize )

        {

        newPosition = mTotalCount - mBufferSize;

        forceUpdate = ETrue;

        }

    mDiff = mBufferPosition - newPosition;

    // Too large change reset whole buffer

    if( mDiff >= mBufferSize || -mDiff >= mBufferSize || mResetOrdered )

        {

        resetBuffer(newPosition + (mBufferSize/2), mTotalCount );

        }

    // Move Up

    else if( mDiff >= mBufferTreshold )

        {

        mRequestCount = mDiff;

        mReleaseCount = mDiff;

        asyncUpdate();

        }

    // Move Down

    else if( -mDiff >= mBufferTreshold )

        {

        mRequestCount = -mDiff;

        mReleaseCount = -mDiff;

        asyncUpdate();

        }

    // Top or bottom has been reached

    else if( forceUpdate && mDiff )

        {

        int diff = mDiff < 0 ? -mDiff : mDiff;

        mRequestCount = diff;

        mReleaseCount = diff;

        asyncUpdate();

        }

    }

void HgScrollBufferManager::timeout()

{

    if(mResetOrdered)

        {

        mResetOrdered = EFalse;

        }

    else

        {

        if(mDiff < 0)

            {

            mReleaseStart = mBufferPosition;

            mRequestStart = mBufferPosition + mBufferSize;

            }

        else if( mDiff > 0)

            {

            mReleaseStart = mBufferPosition + mBufferSize - mDiff;

            mRequestStart = mBufferPosition - mDiff;

            }

        }

    // Release

    int end = mReleaseStart + mReleaseCount < mTotalCount ?

        mReleaseStart + mReleaseCount: mTotalCount;

    end--;

    if(end >= mReleaseStart )

        {

        emit releaseItems( mReleaseStart, end );

        }

    mReleaseCount = 0;

    // Request

    end = mRequestStart + mRequestCount < mTotalCount ?

        mRequestStart + mRequestCount : mTotalCount;

    end--;

    if(end >= mRequestStart )

        {

        emit requestItems( mRequestStart, end );

        }

    mRequestCount = 0;

    // Move Buffer

    mBufferPosition -= mDiff;

    // Reset Diff

    mDiff = 0;

}

bool HgScrollBufferManager::positionInsideBuffer( int position )

{

    return position >= mBufferPosition && position <= (mBufferPosition+mBufferSize);

}

void HgScrollBufferManager::asyncUpdate()

{

    if( !mTimer.isActive())

        mTimer.start(0);

}

void HgScrollBufferManager::currentBuffer(int& bufferStart, int& bufferEnd)

{

    bufferStart = mBufferPosition;

    bufferEnd = mBufferPosition+mBufferSize > mTotalCount-1 ?

        mTotalCount-1 : mBufferPosition+mBufferSize;

}

void HgScrollBufferManager::removeItems(int start, int end, int totalCount)

{

    int oldTotalCount = mTotalCount;

    mTotalCount = totalCount;

    if (isInsideBuffer(start, end)) {

        if (mTotalCount > mBufferSize && mBufferPosition+mBufferSize == oldTotalCount) {

            // We are at the end of items, move buffer

            int oldBufferPos = mBufferPosition;

            mBufferPosition = qMax(0, totalCount-mBufferSize);

            if (start < oldBufferPos) { // Removed items are partially inside buffer

                emit requestItems(mBufferPosition, start-1);

            }

            else {

                emit requestItems(mBufferPosition, oldBufferPos-1);

            }

        }

        else {

            int first = qBound(mBufferPosition, start, mBufferPosition+mBufferSize-1);

            int last = qBound(mBufferPosition, end, mBufferPosition+mBufferSize-1);

            // Requested from the end

            emit requestItems(mBufferPosition+mBufferSize-(last-first+1),

                              qMin(mBufferPosition+mBufferSize-1, mTotalCount));

        }

    }

}

void HgScrollBufferManager::addItems(int start, int end, int totalCount)

{

    int oldTotalCount = mTotalCount;

    mTotalCount = totalCount;

    if (isInsideBuffer(start, end)) {

        int first = start;

        int last = end;

        if (mTotalCount > mBufferSize && mBufferPosition+mBufferSize == oldTotalCount) {

            // We are at the end of items, keep it that way

            int oldBufferPos = mBufferPosition;

            mBufferPosition = qMin(mBufferPosition+(end-start+1), totalCount-mBufferSize);

            if (oldBufferPos < mBufferPosition) {

                // Release from the beginning

                emit releaseItems(oldBufferPos, mBufferPosition-1);

            }

            // Added items may fall outside the buffer as the buffer is moved

            if (isInsideBuffer(start, end)) {

                first = qBound(mBufferPosition, start, mBufferPosition+mBufferSize-1);

                last = qBound(mBufferPosition, end, mBufferPosition+mBufferSize-1);

                emit requestItems(first, last);

            }

        }

        else {

            first = qBound(mBufferPosition, start, mBufferPosition+mBufferSize-1);

            last = qBound(mBufferPosition, end, mBufferPosition+mBufferSize-1);

            if (mTotalCount > mBufferSize) {

                // Release from the end

                emit releaseItems(mBufferPosition+mBufferSize,

                                  mBufferPosition+mBufferSize+(last-first+1)-1);

            }

            // If all the items fit in the buffer no need to release items

            emit requestItems(first, last);

        }

    }

}

void HgScrollBufferManager::moveItems(int start, int end, int target, int totalCount)

{

    if (isInsideBuffer(start) && isInsideBuffer(end) && isInsideBuffer(target)) {

        return;

    }

    if (!isInsideBuffer(start, end) && !isInsideBuffer(target)) {

        return;

    }

    if (!isInsideBuffer(target)) {

        if (isInsideBuffer(start) && isInsideBuffer(end)) {

            if (mBufferPosition+mBufferSize == mTotalCount) {

                // Fetch from beginning

                emit requestItems(mBufferPosition, mBufferPosition+end-start);

            }

            else {

                // Fetch from end

                emit requestItems(mBufferPosition+mBufferSize-(end-start+1),

                                  qMin(mBufferPosition+mBufferSize-1, mTotalCount));

            }

        }

        else if (isInsideBuffer(start) && end >= mBufferPosition+mBufferSize-1) {

            emit requestItems(start, mBufferPosition+mBufferSize-1);

        }

        else if (start <= mBufferPosition && isInsideBuffer(end)) {

            emit requestItems(mBufferPosition, end);

        }

        else {

            emit requestItems(mBufferPosition, mBufferPosition+mBufferSize-1);

        }

    }

    if (isInsideBuffer(target)) {

        // start-end may be partially inside buffer

        if (!isInsideBuffer(start, end)) {

            addItems(target, target+end-start, totalCount);

        }

        else if (isInsideBuffer(start)) {

            addItems(target+(mBufferPosition+mBufferSize-start), target+end-start, totalCount);

        }

        else { // end is inside buffer

            addItems(target, target+mBufferPosition-start-1, totalCount);

        }

    }

}

bool HgScrollBufferManager::isInsideBuffer(int pos)

{

    return (pos >= mBufferPosition && pos < mBufferPosition+mBufferSize);

}

bool HgScrollBufferManager::isInsideBuffer(int start, int end)

{

    INFO("Buffer:" << mBufferPosition << "-" << mBufferPosition+mBufferSize-1);

    INFO("Change:" << start << "-" << end);

    if (isInsideBuffer(start)) {

        return true;

    }

    if (isInsideBuffer(end)) {

        return true;

    }

    if (start < mBufferPosition && end >= mBufferPosition+mBufferSize) {

        return true;

    }

    INFO("Buffer not affected");

    return false;

}