/*
* Copyright (c) 2009-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:  Still image saving thread
*
*/

#include <QPixmap>
#include <QByteArray>
#include <QCoreApplication>
#include <QMutexLocker>

#include "cxestillimage.h"
#include "cxeimagedataitem.h"
#include "cxeimagedataitemsymbian.h"
#include "cxeharvestercontrolsymbian.h"
#include "cxethumbnailmanagersymbian.h"
#include "cxefilesavethreadsymbian.h"
#include "cxutils.h" // debug

namespace
{
    static const int SLEEP_MS_FOR_SIGNALS = 100;
    // Id for "Captured" album
    static const quint32 MDS_CAPTURED_ALBUM_ID = 2;
}


/**
* Implement factory method for CxeFileSaveThreadFactory.
*/
CxeFileSaveThread *CxeFileSaveThreadFactory::createFileSaveThread(QObject *parent)
{
    return new CxeFileSaveThreadSymbian(parent);
}


/*!
    \class CxeFileSaveThreadSymbian
    \brief Still image saving thread
*/


// ======== MEMBER FUNCTIONS ========

CxeFileSaveThreadSymbian::CxeFileSaveThreadSymbian( QObject *parent )
    : CxeFileSaveThread(parent),
      mExitThread(false),
      mSnapshots(),
      mExit(false),
      mThumbnailManager(NULL),
      mHarvesterControl(NULL)
{
    start(IdlePriority);
}

CxeFileSaveThreadSymbian::~CxeFileSaveThreadSymbian()
{
    CX_DEBUG_ENTER_FUNCTION();
    mMutex.lock();
    mExitThread = true;
    mDataToSave.wakeOne();
    mMutex.unlock();

    wait(); // until the thread has finished execution.
    qDeleteAll(mQueue);  // Ensure destruction
    mQueue.clear();

    mSnapshots.clear();

    delete mThumbnailManager;
    delete mHarvesterControl;

    CX_DEBUG_EXIT_FUNCTION();
}

void CxeFileSaveThreadSymbian::save(CxeImageDataItem *data)
{
    CX_DEBUG_ENTER_FUNCTION();

    // Ensure safe data adding.
    // Saving thread will wait if needed, in read method, until mutex is unlocked
    mMutex.lock();
    mQueue.enqueue(data);
    // Wake up saving thread if it's sleeping
    mDataToSave.wakeOne();
    mMutex.unlock();

    CX_DEBUG_EXIT_FUNCTION();
}

void CxeFileSaveThreadSymbian::read()
{
    mMutex.lock();
    mCount = mQueue.count();
    mExit = mExitThread;
    mMutex.unlock();
}

void CxeFileSaveThreadSymbian::run()
{
    CX_DEBUG_ENTER_FUNCTION();

    // Init Thumbnail Manager and Harvester Control.
    init();
    mActiveHarvests = 0;

    // Check if there is data to save.
    // There should not be any, because the thread is just contructed
    read();

    while (!mExit || mCount > 0) { // Complete save before exit
        CX_DEBUG(("CxeFileSaveThreadSymbian: mCount %d", mCount));
        // Wait data
        if (!mExit && mCount == 0) {
            // If there isn't any data to save, put the thread sleeping
            mMutex.lock();
            if(mActiveHarvests > 0) {
                // If we have active harvest requests, continue after a while to check if
                // there are signals waiting.
                CX_DEBUG(("CxeFileSaveThreadSymbian: %d harvesting requests active..", mActiveHarvests));
                mDataToSave.wait(&mMutex, SLEEP_MS_FOR_SIGNALS); // waiting "wakeOne"
                QCoreApplication::processEvents();
            } else {
                // If no active requests, and no data,
                // halt this thread until something to
                // save is available.
                CX_DEBUG(("CxeFileSaveThreadSymbian: set thread sleeping"));
                mDataToSave.wait(&mMutex); // waiting "wakeOne"
            }
            mMutex.unlock();
            CX_DEBUG(("CxeFileSaveThreadSymbian: woken up"));

        }

        // There should be data now, because the thread is woken up
        read();

        if (mCount > 0) {
            // Save one item now.
            saveNow();
        }

        // If we did start harvesting, check if there's signal waiting
        // for harvesting completed already.
        if(mActiveHarvests > 0) {
            msleep(SLEEP_MS_FOR_SIGNALS);
            QCoreApplication::processEvents();
        }

        // Saving takes some seconds, there might be new data available.
        read();
    }

    // Cleanup in the same thread as init() was done.
    deinit();

    CX_DEBUG_EXIT_FUNCTION();
}

