#include "PageView.h"

PageView::PageView(QString path, int pageIndex, QWidget *sizeTarget)
    :mPath{path}, mCurrentPage{pageIndex}
{
    mSizeTarget = sizeTarget;


    mTimer = new QTimer();
    connect(mTimer, SIGNAL(timeout()),
            this, SLOT(on_time_out()));
    connect(this, SIGNAL(load_finished(int, MediaRecord *)),
            this, SLOT(on_load_finished(int, MediaRecord *)));

    initData();
    initUI();

    mLastSize = mSizeTarget->size();
    resizeAllMedium(Vertical);

    on_time_out();
    mLabels->at(mCurrentPage)->show();
}

PageView::~PageView(){

    if (mZipReader != nullptr)
        delete mZipReader;

    if (mTimer != nullptr)
        mTimer->deleteLater();

    if (mThread != nullptr){
        if (mThread->isRunning()){
            mThread->quit();
            mThread->wait();
        }
        mThread->deleteLater();
    }

    if (mReaders != nullptr){
        while (!mReaders->isEmpty())
            delete mReaders->dequeue();
        delete mReaders;
    }

    if (mLabels != nullptr){
        while (!mLabels->isEmpty()){
            PageLabel *label = mLabels->dequeue();
            if (label->movie() != nullptr)
                delete label->movie();
            label->clear();
            label->deleteLater();
        }
        delete mLabels;
    }



    if (mMedia != nullptr){
        while (!mMedia->isEmpty()){
            MediaRecord *record = mMedia->dequeue();
            delete record->movieData;
            delete record->pixmap;
            delete record;
        }
        delete mMedia;
    }
}

void PageView::initData(){
    mReaders = new QQueue<QImageReader *>();
    mMedia = new QQueue<MediaRecord *>();
    mLabels = new QQueue<PageLabel *>();

    if (ArkUtility::isCompressed(QFileInfo{mPath}.fileName())){
        mZipReader = new QZipReader(mPath);

        foreach(QZipReader::FileInfo item, mZipReader->fileInfoList()){
            if (item.isFile){
                if (item.filePath.endsWith("jpg", Qt::CaseInsensitive) ||
                    item.filePath.endsWith("png", Qt::CaseInsensitive) ||
                    item.filePath.endsWith("gif", Qt::CaseInsensitive) ||
                    item.filePath.endsWith("bmp", Qt::CaseInsensitive)){

                    mReaders->enqueue(new QImageReader{item.filePath});
                    mMedia->enqueue(new MediaRecord());
                }
            }
        }
    }
    else{
        QFileInfoList fileInfoList = QDir{mPath}.entryInfoList(
                    QStringList()<< "*.jpg" << "*.png" << "*.gif" << "*.bmp",
                    QDir::Files|QDir::NoDotAndDotDot, QDir::Name|QDir::IgnoreCase);

        foreach(QFileInfo item, fileInfoList){
            mReaders->enqueue(new QImageReader(item.absoluteFilePath()));
            mMedia->enqueue(new MediaRecord());
        }
    }

}

void PageView::initUI(){

    createLabels();

    mMultiLayout = createMultiLayout();
    mMultiArea = getScrollArea(mMultiLayout);
    mVScrollBar = mMultiArea->verticalScrollBar();
    mHScrollBar = mMultiArea->horizontalScrollBar();

    connect(mVScrollBar, SIGNAL(valueChanged(int)),
             this, SLOT(on_scroll_changed(int)));

    mMainLayout = new QGridLayout();
    mMainLayout->addWidget(mMultiArea, 0, 0);
    mMainLayout->setMargin(0);

    setLayout(mMainLayout);
}

QScrollArea* PageView::getScrollArea(QGridLayout *layout){
    QGridLayout *arealayout = new QGridLayout();
    arealayout->addLayout(layout,0,0);

    QWidget *widget = new QWidget(this);
    widget->setLayout(arealayout);

    QScrollArea *area = new QScrollArea(this);
    area->setHorizontalScrollBarPolicy( Qt::ScrollBarAsNeeded );
    area->setVerticalScrollBarPolicy( Qt::ScrollBarAsNeeded );
    area->setWidgetResizable(true);
    area->setWidget(widget);

    return area;
}

void PageView::createLabels(){
    for (int i = 0; i < mReaders->size(); i++ ) {
        PageLabel *label = new PageLabel(QString::number(i+1));
        label->hide();
        label->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        label->setScaledContents(true);
        connect(label, SIGNAL(page_clicked(Qt::MouseButton)),
                this, SLOT(on_page_clicked(Qt::MouseButton)));
        mLabels->enqueue(label);
    }
}


QGridLayout* PageView::createMultiLayout(){

    QGridLayout *multiLayout = new QGridLayout();
 //   QVBoxLayout *v = new QVBoxLayout();

    for (int i = 0; i < mLabels->size(); i++ )
        multiLayout->addWidget(mLabels->at(i), i, 0, Qt::AlignHCenter|Qt::AlignBaseline);
//        v->addWidget(mLabels->at(i), 0, Qt::AlignHCenter);
//multiLayout->addLayout(v,0,0,Qt::AlignCenter);
    qDebug() << "================================spacing: "  << multiLayout->count();

    multiLayout->setSpacing(5);
    return multiLayout;
}

