/*

* 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),

    mFirstTime(true)

    {

    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()

{

    mFirstTime = false;

    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() && mFirstTime) {

        mTimer.start(0);

    } else if (!mTimer.isActive()){

        timeout();

    }

}

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

{

    bufferStart = mBufferPosition;

    bufferEnd = mBufferPosition+mBufferSize > mTotalCount-1 ?

        mTotalCount-1 : mBufferPosition+mBufferSize;

}

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

{

    FUNC_LOG;

    mTotalCount += (end-start+1);

    int lastBufferItem = mBufferPosition+mBufferSize-1;

    if (start < mBufferPosition) {

        simpleAddItems(start, end);

        // New items push the buffer forward, items inside the buffer do not change

    }

    // Check buffer higher limit

    else if (start <= lastBufferItem && end > lastBufferItem) {

        simpleAddItems(start, lastBufferItem);

        // Items added after the buffer are ignored

    }

    else {

        simpleAddItems(start, end);

    }

}

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

{

    FUNC_LOG;

    int lastBufferItem = mBufferPosition+mBufferSize-1;

    int removedItemCount = end-start+1;

    if (mTotalCount < mBufferSize) {

        // Do nothing

    }

    else if (start > lastBufferItem) {

        // Do nothing

    }

    else if (end < mBufferPosition) {

        mTotalCount = mTotalCount-removedItemCount;

        simpleRemoveItems(start, end);

    }

    else if (start < mBufferPosition && end > lastBufferItem) {

        mTotalCount = mTotalCount-removedItemCount;

        mBufferPosition = qBound(0, mBufferPosition, mTotalCount-mBufferSize);

        resetBuffer(mBufferPosition, mTotalCount);

    }

    // Check buffer higher limit

    else if (start <= lastBufferItem && end > lastBufferItem) {

        mTotalCount = mTotalCount-(end-lastBufferItem);

        simpleRemoveItems(lastBufferItem+1, end);

        mTotalCount = mTotalCount-(lastBufferItem-start+1);

        simpleRemoveItems(start, lastBufferItem);

        // Order does matter

        mTotalCount = mTotalCount-(end-lastBufferItem);

        simpleRemoveItems(lastBufferItem+1, end);

        mTotalCount = mTotalCount-(lastBufferItem-start+1);

        simpleRemoveItems(start, lastBufferItem);

    }

    // Check buffer lower limit

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

        // Order does matter

        mTotalCount = mTotalCount-(end-mBufferPosition+1);

        simpleRemoveItems(mBufferPosition, end);

        mTotalCount = mTotalCount-(mBufferPosition-start);

        simpleRemoveItems(start, mBufferPosition-1);

    }

    else {

        mTotalCount = mTotalCount-removedItemCount;

        simpleRemoveItems(start, end);

    }

}

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

{

    int lastBufferItem = mBufferPosition+mBufferSize-1;

    INFO("Move" << start << "-" << end << "to" << target << ",buffer:" << mBufferPosition << "-" << lastBufferItem << "total count:" << mTotalCount);

    if (mTotalCount < mBufferSize) {

        // Do nothing

    }

    else if (start < mBufferPosition && end > lastBufferItem) {

        resetBuffer(mBufferPosition, mTotalCount);

    }

    else if (start > lastBufferItem && target > lastBufferItem) {

        // Do nothing

    }

    else if (start > lastBufferItem && target < mBufferPosition) {

        simpleAddItems(start, end);

    }

    else if (end < mBufferPosition && target < mBufferPosition) {

        // Do nothing

    }

    else if (end < mBufferPosition && target > lastBufferItem) {

        simpleRemoveItems(start, end);

    }

    else if (start >= mBufferPosition && end <= lastBufferItem &&

             target >= mBufferPosition && target <= lastBufferItem) {

        // Do nothing

    }

    else {

        // Rare and complicated use cases: reset the whole buffer

        resetBuffer(mBufferPosition, mTotalCount);

    }

}

void HgScrollBufferManager::flushRequestBuffers()

{

    FUNC_LOG;

    qSort(mReleaseBuffer);

    int releaseCount = mReleaseBuffer.count();

    int lastReleased = -1;

    for (int i = 0; i < releaseCount; i++) {

        UpdatePair update = mReleaseBuffer.at(i);

        emit releaseItems(qMax(lastReleased+1, update.start()), update.end());

        lastReleased = update.end();

    }

    mReleaseBuffer.clear();

    qSort(mRequestBuffer);

    int requestCount = mRequestBuffer.count();

    int lastRequested = -1;

    for (int i = 0; i < requestCount; i++) {

        UpdatePair update = mRequestBuffer.at(i);

        emit requestItems(qMax(lastRequested+1, update.start()), update.end());

        lastRequested = update.end();

    }

    mRequestBuffer.clear();

}

int HgScrollBufferManager::changeBufferPosition(int newPos)

{

    FUNC_LOG;

    INFO("Change buffer position to" << newPos << "total count:" << mTotalCount);

    HANDLE_ERROR_BOOL((newPos >= 0));

    HANDLE_ERROR_BOOL((newPos+mBufferSize <= mTotalCount));

    int bufferShift = newPos-mBufferPosition;

    if (bufferShift > 0) {

        mRequestBuffer.shiftRight(mBufferPosition, bufferShift);

        mReleaseBuffer.shiftRight(mBufferPosition, bufferShift);

    }

    else if (bufferShift < 0) {

        mRequestBuffer.shiftLeft(mBufferPosition, -bufferShift);

        mReleaseBuffer.shiftLeft(mBufferPosition, -bufferShift);

    }

    mBufferPosition = newPos;

    return bufferShift;

}

/**

    This function manages only simple item additions: all items are either

    outside the buffer or inside it.

    Firs call prepare, then update model, then call fecth.

*/