/**
* Slot for saved video signal.
*/
void CxeFileSaveThreadSymbian::handleVideoSaved(CxeError::Id status, const QString& filename) {
    CX_DEBUG_ENTER_FUNCTION();
    CX_DEBUG(("[INFO] current thread 0x%x", QThread::currentThreadId()));
    CX_DEBUG(("status = %d filename = %s", status, filename.toAscii().constData()));

    if (status == CxeError::None) {
        // Use a dummy "image data item" with empty data and saved state for videos.
        // We just need to harvest the file and provide snapshot to Thumbnail Manager.
        QByteArray empty;
        CxeImageDataItem* item = new CxeImageDataItemSymbian(empty, filename, CxeStillImage::INVALID_ID, CxeImageDataItem::Saved);
        if(item) {
            save(item);
        }
    }
    CX_DEBUG_EXIT_FUNCTION();
}

void CxeFileSaveThreadSymbian::handleSnapshotReady(CxeError::Id status, const QPixmap& snapshot, const QString& filename)
{
    CX_DEBUG_ENTER_FUNCTION();
    CX_DEBUG(("[INFO] current thread 0x%x", QThread::currentThreadId()));
    CX_DEBUG(("status = %d filename = %s", status, filename.toAscii().constData()));

    if (status == CxeError::None) {
        // Store snapshot.
        if (!snapshot.isNull()) {
            // QMutexLocker handles locking and unlocking automaticly.
            QMutexLocker lock(&mSnapshotsMutex);

            //!@todo: Store as QImage once TNM API is fixed.
            mSnapshots.insert(filename, snapshot);
        }
    }

    CX_DEBUG_EXIT_FUNCTION();
}

void CxeFileSaveThreadSymbian::handleSnapshotReady(CxeError::Id status, const QPixmap& snapshot, int id)
{
    CX_DEBUG_ENTER_FUNCTION();
    CX_DEBUG(("[INFO] current thread 0x%x", QThread::currentThreadId()));
    CX_DEBUG(("status = %d id = %d", status, id));
    // Using id number as "filename" for images as filename is not available
    // at the time of snapshot for still images (and preparing the filename
    // would be slowing down showing the snapshot).
    handleSnapshotReady(status, snapshot, QString::number(id));
    CX_DEBUG_EXIT_FUNCTION();
}

/**
* Slot to handle harvested file.
* @param status Status of the harvesting.
* @param filename Path of the file just harvested.
*/
void CxeFileSaveThreadSymbian::handleFileHarvested(CxeError::Id status, const QString& filename)
{
    CX_DEBUG_ENTER_FUNCTION();
    CX_DEBUG(("[INFO] current thread 0x%x", QThread::currentThreadId()));
    CX_DEBUG(("status = %d filename = %s", status, filename.toAscii().constData()));

    // Synchronize snapshots container access.
    QMutexLocker lock(&mSnapshotsMutex);

    // Decrease count to enable sleeping in main loop
    // if nothing to save is available.
    --mActiveHarvests;

    if (status == KErrNone && mThumbnailManager) {
        if (mSnapshots.contains(filename)) {
            // File has been successfully harvested,
            // let's provide the snapshot to Thumbnail Manager.
            mThumbnailManager->createThumbnail(filename, mSnapshots[filename]);
        }
    }

    // Releasing the snapshot if it exists.
    mSnapshots.remove(filename);

    CX_DEBUG_EXIT_FUNCTION();
}

