/*

Pencil2D - Traditional Animation Software
Copyright (C) 2005-2007 Patrick Corrieri & Pascal Naidon
Copyright (C) 2012-2020 Matthew Chiawen Chang

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

*/

#include "activeframepool.h"
#include "keyframe.h"
#include "pencildef.h"


ActiveFramePool::ActiveFramePool()
{
    Q_ASSERT(mMemoryBudgetInBytes >= (1024 * 1024 * 100)); // at least 100MB
}

ActiveFramePool::~ActiveFramePool() {}

void ActiveFramePool::put(KeyFrame* key)
{
    if (key == nullptr)
        return;

    Q_ASSERT(key->pos() > 0);

    key->loadFile();

    auto it = mCacheFramesMap.find(key);
    const bool keyExistsInPool = (it != mCacheFramesMap.end());
    if (keyExistsInPool)
    {
        // move the keyframe to the front of the list, if the key already exists in frame pool
        mCacheFramesList.erase(it->second);
    }
    mCacheFramesList.push_front(key);
    mCacheFramesMap[key] = mCacheFramesList.begin();

    key->addEventListener(this);

    if (!keyExistsInPool)
    {
        mTotalUsedMemory += key->memoryUsage();
    }

    discardLeastUsedFrames();
}

void ActiveFramePool::clear()
{
    for (KeyFrame* key : mCacheFramesList)
    {
        key->removeEventListner(this);
    }
    mCacheFramesList.clear();
    mCacheFramesMap.clear();
}

void ActiveFramePool::resize(quint64 memoryBudget)
{
    memoryBudget = qMin(memoryBudget, quint64(1024) * 1024 * 1024 * 16); // 16GB
    memoryBudget = qMax(memoryBudget, quint64(1024) * 1024 * 100); // 100MB
    mMemoryBudgetInBytes = memoryBudget;
    discardLeastUsedFrames();
}

bool ActiveFramePool::isFrameInPool(KeyFrame* key)
{
    auto it = mCacheFramesMap.find(key);
    return (it != mCacheFramesMap.end());
}

void ActiveFramePool::setMinFrameCount(size_t frameCount)
{
    mMinFrameCount = frameCount;
}

void ActiveFramePool::onKeyFrameDestroy(KeyFrame* key)
{
    auto it = mCacheFramesMap.find(key);
    if (it != mCacheFramesMap.end())
    {
        mCacheFramesList.erase(it->second);
        mCacheFramesMap.erase(it);

        // Just recalculate the total usage
        // Not safe to call key->memoryUsage() here cuz it's in the KeyFrame's destructor
        recalcuateTotalUsedMemory();
    }
}

void ActiveFramePool::discardLeastUsedFrames()
{
    while ((mTotalUsedMemory > mMemoryBudgetInBytes) && (mCacheFramesList.size() > mMinFrameCount))
    {
        list_iterator_t last = mCacheFramesList.end();
        last--;

        KeyFrame* lastKeyFrame = *last;
        unloadFrame(lastKeyFrame);

        mCacheFramesMap.erase(lastKeyFrame);
        mCacheFramesList.pop_back();

        lastKeyFrame->removeEventListner(this);
    }
}

void ActiveFramePool::unloadFrame(KeyFrame* key)
{
    mTotalUsedMemory -= key->memoryUsage();
    key->unloadFile();
}

void ActiveFramePool::recalcuateTotalUsedMemory()
{
    mTotalUsedMemory = 0;
    for (KeyFrame* key : mCacheFramesList)
    {
        mTotalUsedMemory += key->memoryUsage();
    }
}
