#include "dialog_exportimagefile.h"
#include "ui_dialog_exportimagefile.h"
#include "mainwindow.h"
#include "base/HGInfo.h"
#include "base/HGUtility.h"
#include "imgfmt/HGImgFmt.h"
#include "imgfmt/HGGif.h"
#include "imgproc/HGOCR.h"
#include "HGUIGlobal.h"
#include "HGString.h"
#include <QMessageBox>
#include <QFile>
#include "app_cfg.h"

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);
    setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);

    int totalCount = 0;
    for (int i = 0; i < m_srcFiles.size(); ++i)
    {
        HGImgFmtReader imgFmtReader = nullptr;
        HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
        if (NULL != imgFmtReader)
        {
            HGUInt count = 0;
            HGImgFmt_GetImagePageCount(imgFmtReader, &count);
            totalCount += count;
            HGImgFmt_CloseImageReader(imgFmtReader);
        }
    }

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(totalCount);
    ui->progressBar->setValue(0);

    connect(this, SIGNAL(updateProgress(int)), this, SLOT(on_updateProgress(int)), Qt::QueuedConnection);
    connect(this, SIGNAL(finish(int)), this, SLOT(on_finish(int)), 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 HGAPI Dialog_ExportImageFile::ThreadFunc(HGThread thread, HGPointer param)
{
    (void)thread;
    Dialog_ExportImageFile *p = (Dialog_ExportImageFile *)param;

    HGResult ret = HGBASE_ERR_FAIL;
    if (p->m_isSaveAsMulti)
    {
        if (p->m_isOcr)
        {
            ret = p->processMultiFileOcr();
        }
        else
        {
            if (p->m_destExt == ".gif")
            {
                ret = p->processMultiFileGif();
            }
            else
            {
                ret = p->processMultiFile();
            }
        }
    }
    else
    {
        ret = p->processSingleFile();
    }

    emit p->finish((int)ret);
}

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

void Dialog_ExportImageFile::on_finish(int ret)
{
    QString str = (ret == HGBASE_ERR_OK) ? tr("export succeed") : tr("export failed: ") + MainWindow::getLogInfo(ret);
    QMessageBox msg(QMessageBox::Information, tr("tip"), str, QMessageBox::Ok, this);
    close();
    msg.exec();
}

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

HGResult Dialog_ExportImageFile::processMultiFileOcr()
{
    int handleCount = 0;
    QString fileName = m_destPath + m_destName + m_destExt;

    HGOCRMgr ocrMgr = nullptr;
    HGResult ret = HGImgProc_CreateOCRMgr(HGIMGPROC_OCRALGO_HANVON, &ocrMgr);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

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

        HGImgFmtReader imgFmtReader = nullptr;
        ret = HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }

        HGUInt count = 0;
        HGImgFmt_GetImagePageCount(imgFmtReader, &count);
        for (HGUInt j = 0; j < count; ++j)
        {
            if (m_stopThread)
            {
                break;
            }

            emit updateProgress(handleCount);

            HGImage img = nullptr;
            ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
            if (HGBASE_ERR_OK != ret)
            {
                break;
            }

            ret = HGImgProc_AddToImageOCRList(ocrMgr, img);
            HGBase_DestroyImage(img);
            ++handleCount;
            emit updateProgress(handleCount);

            if (HGBASE_ERR_OK != ret)
            {
                break;
            }
        }

        HGImgFmt_CloseImageReader(imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }
    }

    if (HGBASE_ERR_OK == ret)
    {
        ret = HGImgProc_ImageListOCRToFile(ocrMgr, 0, getStdString(fileName).c_str(), NULL, NULL);
        if (HGBASE_ERR_OK != ret)
        {
            QFile::remove(fileName);
        }
    }

    HGImgProc_DestroyOCRMgr(ocrMgr);
    return ret;
}