/**
* Init the utility classes.
*/
void CxeFileSaveThreadSymbian::init()
{
    // Create the thumbnail manager and harvester control objects in the new thread.
    if (!mThumbnailManager) {
        mThumbnailManager = new CxeThumbnailManagerSymbian();
    }
    if (!mHarvesterControl) {
        mHarvesterControl = new CxeHarvesterControlSymbian();
        connect(mHarvesterControl, SIGNAL(fileHarvested(CxeError::Id, const QString&)),
                this, SLOT(handleFileHarvested(CxeError::Id, const QString&)),
                Qt::DirectConnection);
    }
}

/**
* Clean up the utility classes
*/
void CxeFileSaveThreadSymbian::deinit()
{
    // Delete in the same thread where created.
    CX_DEBUG(("CxeFileSaveThreadSymbian: delete Thumbnail Manager"));
    delete mThumbnailManager;
    mThumbnailManager = NULL;
    CX_DEBUG(("CxeFileSaveThreadSymbian: delete Harvester Control"));
    delete mHarvesterControl;
    mHarvesterControl = NULL;
}



/**
* Save the item now.
*/
void CxeFileSaveThreadSymbian::saveNow()
{
    CX_DEBUG_ENTER_FUNCTION();
    CX_DEBUG(("[INFO] current thread 0x%x", QThread::currentThreadId()));

    CxeImageDataItem* item(mQueue.dequeue());
    if (item ) {
        // If item needs to be saved, do it now.
        if( item->state() == CxeImageDataItem::SavePending) {
            // Save the item.
            // Error ignored since we'll check the state.
            item->save();
        }

        CX_DEBUG(("Item state after saving: %d", item->state()));
        // If item is saved ok, ask to harvest it now.
        if (item->state() == CxeImageDataItem::Saved) {

            QString path(item->path());

            if (item->id() != CxeStillImage::INVALID_ID) {
                // Synchronize snapshots container access.
                QMutexLocker lock(&mSnapshotsMutex);

                // If snapshot was stored using id as a "filename", replace key with real filename now,
                // so we can find the snapshot when harvesting is ready.
                QString idString(QString::number(item->id()));
                if (mSnapshots.contains(idString)) {
                    const QPixmap& snapshot(mSnapshots[idString]);
                    mSnapshots.remove(idString);
                    mSnapshots.insert(path, snapshot);
                }
            }

            harvestFile(path);
        }

        // Delete item, since we own it
        delete item;
        item = NULL;
    }

    CX_DEBUG_EXIT_FUNCTION();
}

/**
* Harvest one file.
* @param filename Path of the file to be harvested.
*/
void CxeFileSaveThreadSymbian::harvestFile(const QString& filename)
{
    CX_DEBUG_ENTER_FUNCTION();
    if (mHarvesterControl) {
        // Synchronize snapshots container access.
        QMutexLocker lock(&mSnapshotsMutex);

        // harvest file ( filename, add to album, album id )
        CX_DEBUG(("Requesting harvesting for file: %s", filename.toAscii().constData()));
        CxeError::Id status = mHarvesterControl->harvestFile(filename, false, MDS_CAPTURED_ALBUM_ID);
        CX_DEBUG(("Status for starting harvesting: %d", status));

        // If there were errors, release any snapshot stored for this file.
        // Otherwise waiting for the harvesting to complete to
        // provide the snapshot to Thumbnail Manager.
        if(status != CxeError::None) {
            mSnapshots.remove(filename);
        } else {
            // Update count to process events in main loop.
            ++mActiveHarvests;
        }
    }
    CX_DEBUG_EXIT_FUNCTION();
}