/*
 *  Copyright (c) 2019 Dmitry Kazakov <dimula73@gmail.com>
 *
 *  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; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "KisSafeNodeProjectionStore.h"

#include <QCoreApplication>
#include <QVector>
#include <KoColorSpace.h>

#include "kis_image.h"
#include "kis_paint_device.h"
#include "kis_selection.h"
#include "KisRecycleProjectionsJob.h"

/**********************************************************************/
/*     StoreImplementaionInterface                                    */
/**********************************************************************/

struct StoreImplementaionInterface
{
    virtual ~StoreImplementaionInterface() {}
    virtual StoreImplementaionInterface* clone() const = 0;
    virtual bool releaseDevice() = 0;
    virtual void discardCaches() = 0;
    virtual void recycleProjectionsInSafety() = 0;
};


/**********************************************************************/
/*     StoreImplementaion                                             */
/**********************************************************************/

template <typename DeviceSP>
struct StoreImplementation : public StoreImplementaionInterface
{
    bool releaseDevice() override {
        bool hasDeletedProjection = false;

        if (m_projection) {
            m_dirtyProjections.append(m_projection);
            m_projection = 0;
            hasDeletedProjection = true;

//            qDebug() << "release a device";
        }
        return hasDeletedProjection;
    }

    virtual void discardCaches() override {
//        qDebug() << "discard caches";
        m_dirtyProjections.clear();
    }

    virtual void recycleProjectionsInSafety() override {
//        qDebug() << "recycle caches";
        Q_FOREACH (DeviceSP projection, m_dirtyProjections) {
            projection->clear();
            m_cleanProjections.append(projection);
        }
        m_dirtyProjections.clear();
    }

protected:
    DeviceSP m_projection;
    QVector<DeviceSP> m_dirtyProjections;
    QVector<DeviceSP> m_cleanProjections;
};


/**********************************************************************/
/*     StoreImplementaionForDevice                                    */
/**********************************************************************/

struct StoreImplementationForDevice : StoreImplementation<KisPaintDeviceSP>
{
    StoreImplementationForDevice() {}
    StoreImplementationForDevice(const KisPaintDevice &prototype) {
        m_projection = new KisPaintDevice(prototype);
    }

    StoreImplementaionInterface* clone() const override {
        return m_projection ?
            new StoreImplementationForDevice(*m_projection) :
            new StoreImplementationForDevice();
    }

    KisPaintDeviceSP getDeviceLazy(KisPaintDeviceSP prototype) {
        if(!m_projection ||
           *m_projection->colorSpace() != *prototype->colorSpace()) {

            if (!m_cleanProjections.isEmpty()) {
                m_projection = m_cleanProjections.takeLast();
                m_projection->makeCloneFromRough(prototype, prototype->extent());
            } else {
                m_projection = new KisPaintDevice(*prototype);
            }

            m_projection->setProjectionDevice(true);
        }
        return m_projection;
    }
};


/**********************************************************************/
/*     StoreImplementaionForSelection                                 */
/**********************************************************************/

struct StoreImplementationForSelection : StoreImplementation<KisSelectionSP>
{
    StoreImplementationForSelection() {}
    StoreImplementationForSelection(const KisSelection &prototype) {
        m_projection = new KisSelection(prototype);
    }

    StoreImplementaionInterface* clone() const override {
        return m_projection ?
            new StoreImplementationForSelection(*m_projection) :
            new StoreImplementationForSelection();
    }

    KisSelectionSP getDeviceLazy(KisSelectionSP prototype) {
        if(!m_projection) {
            if (!m_cleanProjections.isEmpty()) {
                m_projection = m_cleanProjections.takeLast();
                m_projection->pixelSelection()->makeCloneFromRough(prototype->pixelSelection(), prototype->selectedRect());
            } else {
                m_projection = new KisSelection(*prototype);
            }

            m_projection->pixelSelection()->setProjectionDevice(true);
        }
        return m_projection;
    }
};


/**********************************************************************/
/*     KisSafeNodeProjectionStoreBase                                 */
/**********************************************************************/

struct KisSafeNodeProjectionStoreBase::Private
{
    mutable QMutex lock;
    KisImageWSP image;
    QScopedPointer<StoreImplementaionInterface> store;
};