HGResult Dialog_ExportImageFile::processMultiFileGif()
{
    HGUInt maxWidth = 0;
    HGUInt maxHeight = 0;
    for (int i = 0; i < m_srcFiles.size(); ++i)
    {
        HGImgFmtReader imgFmtReader = nullptr;
        HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
        if (nullptr != imgFmtReader)
        {
            HGUInt count = 0;
            HGImgFmt_GetImagePageCount(imgFmtReader, &count);
            for (HGUInt j = 0; j < count; ++j)
            {
                HGImgFmtLoadInfo info = {0};
                HGImgFmt_LoadImageFromReader(imgFmtReader, j, &info, 0, 0, NULL);
                if (info.width > maxWidth)
                    maxWidth = info.width;
                if (info.height > maxHeight)
                    maxHeight = info.height;
            }

            HGImgFmt_CloseImageReader(imgFmtReader);
        }
    }

    int handleCount = 0;
    QString fileName = m_destPath + m_destName + m_destExt;

    HGGifSaveInfo gifSaveInfo = {maxWidth, maxHeight};
    HGGifWriter gifWriter = NULL;
    HGResult ret = HGImgFmt_OpenGifWriter(getStdString(fileName).c_str(), &gifSaveInfo, &gifWriter);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    bool valid = false;
    for (int i = 0; i < m_srcFiles.size(); ++i)
    {
        if (m_stopThread)
        {
            break;
        }

        HGImgFmtReader imgFmtReader = nullptr;
        ret = HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }

        HGUInt count = 0;
        HGImgFmt_GetImagePageCount(imgFmtReader, &count);
        for (HGUInt j = 0; j < count; ++j)
        {
            if (m_stopThread)
            {
                break;
            }

            emit updateProgress(handleCount);

            HGImage img = nullptr;
            ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
            if (HGBASE_ERR_OK != ret)
            {
                break;
            }

            ret = HGImgFmt_SaveImageToGifWriter(gifWriter, 200, HG_MAKECOLOR(255, 255, 255, 255), img);
            HGBase_DestroyImage(img);
            ++handleCount;
            emit updateProgress(handleCount);

            if (HGBASE_ERR_OK != ret)
            {
                break;
            }

            valid = true;
        }

        HGImgFmt_CloseImageReader(imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }
    }

    HGImgFmt_CloseGifWriter(gifWriter);
    if (!valid)
    {
        QFile::remove(fileName);
    }

    return ret;
}

HGResult Dialog_ExportImageFile::processMultiFile()
{
    int handleCount = 0;
    QString fileName = m_destPath + m_destName + m_destExt;

    HGImgFmtWriter imgFmtWriter = nullptr;
    HGResult ret = HGImgFmt_OpenImageWriter(getStdString(fileName).c_str(), 0, &imgFmtWriter);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    bool valid = false;
    for (int i = 0; i < m_srcFiles.size(); ++i)
    {
        if (m_stopThread)
        {
            break;
        }

        HGImgFmtReader imgFmtReader = nullptr;
        ret = HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }

        HGUInt count = 0;
        HGImgFmt_GetImagePageCount(imgFmtReader, &count);
        for (HGUInt j = 0; j < count; ++j)
        {
            if (m_stopThread)
            {
                break;
            }

            emit updateProgress(handleCount);

            HGImage img = nullptr;
            ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
            if (HGBASE_ERR_OK != ret)
            {
                break;
            }

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

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

            ret = HGImgFmt_SaveImageToWriter(imgFmtWriter, img, &saveInfo);
            HGBase_DestroyImage(img);
            ++handleCount;
            emit updateProgress(handleCount);

            if (HGBASE_ERR_OK != ret)
            {
                break;
            }

            valid = true;
        }

        HGImgFmt_CloseImageReader(imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }
    }

    HGImgFmt_CloseImageWriter(imgFmtWriter);
    if (!valid)
    {
        QFile::remove(fileName);
    }

    return ret;
}

HGResult Dialog_ExportImageFile::processSingleFile()
{
    int handleCount = 0;
    HGResult ret = HGBASE_ERR_OK;

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

        HGImgFmtReader imgFmtReader = nullptr;
        ret = HGImgFmt_OpenImageReader(getStdString(m_srcFiles[i]).c_str(), 0, &imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }

        HGUInt count = 0;
        HGImgFmt_GetImagePageCount(imgFmtReader, &count);
        for (HGUInt j = 0; j < count; ++j)
        {
            if (m_stopThread)
            {
                break;
            }

            emit updateProgress(handleCount);

            HGImage img = nullptr;
            ret = HGImgFmt_LoadImageFromReader(imgFmtReader, j, nullptr, 0, HGBASE_IMGORIGIN_TOP, &img);
            if (HGBASE_ERR_OK != ret)
            {
                break;
            }

            QString fileName;
            if(m_srcFiles.size() > 1 || count > 1)
            {
                char str[256];
                sprintf(str, "%s%03d", getStdString(m_destName).c_str(), handleCount + 1);
                fileName = m_destPath + QString(StdStringToUtf8(str).c_str()) + m_destExt;
            }
            else
            {
                fileName = m_destPath + m_destName + m_destExt;
            }

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

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

            ret = MainWindow::saveImage(img, &saveInfo, m_isOcr, getStdString(fileName).c_str());
            HGBase_DestroyImage(img);
            ++handleCount;
            emit updateProgress(handleCount);

            if (HGBASE_ERR_OK != ret)
            {
                QFile::remove(fileName);
                break;
            }
        }

        HGImgFmt_CloseImageReader(imgFmtReader);
        if (HGBASE_ERR_OK != ret)
        {
            break;
        }
    }

    return ret;
}

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