#include "dialog_exportimagefile.h"
#include "ui_dialog_exportimagefile.h"
#include "mainwindow.h"
#include "imgfmt/HGImgFmt.h"
#include "HGUIGlobal.h"
#include "HGString.h"
#include <QMessageBox>

Dialog_ExportImageFile::Dialog_ExportImageFile(const QString &destPath, const QString &destName, const QString &destExt,
    bool isSaveAsMulti, int jpegQuality, int tiffCompressionBW, int tiffCompression, int tiffQuality, bool isOcr,
    const QStringList &srcFiles, QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::Dialog_ExportImageFile)
    , m_destPath(destPath)
    , m_destName(destName)
    , m_destExt(destExt)
    , m_isSaveAsMulti(isSaveAsMulti)
    , m_jpegQuality(jpegQuality)
    , m_tiffCompressionBW(tiffCompressionBW)
    , m_tiffCompression(tiffCompression)
    , m_tiffQuality(tiffQuality)
    , m_isOcr(isOcr)
    , m_srcFiles(srcFiles)
{
    ui->setupUi(this);

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(srcFiles.size());
    ui->progressBar->setValue(0);

    connect(this, SIGNAL(updateProgress(int)), this, SLOT(on_updateProgress(int)), Qt::QueuedConnection);
    connect(this, SIGNAL(finish()), this, SLOT(on_finish()), Qt::QueuedConnection);

    m_stopThread = false;
    HGBase_OpenThread(ThreadFunc, this, &m_thread);
}

Dialog_ExportImageFile::~Dialog_ExportImageFile()
{
    if (nullptr != m_thread)
    {
        HGBase_CloseThread(m_thread);
        m_thread = nullptr;
    }

    delete ui;
}

void Dialog_ExportImageFile::ThreadFunc(HGThread thread, HGPointer param)
{
    (void)thread;
    Dialog_ExportImageFile *p = (Dialog_ExportImageFile *)param;

    if (p->m_isSaveAsMulti)
    {
        QString fileName = p->m_destPath + p->m_destName + p->m_destExt;

        HGImgFmtWriter imgFmtWriter = nullptr;
        HGImgFmt_OpenImageWriter(getStdString(fileName).c_str(), 0, &imgFmtWriter);
        if (nullptr != imgFmtWriter)
        {
            for (int i = 0; i < p->m_srcFiles.size(); ++i)
            {
                if (p->m_stopThread)
                {
                    break;
                }

                emit p->updateProgress(i);

                HGImgFmtReader imgFmtReader = nullptr;
                HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
                if (nullptr != imgFmtReader)
                {
                    HGUInt count = 0;
                    HGImgFmt_GetImagePageCount(imgFmtReader, &count);
                    for (HGUInt j = 0; j < count; ++j)
                    {
                        if (p->m_stopThread)
                        {
                            break;
                        }

                        HGImage img = nullptr;
                        HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
                        if (nullptr != img)
                        {
                            HGImgFmtSaveInfo saveInfo;
                            saveInfo.jpegQuality = (HGUInt)p->m_jpegQuality;
                            saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
                            saveInfo.tiffJpegQuality = (HGUInt)p->m_tiffQuality;

                            HGImageInfo imgInfo;
                            HGBase_GetImageInfo(img, &imgInfo);
                            if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
                            {
                                if (1 == p->m_tiffCompressionBW)
                                    saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                                else if (2 == p->m_tiffCompressionBW)
                                    saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_CCITTFAX4;
                            }
                            else
                            {
                                if (1 == p->m_tiffCompression)
                                    saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                                else if (2 == p->m_tiffCompression)
                                    saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_JPEG;
                            }

                            HGImgFmt_SaveImageToWriter(imgFmtWriter, img, &saveInfo);
                            HGBase_DestroyImage(img);
                        }
                    }

                    HGImgFmt_CloseImageReader(imgFmtReader);
                }
            }

            HGImgFmt_CloseImageWriter(imgFmtWriter);
        }
    }
    else
    {
        int index = 1;

        for (int i = 0; i < p->m_srcFiles.size(); ++i)
        {
            if (p->m_stopThread)
            {
                break;
            }

            emit p->updateProgress(i);

            HGImgFmtReader imgFmtReader = nullptr;
            HGImgFmt_OpenImageReader(getStdString(p->m_srcFiles[i]).c_str(), 0, &imgFmtReader);
            if (nullptr != imgFmtReader)
            {
                HGUInt count = 0;
                HGImgFmt_GetImagePageCount(imgFmtReader, &count);
                for (HGUInt j = 0; j < count; ++j)
                {
                    if (p->m_stopThread)
                    {
                        break;
                    }

                    HGImage img = nullptr;
                    HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
                    if (nullptr != img)
                    {
                        char fileName[512];
                        if(p->m_srcFiles.size() > 1)
                        {
                            sprintf(fileName, "%s%03d", getStdString(p->m_destName).c_str(), index);
                        }else
                            sprintf(fileName, "%s", getStdString(p->m_destName).c_str());

                        ++index;

                        QString saveFileName = p->m_destPath + QString(StdStringToUtf8(fileName).c_str()) + p->m_destExt;

                        HGImgFmtSaveInfo saveInfo;
                        saveInfo.jpegQuality = (HGUInt)p->m_jpegQuality;
                        saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
                        saveInfo.tiffJpegQuality = (HGUInt)p->m_tiffQuality;

                        HGImageInfo imgInfo;
                        HGBase_GetImageInfo(img, &imgInfo);
                        if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
                        {
                            if (1 == p->m_tiffCompressionBW)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                            else if (2 == p->m_tiffCompressionBW)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_CCITTFAX4;
                        }
                        else
                        {
                            if (1 == p->m_tiffCompression)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
                            else if (2 == p->m_tiffCompression)
                                saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_JPEG;
                        }

                        MainWindow::saveImage(img, &saveInfo, p->m_isOcr, getStdString(saveFileName).c_str());
                        HGBase_DestroyImage(img);
                    }
                }

                HGImgFmt_CloseImageReader(imgFmtReader);
            }
        }
    }

    emit p->finish();
}

void Dialog_ExportImageFile::on_updateProgress(int value)
{
    ui->progressBar->setValue(value);
}

void Dialog_ExportImageFile::on_finish()
{
    QMessageBox msg(QMessageBox::Information, tr("tip"), tr("export succeed"), QMessageBox::Ok, this);
    msg.setButtonText(QMessageBox::Ok, tr("ok"));
    close();
    msg.exec();
}

void Dialog_ExportImageFile::on_pushButton_clicked()
{
    m_stopThread = true;
    HGBase_CloseThread(m_thread);
    m_thread = nullptr;
}

void Dialog_ExportImageFile::closeEvent(QCloseEvent *e)
{
    (void)e;
    m_stopThread = true;
    HGBase_CloseThread(m_thread);
    m_thread = nullptr;
}