void PageView::on_scroll_changed(int value){
    if (mIsClickMode){
//        qDebug()<< mCurrentPage<<  " mCurrentPage: " << mLabels->at(mCurrentPage)->size();
//        qDebug()<< mCurrentPage << ", mSizeTarget:  " << mSizeTarget->size() - QSize{50,60};
//        qDebug() << "" ;
        return;
    }



    int spacing = 5;
    int total = 0 + spacing;

    for (int i = 0; i < mLabels->size(); i++){
        total += mLabels->at(i)->size().height() + spacing;
        mCurrentPage = i;
        if (total - mLabels->at(i)->size().height() / 2  > value)
            break;
    }
//    qDebug()<< mCurrentPage<<  " mCurrentPage: " << mLabels->at(mCurrentPage)->size();
//    qDebug()<< mCurrentPage << ", mSizeTarget:  " << mSizeTarget->size() - QSize{50,60};
//    qDebug() << "" ;


    mTimer->stop();
    mTimer->start(200);
}

void PageView::on_time_out(){
    mTimer->stop();

    if (mThread != nullptr ){
        mThread->quit();
        mThread->wait();
        mThread->deleteLater();
    }

    mThread = QThread::create([=]{
        int size = mLabels->size();
        int buffCount = 3;

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

            if (mLabels->at(i)->visibleRegion().isEmpty())
                continue;

            MediaRecord *theMedia = mMedia->at(i);
            if (theMedia->movieData->isNull() && theMedia->pixmap->isNull())
                emit load_finished(i, loadPixmap(i));
        }

        for (int i = 1; i < size; i++){

            if (mLabels->at(i)->visibleRegion().isEmpty())
                continue;
            else {
                for (int j = i-buffCount; j <= i; j++){
                    if (j < 0)
                        continue;

                    MediaRecord *theMedia = mMedia->at(j);
                    if (theMedia->movieData->isNull() && theMedia->pixmap->isNull())
                        emit load_finished(j, loadPixmap(j));
                }
                break;
            }
        }
        for (int i = size - 2; i > 0; i--){

            if (mLabels->at(i)->visibleRegion().isEmpty())
                continue;
            else {
                for (int j = i+buffCount; j >= i; j--){
                    if (j > size - 1)
                        continue;

                    MediaRecord *theMedia = mMedia->at(j);
                    if (theMedia->movieData->isNull() && theMedia->pixmap->isNull())
                        emit load_finished(j, loadPixmap(j));
                }
                break;
            }
        }

        MediaRecord *theMedia = mMedia->at(mCurrentPage);
        if (theMedia->movieData->isNull() && theMedia->pixmap->isNull())
            emit load_finished(mCurrentPage, loadPixmap(mCurrentPage));
    });
    mThread->start();
}

MediaRecord* PageView::loadPixmap(int index){

    QString path{mReaders->at(index)->fileName()};


    MediaRecord *record = new MediaRecord;

    if (path.endsWith(".gif", Qt::CaseInsensitive)){

        if (mZipReader != nullptr){
            record->movieData->append(mZipReader->fileData(path));
            return record;
        }
        else {
            QFile *movieFile = new QFile(path);
            if (movieFile->open(QIODevice::ReadOnly))
                record->movieData->append(movieFile->readAll());
            return record;
        }
    }

    QImage image;

    bool isSuccessed;

    isSuccessed = (mZipReader != nullptr) ?
                image.loadFromData(mZipReader->fileData(path)):
                image.load(path);

    if (!isSuccessed)
        return record;

    QPixmap pixmap = QPixmap::fromImage(image);



    record->pixmap->swap(pixmap);

    return record;
}

void PageView::on_load_finished(int index, MediaRecord *record){

    MediaRecord *theMediam = mMedia->at(index);
    PageLabel *theLabel = mLabels->at(index);

    //theLabel->setText("");

    if (!record->pixmap->isNull()){
       theMediam->pixmap->swap(*record->pixmap);
       theLabel->setPixmap(*theMediam->pixmap);
    }
    else if (!record->movieData->isNull()){

       theMediam->movieData->append(*record->movieData);

       QBuffer *buffer = new QBuffer(theMediam->movieData);

       if (buffer->open(QIODevice::ReadOnly)){
           QMovie *movie = new QMovie{buffer, "GIF"};
           movie->setCacheMode(QMovie::CacheAll);
           movie->setScaledSize(QSize{QImageReader{buffer, "GIF"}.size()});
           movie->start();
           theLabel->setMovie(movie);
       }
    }
    resizeAfterLoad(index);

    delete record;
}

