#include "imageringlist.h"
#include <QThreadPool>
#include <QDir>

using namespace std;

const int DEFAULT_WIDTH = 3;

class LoadRunable : public QRunnable
{
    QString m_file;
    QObject *m_receiver;
public:
    LoadRunable(const QString &file, QObject *receiver) :
        m_file(file),
        m_receiver(receiver)
    {
    }
    void run()
    {
        QImage img(m_file);
        QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(QImage, img));
    }
};

Image::Image(const QString name) :
    m_loading(false),
    m_released(true),
    m_name(name)
{
}

void Image::load()
{
    if(m_pixmap.isNull() && !m_loading)
    {
        m_loading = true;
        m_released = false;
        QThreadPool::globalInstance()->start(new LoadRunable(m_name, this));
    }
    if(!m_loading && !m_pixmap.isNull())
        emit pixmapLoaded(this);
}

void Image::release()
{
    m_pixmap = QPixmap();
    m_released = true;
}

QString Image::name() const
{
    return m_name;
}

QPixmap Image::pixmap() const
{
    return m_pixmap;
}

void Image::imageLoaded(QImage img)
{
    m_loading = false;
    if(!m_released)
    {
        m_pixmap = QPixmap::fromImage(img);
        emit pixmapLoaded(this);
    }
}

ImageRingList::ImageRingList(QObject *parent) : QObject(parent)
{
}

bool ImageRingList::setDir(const QString path)
{
    QDir dir(path);

    if(dir.exists())
    {
        QStringList nameFilter;
        nameFilter << "*.jpg" << "*.png";

        QStringList list = dir.entryList(nameFilter, QDir::Files | QDir::Readable, QDir::Name);
        QStringList absolutePaths;
        foreach(const QString &file, list)
        {
            absolutePaths.append(dir.absoluteFilePath(file));
        }
        setFiles(absolutePaths);
        return true;
    }
    return false;
}

void ImageRingList::setFiles(const QStringList files)
{
    m_images.clear();
    foreach(const QString &file, files)
    {
        ImagePtr ptr = make_shared<Image>(file);
        connect(ptr.get(), SIGNAL(pixmapLoaded(Image*)), this, SLOT(imageLoaded(Image*)));
        m_images.append(ptr);
    }

    m_firstImage = m_currImage = m_lastImage = m_images.begin();
    (*m_currImage)->load();

    m_width = DEFAULT_WIDTH<m_images.size()/2 ? DEFAULT_WIDTH : m_images.size()/2;

    for(int i=0; i<m_width; i++)
    {
        m_firstImage = decrement(m_firstImage);
        (*m_firstImage)->load();
        m_lastImage = increment(m_lastImage);
        (*m_lastImage)->load();
    }
}

void ImageRingList::increment()
{
    if(m_images.size())
    {
        (*m_firstImage)->release();
        m_firstImage = increment(m_firstImage);
        m_currImage = increment(m_currImage);
        (*m_currImage)->load();
        m_lastImage = increment(m_lastImage);
        (*m_lastImage)->load();
    }
}

void ImageRingList::decrement()
{
    if(m_images.size())
    {
        (*m_lastImage)->release();
        m_firstImage = decrement(m_firstImage);
        m_currImage = decrement(m_currImage);
        (*m_currImage)->load();
        m_lastImage = decrement(m_lastImage);
        (*m_firstImage)->load();
    }
}

QList<shared_ptr<Image>>::iterator ImageRingList::increment(QList<ImagePtr>::iterator iter)
{
    iter++;
    if(iter == m_images.end())
        iter = m_images.begin();
    return iter;
}

QList<shared_ptr<Image>>::iterator ImageRingList::decrement(QList<ImagePtr>::iterator iter)
{
    if(iter == m_images.begin())
        iter = m_images.end();
    iter--;
    return iter;
}

void ImageRingList::imageLoaded(Image *image)
{
    if(image->name() == (*m_currImage)->name())
    {
        emit pixmapLoaded(image->pixmap());
    }
}