KisSafeNodeProjectionStoreBase::KisSafeNodeProjectionStoreBase(StoreImplementaionInterface *storeImpl)
    : m_d(new Private)
{
    m_d->store.reset(storeImpl);
    moveToThread(qApp->thread());
    connect(this, SIGNAL(internalInitiateProjectionsCleanup()), this, SLOT(slotInitiateProjectionsCleanup()));
}

KisSafeNodeProjectionStoreBase::KisSafeNodeProjectionStoreBase(const KisSafeNodeProjectionStoreBase &rhs)
    : QObject(),
      KisShared(),
      m_d(new Private)
{
    {
        QMutexLocker rhsLocker(&rhs.m_d->lock);

        m_d->image = rhs.m_d->image;
        m_d->store.reset(rhs.m_d->store->clone());
    }

    moveToThread(qApp->thread());
    connect(this, SIGNAL(internalInitiateProjectionsCleanup()), this, SLOT(slotInitiateProjectionsCleanup()));
}

KisSafeNodeProjectionStoreBase::~KisSafeNodeProjectionStoreBase()
{
}

void KisSafeNodeProjectionStoreBase::releaseDevice()
{
    QMutexLocker locker(&m_d->lock);
    if (m_d->store->releaseDevice()) {
        locker.unlock();
        emit internalInitiateProjectionsCleanup();
    }
}

void KisSafeNodeProjectionStoreBase::setImage(KisImageWSP image)
{
    m_d->image = image;
}

void KisSafeNodeProjectionStoreBase::slotInitiateProjectionsCleanup()
{
    /**
     * After the projection has been used, we should clean it. But we cannot
     * clean it until all the workers accessing it have completed their job.
     *
     * Therefore we just schedule an exclusive job that will execute the
     * recycling action in an exclusive context, when no jobs are running.
     */

    KisImageSP image = m_d->image;

    if (image) {
        image->addSpontaneousJob(new KisRecycleProjectionsJob(this));
    } else {
        discardCaches();
    }
}

void KisSafeNodeProjectionStoreBase::discardCaches()
{
    QMutexLocker locker(&m_d->lock);
    m_d->store->discardCaches();
}

void KisSafeNodeProjectionStoreBase::recycleProjectionsInSafety()
{
    QMutexLocker locker(&m_d->lock);
    m_d->store->recycleProjectionsInSafety();
}


/**********************************************************************/
/*     KisSafeNodeProjectionStore                                     */
/**********************************************************************/

KisSafeNodeProjectionStore::KisSafeNodeProjectionStore()
    : KisSafeNodeProjectionStoreBase(new StoreImplementationForDevice)
{
}

KisSafeNodeProjectionStore::KisSafeNodeProjectionStore(const KisSafeNodeProjectionStore &rhs)
    : KisSafeNodeProjectionStoreBase(rhs)
{
}

KisPaintDeviceSP KisSafeNodeProjectionStore::getDeviceLazy(KisPaintDeviceSP prototype)
{
    QMutexLocker locker(&m_d->lock);
    StoreImplementationForDevice *store = dynamic_cast<StoreImplementationForDevice*>(m_d->store.data());
    KIS_ASSERT(store);

    return store->getDeviceLazy(prototype);
}


/**********************************************************************/
/*     KisSafeSelectionNodeProjectionStore                            */
/**********************************************************************/

KisSafeSelectionNodeProjectionStore::KisSafeSelectionNodeProjectionStore()
    : KisSafeNodeProjectionStoreBase(new StoreImplementationForSelection)
{
}

KisSafeSelectionNodeProjectionStore::KisSafeSelectionNodeProjectionStore(const KisSafeSelectionNodeProjectionStore &rhs)
    : KisSafeNodeProjectionStoreBase(rhs)
{
}

KisSelectionSP KisSafeSelectionNodeProjectionStore::getDeviceLazy(KisSelectionSP prototype)
{
    QMutexLocker locker(&m_d->lock);
    StoreImplementationForSelection *store = dynamic_cast<StoreImplementationForSelection*>(m_d->store.data());
    KIS_ASSERT(store);

    return store->getDeviceLazy(prototype);
}