void PageView::on_page_clicked(Qt::MouseButton button){


    qDebug() << "sizeHint " <<mLabels->at(mCurrentPage)->sizeHint();
    qDebug() << "minimumSizeHint " <<mLabels->at(mCurrentPage)->minimumSizeHint();
    qDebug() << "maximumSize " <<mLabels->at(mCurrentPage)->maximumSize();

    qDebug() << "size " <<mLabels->at(mCurrentPage)->size();
    qDebug() << "" <<mLabels->at(mCurrentPage)->pixmap()->size();

    qDebug() << "max" << mVScrollBar->maximum() ;



    if (!mIsClickMode)
        return;

    switch (button) {
    case Qt::LeftButton:
    case Qt::ForwardButton:
        if (mCurrentPage >= mLabels->size() -1)
            return;
        mLabels->at(mCurrentPage)->hide();
        mCurrentPage++;
        mLabels->at(mCurrentPage)->show();

        break;
    case Qt::RightButton:
    case Qt::BackButton:
        if (mCurrentPage <= 0)
            return;
        mLabels->at(mCurrentPage)->hide();
        mCurrentPage--;
        mLabels->at(mCurrentPage)->show();
        break;
    default:
        break;
    }
    on_time_out();


    moveToCurrentPage();

}

QSize PageView::getNewSize(QSize oldSize, ScaleMode mode){

      QSize targetSize = mLastSize - QSize{50,60};
      int newWidth;
      int newHeight;

      switch (mode) {
      case Vertical:
          newWidth = static_cast<int>(
                      static_cast<double>(targetSize.height()) *
                      static_cast<double>(oldSize.width()) /
                      static_cast<double>(oldSize.height())
                      );
          newHeight = targetSize.height();
          break;
      case Horizontal:
          newWidth = targetSize.width();
          newHeight = static_cast<int>(
                      static_cast<double>(targetSize.width()) *
                      static_cast<double>(oldSize.height()) /
                      static_cast<double>(oldSize.width())
                      );
          break;
      default:
          newWidth = targetSize.width();
          newHeight = targetSize.height();
          break;
      }
      return QSize{newWidth, newHeight};
}


void PageView::resizeMedium(int index, QSize newSize){
    PageLabel *theLabel = mLabels->at(index);
    MediaRecord *theMediam = mMedia->at(index);


//    if (index < 15){
//    qDebug() << index << " lab bf" << theLabel->size();
//    qDebug() << "sizeHint: " << theLabel->sizeHint();
//    qDebug() << "minimumSizeHint: " << theLabel->minimumSizeHint();
//    }
    theLabel->setFixedSize(newSize);


    if (!theMediam->pixmap->isNull()){
        QPixmap newPix = theMediam->pixmap->scaled(
                    newSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
        theLabel->setPixmap(newPix);
    } else if (!theMediam->movieData->isNull()){
        theLabel->movie()->setScaledSize(newSize);
        theLabel->movie()->start();
    }
    mHScrollBar->setValue(mHScrollBar->maximum() / 2);
}

void PageView::resizeAfterLoad(int index){


    QSize newSize = getNewSize(getOriginSize(index), (mIsVertical)?
                                   Vertical:
                                   Horizontal);
    resizeMedium(index, newSize);
}

void PageView::resizeAllMedium(ScaleMode mode){

    for (int i = 0; i < mLabels->size(); i++){
        QSize oldSize = getOriginSize(i);
        QSize newSize = getNewSize(oldSize, mode);
        resizeMedium(i, newSize);

    }
    moveToCurrentPage();
    qDebug() << "count: " << mMultiLayout->count() ;

}


QSize PageView::getOriginSize(int index){
    QSize size = mReaders->at(index)->size();

    if (size.isValid())
        return size;

    MediaRecord *theMedia = mMedia->at(index);
    if (!theMedia->pixmap->isNull())
        return theMedia->pixmap->size();

    PageLabel *theLabel = mLabels->at(index);
    if (!theMedia->movieData->isNull())
        return theLabel->movie()->scaledSize();

    return theLabel->size();

}

void PageView::moveToCurrentPage(){

    if (mIsClickMode)
        return;;

    int spacing = 5;
    int moveTo = spacing;
    int max = spacing;

    for (int i = 0; i < mLabels->size(); i++ ){
        max += mLabels->at(i)->size().height() + spacing;
        if (i < mCurrentPage)
            moveTo += mLabels->at(i)->size().height() + spacing;
    }

    mVScrollBar->setMaximum(max);
    mVScrollBar->setValue(moveTo);
}


void PageView::enlarge(){
    qDebug() << "PageView enlarge" ;
}
void PageView::shrink(){
    qDebug() << "PageView shrink" ;
}

void PageView::vertical(){
    mIsVertical = true;
    mLastSize = mSizeTarget->size();
    resizeAllMedium(Vertical);
}

void PageView::horizontal(){
    mIsVertical = false;
    mLastSize = mSizeTarget->size();
    resizeAllMedium(Horizontal);
}

bool PageView::switchMode(){

    mIsClickMode = !mIsClickMode;


    if (mIsClickMode){
        for (int i=0; i < mLabels->size(); i++)
            mLabels->at(i)->hide();
        mLabels->at(mCurrentPage)->show();
    }else
        for (int i=0; i < mLabels->size(); i++)
            mLabels->at(i)->show();


    moveToCurrentPage();

    return mIsClickMode;
}