void HgScrollBufferManager::simpleAddItems(int start, int end)

{

    FUNC_LOG;

    int lastBufferItem = mBufferPosition+mBufferSize-1;

    int numAddedItems = end-start+1; // [start, end] inclusive

    if (mTotalCount < mBufferSize) {

        appendRequestBuffer(start, numAddedItems);

    }

    else if (start > lastBufferItem) {

        // Do nothing

    }

    else if (start <= mBufferPosition) {

        changeBufferPosition(mBufferPosition+numAddedItems);

        // No need to fetch items, the indexes just change

    }

    else {

        // free from end

        appendReleaseBuffer(lastBufferItem+1-numAddedItems, numAddedItems);

        mReleaseBuffer.shiftRight(start, numAddedItems);

        mRequestBuffer.shiftRight(start, numAddedItems);

        appendRequestBuffer(start, numAddedItems);

    }

}

/**

    This function manages only simple item removals: all items are either

    outside the buffer or inside it.

    Firs call prepare, then update model, then call fecth.

*/

void HgScrollBufferManager::simpleRemoveItems(int start, int end)

{

    FUNC_LOG;

    int lastBufferItem = mBufferPosition+mBufferSize-1;

    int numRemovedItems = end-start+1; // [start, end] inclusive

    if (start > lastBufferItem) {

        // Do nothing

    }

    else if (end < mBufferPosition) {

        changeBufferPosition(qMax(0, mBufferPosition-numRemovedItems));

        // No need to fetch items, the indexes just change

    }

    else {

        if (mTotalCount < mBufferPosition+mBufferSize) {

            // Buffer is at the end of items

            int bufferShift = changeBufferPosition(qMax(0, mTotalCount-mBufferSize));

            // Fetch from beginning

            // Releasing removed items has been done outside this class

            appendRequestBuffer(mBufferPosition, qAbs(bufferShift));

        }

        else {

            // Fetch from end

            appendRequestBuffer(lastBufferItem+1-numRemovedItems, numRemovedItems);

        }

    }

}

void HgScrollBufferManager::appendRequestBuffer(int start, int count)

{

    FUNC_LOG;

    INFO("Request items" << start << ":" << count)

    mRequestBuffer.add(start, count);

    mReleaseBuffer.remove(start, count);

}

void HgScrollBufferManager::appendReleaseBuffer(int start, int count)

{

    FUNC_LOG;

    INFO("Release items" << start << ":" << count)

    mReleaseBuffer.add(start, count);

    mRequestBuffer.remove(start, count);

}

UpdatePair::UpdatePair(int start, int count) : mStart(start), mCount(count)

{

    HANDLE_ERROR_BOOL(mCount > 0);

}

int UpdatePair::start() const

{

    return mStart;

}

int UpdatePair::end() const

{

    return mStart+mCount-1;

}

bool UpdatePair::adjacent(int start, int count) const

{

    if (start+count < mStart) return false;

    if (start > mStart+mCount) return false;

    return true;

}

bool UpdatePair::contains(const UpdatePair &other) const

{

    if (other.mStart+other.mCount-1 < mStart) return false;

    if (other.mStart > mStart+mCount-1) return false;

    return true;

}

void UpdatePair::extend(int start, int count)

{

    int end = qMax(mStart+mCount, start+count);

    mStart = qMin(mStart, start);

    mCount = end-mStart;

    INFO("Pair extended to:" << mStart << ":" << mCount);

}

void UpdatePair::subtract(int start, int count)

{

    int end = qMin(mStart+mCount, start+count);

    mStart = qMax(mStart, start);

    mCount = end-mStart;

    INFO("Pair reduced to:" << mStart << ":" << mCount);

}

void UpdatePair::shiftRight(int count)

{

    mStart += count;

    INFO("Pair shifted to:" << mStart << ":" << mCount);

}

void UpdatePair::shiftLeft(int count)

{

    mStart -= count;

    HANDLE_ERROR_BOOL((mStart >= 0));

    INFO("Pair shifted to:" << mStart << ":" << mCount);

}

bool UpdatePair::operator== (const UpdatePair &other) const

{

    return mStart == other.mStart && mCount == other.mCount;

}

bool UpdatePair::operator< (const UpdatePair &other) const

{

    return (mStart < other.mStart || mStart == other.mStart && mCount < other.mCount);

}

UpdateBuffer::UpdateBuffer()

{

    FUNC_LOG;

}