#include <jni.h>
#include <opencv2/opencv.hpp>
#include <string>
#include <iostream>
#include <vector>
#include "base64.h"
#include <string>
#include <stdlib.h>
#include <mutex>
#include <HG_SCANNER_API.h>
#include <map>
#ifdef _WIN32
#include <io.h>
#else
#include <sys/uio.h>
//#include <sys/io.h>
#endif // linux



#include "utlis.h"
#if defined(WIN32)||defined(_WIN32)
#include <Windows.h>
#else
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#endif // defined(WIN32)||defined(_WIN32)

static jobject mUserListener = nullptr;
static jobject mUserCallback = nullptr;
static JavaVM* g_vm = nullptr;
HG_Scanner_Handle mScanner = nullptr;
static jobject gClassLoader;
static jmethodID gFindClassMethod;
static jclass statusClazz;
int indeximg = 0;
static int indexPatch = 0;
#define EN_LOG

#ifdef EN_LOG
#define LOG printf
#else
#define LOG
#endif // EN_LOG

std::mutex m_mutex;

static HG_CACHEIMGFORMAT m_cacheimgformat = HG_CJPG;

static std::map< HG_CACHEIMGFORMAT, std::string> m_mapcaches = {
    {HG_CJPG,".jpg"},
    {HG_CPNG,".png"},
    {HG_CBMP,".bmp"},
    {HG_CTIFF,".tiff"}
};

int  writeimage(const char* filename, std::vector<unsigned char>& imagedata) {
    FILE* fp = NULL;
    if (NULL == imagedata.data() || imagedata.size() <= 0) return -1;
    fp = fopen(filename, "wb"); // 必须确保是以 二进制写入的形式打开

    if (NULL == fp)
        return (-1);

    fwrite(imagedata.data(), imagedata.size(), 1, fp); //二进制
    fclose(fp);
    fp = NULL;
    return 0;
}

void onReceivedImage(HG_IMG* img, void* obj) 
{
    std::lock_guard<std::mutex> lock(m_mutex);
    LOG("JAVA--- Enter  onReceivedImage  width:%d height:%d  bitdepth:%d  pdata:%p byteperlin:%d\n", img->width, img->height, img->bitdepth, img->pimgdata, img->bytesperline);
    if (mUserCallback) 
    {
        JNIEnv* env;
        jint ret = g_vm->GetEnv((void**)&env, JNI_VERSION_1_6);
        if (ret < 0) 
            g_vm->AttachCurrentThread((void**)&env, NULL);

        jclass clazz = env->GetObjectClass(mUserCallback);
        indeximg++;
        indexPatch++;
        cv::Mat matimg(img->height, img->width, img->bitdepth == 24 ? CV_8UC3 : CV_8UC1, img->pimgdata);
        std::string filename, path, str_encodeformat;
        std::vector<int> encodeparam;
        if (m_mapcaches.count(m_cacheimgformat) > 0)
        {
            str_encodeformat = m_mapcaches[m_cacheimgformat];
            switch (m_cacheimgformat)
            {
            case HG_CJPG:
                encodeparam.push_back(CV_IMWRITE_JPEG_QUALITY);
                encodeparam.push_back(70);
                break;
            case HG_CPNG:
                encodeparam.push_back(CV_IMWRITE_PNG_STRATEGY);
                encodeparam.push_back(cv::IMWRITE_PNG_STRATEGY_FIXED);
                break;
            default:
                break;
            }
        }
        else
            str_encodeformat = m_mapcaches[HG_CJPG];

        filename = std::to_string(indeximg) + str_encodeformat;
#if defined(WIN32) || defined(_WIN32)
        WCHAR outapth[MAX_PATH];
        auto length = GetTempPathW(MAX_PATH, outapth);
        if (length < 1)
        {
            LOG("JAVA--- error : on Get tmpPath! this would cause no image be saved\n ");
            path = "C:\\" + filename;//save in the system disk
        }
        else
        {
            path = WChar2Ansi(outapth);
            path += filename;
        }
#else
        std::string dstdirPath = "/tmp/huagowebserver";
        if (access(dstdirPath.c_str(), 0) == -1)//is not exist
        {
            int flag = mkdir(dstdirPath.c_str(), 0755);
            if (flag != 0)
            {
                std::cout << "make " << dstdirPath << " falied" << std::endl;
                dstdirPath = "/tmp";
            }
        }
        path = dstdirPath + "/" + filename;
#endif
        //std::vector<int> quality;
        //quality.push_back(CV_IMWRITE_JPEG_QUALITY);
        //quality.push_back(70);//进行50%的压缩
        std::vector<unsigned char> data;
        //cv::imencode(".jpg", matimg, data, quality);
        data.insert(data.end(), img->pimgdata, img->pimgdata + img->bufferlength);
        auto retw = writeimage(path.c_str(), data);
        if (retw == -1)
            LOG("JAVA--- LOST IMAGE %s \n", path.c_str());

        std::string datastr(data.begin(), data.end());
        if (!data.empty())
        {
            std::string base64data = base64_encode_mime(datastr);
            jmethodID id = env->GetMethodID(env->GetObjectClass(mUserCallback), "onImageReceived", "(ILjava/lang/String;Ljava/lang/String;)V");
            LOG("JAVA--- IMAGE PATH =%s \n", path.c_str());
            env->CallVoidMethod(mUserCallback, id, indexPatch, env->NewStringUTF(path.c_str()), env->NewStringUTF(base64data.c_str()));
        }
        else
            LOG("JAVA---  Get uncorrect data");

        if (ret < 0) 
            g_vm->DetachCurrentThread();
    }
    else
        LOG("JAVA--- mUserCallback is null\n");
}

//aaa
void onEvent(HG_STATUSCODE statuscode, void* obj) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (statuscode <= 0 || statuscode > 13)
        return;
    if (mUserListener) {
        JNIEnv* env;
        jint ret = g_vm->GetEnv((void**)&env, JNI_VERSION_1_6);
        if (ret < 0) 
            jint ret2 = g_vm->AttachCurrentThread((void**)&env, NULL);

        jclass listenerClazz = env->GetObjectClass(mUserListener);
        jmethodID methodEventId = env->GetMethodID(listenerClazz, "onEvent", "(I)V");
        env->CallVoidMethod(mUserListener, methodEventId, (jint)statuscode);
        if (ret < 0) 
            g_vm->DetachCurrentThread();
        LOG("JAVA--- Enter  onEvent callback 10  \n");
    }
    else
        LOG("JAVA--- mUserListener is null\n");
}

extern "C" JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM * vm, void* reserved) 
{
    JNIEnv* env;
    if (g_vm == nullptr) 
        g_vm = vm;

    if (g_vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) 
    {
        LOG("JAVA--- JNI_OnLoad error\n");
        return JNI_ERR;
    }

    LOG("JAVA--- JNI_OnLoad\n");
    return JNI_VERSION_1_6;
}

extern "C"
JNIEXPORT jobjectArray JNICALL
Java_com_huagao_scanner_DeviceManager_getDevices(JNIEnv * env, jobject thiz) 
{
    const char* sp = ";";
    char* cDevices = HG_GetDevices(const_cast<char*>(sp));
    if (cDevices == nullptr) 
    {
        LOG(" JAVA--- getDevices is fail\n");
        return NULL;
    }
    jstring devices = env->NewStringUTF(cDevices);
    jclass strClazz = env->FindClass("java/lang/String");
    jmethodID splitId = env->GetMethodID(strClazz, "split", "(Ljava/lang/String;)[Ljava/lang/String;");;
    return static_cast<jobjectArray>(env->CallObjectMethod(devices, splitId, env->NewStringUTF(";")));
}

extern "C" JNIEXPORT void JNICALL
Java_com_huagao_scanner_DeviceManager_init(JNIEnv * env, jobject thiz) 
{
    HG_Init();
    HG_Set_OnDeviceEvent_callback(onEvent);
    HG_Set_AquireImg_callback(onReceivedImage);
    LOG("JAVA--- DeviceManager_init\n");
}

extern "C"
JNIEXPORT void JNICALL
Java_com_huagao_scanner_DeviceManager_setEventListener(JNIEnv * env, jobject thiz, jobject listener) 
{
    if (mUserListener)
        env->DeleteGlobalRef(mUserListener);
    mUserListener = env->NewGlobalRef(listener);
}

extern "C"
JNIEXPORT jboolean JNICALL
Java_com_huagao_scanner_DeviceManager_open(JNIEnv * env, jobject thiz, jstring scanner_name) 
{
    if (mScanner) 
        return true;

    char* cName = const_cast<char*>(env->GetStringUTFChars(scanner_name, 0));
    LOG("JAVA--- open deivce name:%s \n", cName);
    mScanner = HG_OpenScanner(cName);
    env->ReleaseStringUTFChars(scanner_name, cName);
    return mScanner != nullptr;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_huagao_scanner_DeviceManager_close(JNIEnv * env, jobject thiz) 
{
    if (mScanner) 
    {
        HG_CloseScanner(mScanner);
        mScanner = nullptr;
    }
}

extern "C"
JNIEXPORT jboolean JNICALL
Java_com_huagao_scanner_DeviceManager_setScanParam(JNIEnv * env, jobject thiz, jobject params) 
{
    if (mScanner) 
    {
        HG_SCANPARAMS cParams;
        jclass clazz = env->GetObjectClass(params);
        //设置colorMode
        jfieldID id = env->GetFieldID(clazz, "colorMode", "Lcom/huagao/scanner/enums/ColorMode;");
        jobject fieldObj = env->GetObjectField(params, id);
        jfieldID fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
        cParams.PixelType = static_cast<HG_COLORMODE>(env->GetIntField(fieldObj, fieldId));
        LOG("JAVA--- PixelType =%d \n", cParams.PixelType);

        id = env->GetFieldID(clazz, "cacheImgFormat", "Lcom/huagao/scanner/enums/CacheImgFormat;");
        fieldObj = env->GetObjectField(params, id);
        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
        m_cacheimgformat = static_cast<HG_CACHEIMGFORMAT>(env->GetIntField(fieldObj, fieldId));

        id = env->GetFieldID(clazz, "multiOutput", "Lcom/huagao/scanner/enums/MultiOutput;");
        fieldObj = env->GetObjectField(params, id);
        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "multiMode", "I");
        cParams.MultiOutput = static_cast<HG_MULTIOUTPUT>(env->GetIntField(fieldObj, fieldId));
        LOG("JAVA--- MultiOutput =%d \n", cParams.MultiOutput);

        id = env->GetFieldID(clazz, "paperType", "Lcom/huagao/scanner/enums/PaperType;");
        fieldObj = env->GetObjectField(params, id);
        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
        cParams.PaperSize = static_cast<HG_PAPERTYPE>(env->GetIntField(fieldObj, fieldId));
        LOG("JAVA--- PaperSize =%d \n", cParams.PaperSize);

        id = env->GetFieldID(clazz, "paperAlign", "Lcom/huagao/scanner/enums/PaperAlign;");
        fieldObj = env->GetObjectField(params, id);
        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
        cParams.PaperAlign = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
        LOG("JAVA--- PaperAlign =%d \n", cParams.PaperAlign);

        id = env->GetFieldID(clazz, "resolution", "I");
        cParams.Resolution = env->GetIntField(params, id);
        LOG("JAVA--- Resolution =%d \n", cParams.Resolution);

        id = env->GetFieldID(clazz, "scanSide", "Lcom/huagao/scanner/params/ScanSide;");
        fieldObj = env->GetObjectField(params, id);
        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "switchFrontBack", "I");
        cParams.ScanSide.SwitchFrontBack = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- SwitchFrontBack =%d \n", cParams.ScanSide.SwitchFrontBack);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "discardBlank", "I");
        cParams.ScanSide.DiscardBlank = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- DiscardBlank =%d \n", cParams.ScanSide.DiscardBlank);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "discardBlankVince", "I");
        cParams.ScanSide.DiscardBlankVince = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- DiscardBlankVince =%d \n", cParams.ScanSide.DiscardBlankVince);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "duplex", "I");
        cParams.ScanSide.Duplex = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- Duplex =%d \n", cParams.ScanSide.Duplex);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fold", "I");
        cParams.ScanSide.Fold = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- Fold =%d \n", cParams.ScanSide.Fold);

        id = env->GetFieldID(clazz, "imageProcessParams", "Lcom/huagao/scanner/params/ImageProcessParams;");
        fieldObj = env->GetObjectField(params, id);
        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "answerSheetFilterRed", "I");
        cParams.ImageProcess.AnswerSheetFilterRed = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- AnswerSheetFilterRed =%d \n", cParams.ImageProcess.AnswerSheetFilterRed);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoCrop", "I");
        cParams.ImageProcess.AutoCrop = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- AutoCrop =%d \n", cParams.ImageProcess.AutoCrop);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoCropThreshold", "I");
        cParams.ImageProcess.AutoCrop_threshold = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- AutoCrop_threshold =%d \n", cParams.ImageProcess.AutoCrop_threshold);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoDescrew", "I");
        cParams.ImageProcess.AutoDescrew = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- AutoDescrew =%d \n", cParams.ImageProcess.AutoDescrew);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "backRotate180", "I");
        cParams.ImageProcess.BackRotate180 = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- BackRotate180 =%d \n", cParams.ImageProcess.BackRotate180);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "colorCorrection", "I");
        cParams.ImageProcess.ColorCorrection = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- ColorCorrection =%d \n", cParams.ImageProcess.ColorCorrection);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "contrast", "I");
        cParams.ImageProcess.Contrast = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- Contrast =%d \n", cParams.ImageProcess.Contrast);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "brightness", "I");
        cParams.ImageProcess.Brightness = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- Brightness =%d \n", cParams.ImageProcess.Brightness);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "errorExtention", "I");
        cParams.ImageProcess.ErrorExtention = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- ErrorExtention =%d \n", cParams.ImageProcess.ErrorExtention);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fillBlackRect", "I");
        cParams.ImageProcess.FillBlackRect = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- FillBlackRect =%d \n", cParams.ImageProcess.FillBlackRect);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fillHole", "Lcom/huagao/scanner/params/FillHole;");
        jobject fFieldObj = env->GetObjectField(fieldObj, fieldId);
        fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "enbaleFileHole", "I");
        cParams.ImageProcess.FillHole.enable = env->GetIntField(fFieldObj, fieldId);
        LOG("JAVA--- FillHole.enable =%d \n", cParams.ImageProcess.FillHole.enable);

        fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "SearchRatio", "I");
        cParams.ImageProcess.FillHole.ratio = env->GetIntField(fFieldObj, fieldId);
        LOG("JAVA--- FillHole.ratio =%d \n", cParams.ImageProcess.FillHole.ratio);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "filter", "Lcom/huagao/scanner/enums/Filter;");
        fFieldObj = env->GetObjectField(fieldObj, fieldId);
        fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "value", "I");
        cParams.ImageProcess.Filter = static_cast<HG_FILTER>(env->GetIntField(fFieldObj, fieldId));
        LOG("JAVA--- Filter =%d \n", cParams.ImageProcess.Filter);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "gamma", "F");
        cParams.ImageProcess.Gamma = env->GetFloatField(fieldObj, fieldId);
        LOG("JAVA--- Gamma =%.2f \n", cParams.ImageProcess.Gamma);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "indent", "I");
        cParams.ImageProcess.Indent = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- Indent =%d \n", cParams.ImageProcess.Indent);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "IsConvex", "Z");
        cParams.ImageProcess.Is_convex = env->GetBooleanField(fieldObj, fieldId);
        LOG("JAVA--- Is_convex =%d \n", cParams.ImageProcess.Is_convex);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "multiOutFilterRed", "I");
        cParams.ImageProcess.MultiOutFilterRed = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- MultiOutFilterRed =%d \n", cParams.ImageProcess.MultiOutFilterRed);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "noise", "I");
        cParams.ImageProcess.Noise = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- Noise =%d \n", cParams.ImageProcess.Noise);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "noiseDetach", "I");
        cParams.ImageProcess.NosieDetach = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- NosieDetach =%d \n", cParams.ImageProcess.NosieDetach);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "orentation", "Lcom/huagao/scanner/enums/Orentation;");
        fFieldObj = env->GetObjectField(fieldObj, fieldId);
        fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "value", "I");
        cParams.ImageProcess.Orentation = static_cast<HG_ORENTATION>(env->GetIntField(fFieldObj, fieldId));
        LOG("JAVA--- Orentation =%d \n", cParams.ImageProcess.Orentation);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "refuseInflow", "I");
        cParams.ImageProcess.RefuseInflow = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- RefuseInflow =%d \n", cParams.ImageProcess.RefuseInflow);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "removeMorre", "I");
        cParams.ImageProcess.RemoveMorr = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- RemoveMorr =%d \n", cParams.ImageProcess.RemoveMorr);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "sharpenType", "Lcom/huagao/scanner/enums/SharpenType;");
        fFieldObj = env->GetObjectField(fieldObj, fieldId);
        fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "value", "I");
        cParams.ImageProcess.SharpenType = (HG_SHARPENTYPE)env->GetIntField(fFieldObj, fieldId);
        LOG("JAVA--- SharpenType =%d \n", cParams.ImageProcess.SharpenType);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "splitImage", "I");
        cParams.ImageProcess.SplitImage = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- SplitImage =%d \n", cParams.ImageProcess.SplitImage);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "textureRemove", "I");
        cParams.ImageProcess.TextureRemove = env->GetIntField(fieldObj, fieldId);
        LOG("JAVA--- TextureRemove =%d \n", cParams.ImageProcess.TextureRemove);

        id = env->GetFieldID(clazz, "hardwareCaps", "Lcom/huagao/scanner/params/HardwareCaps;");
        fieldObj = env->GetObjectField(params, id);
        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "bindingDetect", "I");
        cParams.HardwareParam.bindingDetection = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
        LOG("JAVA--- bindingDetection =%d \n", cParams.HardwareParam.bindingDetection);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "capturePixType", "I");
        cParams.HardwareParam.capturepixtype = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
        LOG("JAVA--- capturepixtype =%d \n", cParams.HardwareParam.capturepixtype);

        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "doubleFeedDetection", "I");
        cParams.HardwareParam.doubleFeedDetection = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
        LOG("JAVA--- doubleFeedDetection =%d \n", cParams.HardwareParam.doubleFeedDetection);

        return HG_Set_Scan_Params(mScanner, cParams);
    }
    return false;
}

extern "C"
JNIEXPORT jobject JNICALL
Java_com_huagao_scanner_DeviceManager_getScanParam(JNIEnv * env, jobject thiz) 
{
    HG_SCANPARAMS cparams;
    if (mScanner) 
    {
        HG_Get_Scan_Params(mScanner, &cparams);
        jclass myclass = env->FindClass("com/huagao/scanner/ScanParam");
        jmethodID id = env->GetMethodID(myclass, "<init>", "()V");
        jobject jvScanparam = env->NewObject(myclass, id);//调用构造函数

        return jvScanparam;
    }
    return nullptr;
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_huagao_scanner_DeviceManager_startScan(JNIEnv * env, jobject thiz, jint count) 
{
    LOG("JAVA--- strat scan\n");
    return HG_StartScan(mScanner, count);
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_huagao_scanner_DeviceManager_stopScan(JNIEnv * env, jobject thiz)
{
    return HG_StopScan(mScanner);
}

extern "C"
JNIEXPORT jboolean JNICALL
Java_com_huagao_scanner_DeviceManager_isRunning(JNIEnv * env, jobject thiz) 
{
    if (mScanner)
        return HG_Is_Running(mScanner) != 0;
    return 0;
}

extern "C"
JNIEXPORT jboolean JNICALL
Java_com_huagao_scanner_DeviceManager_isPaperPutted(JNIEnv * env, jobject thiz) 
{
    if (mScanner) 
        return HG_Is_FeederLoaded(mScanner) != 0;
    return 0;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_huagao_scanner_DeviceManager_setImageCallback(JNIEnv * env, jobject thiz, jobject callback) 
{
    if (mUserCallback)
        env->DeleteGlobalRef(mUserCallback);
    mUserCallback = env->NewGlobalRef(callback);
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_huagao_scanner_DeviceManager_createMultiDocs(JNIEnv * env, jobject thiz, jobjectArray src_files, jstring dest_path) 
{
    //const int len = env->GetArrayLength(src_files);
    //char** cSrcPaths = new char*[len];

    //for (int i = 0; i < len; i++) {
    //    jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
    //    cSrcPaths[i] = (char*)const_cast<jchar*>(env->GetStringChars(jPath, 0));
    //}
    //char *cDestPath = const_cast<char*>(env->GetStringUTFChars(dest_path, 0));
    //jint ret = HG_Create_MultiPageDocument(cSrcPaths, len, cDestPath);
    //env->ReleaseStringUTFChars(dest_path, cDestPath);
    //for (int i = 0; i < len; i++) {
    //    jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
    //    env->ReleaseStringUTFChars(jPath, cSrcPaths[i]);
    //}

    //delete[] cSrcPaths;
    jint ret = 0;
    return ret;
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_huagao_scanner_DeviceManager_createMultiTiffs(JNIEnv * env, jobject thiz, jobjectArray src_files, jstring dest_path) 
{
    const int len = env->GetArrayLength(src_files);
    char** cSrcPaths = new char* [len];

    for (int i = 0; i < len; i++) 
    {
        jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
        jsize strlen = env->GetStringUTFLength(jPath);
        {
            cSrcPaths[i] = new char[strlen];
            cSrcPaths[i] = const_cast<char*>(env->GetStringUTFChars(jPath, nullptr));
        }
    }

    char* cDestPath = const_cast<char*>(env->GetStringUTFChars(dest_path, 0));
    jint ret = HG_Create_MultiTiff(cSrcPaths, len, cDestPath);
    env->ReleaseStringUTFChars(dest_path, cDestPath);
    for (int i = 0; i < len; i++) 
    {
        jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
        env->ReleaseStringUTFChars(jPath, cSrcPaths[i]);
    }
    delete[] cSrcPaths;
    return ret;
}
extern "C"
JNIEXPORT jstring JNICALL
Java_com_huagao_scanner_DeviceManager_getSDKVersion(JNIEnv * env, jobject thiz) 
{
    char* cVersion = HG_GetSDKVersion();
    LOG("JAVA--- get SDKVersion:%s\n", cVersion);
    if (cVersion == nullptr) 
        return NULL;

    jstring strver = env->NewStringUTF(cVersion);
    return strver;
}

extern "C"
JNIEXPORT jstring JNICALL
Java_com_huagao_scanner_DeviceManager_getFwVersion(JNIEnv * env, jobject thiz) 
{
    const char* cVersion = HG_GetFwVersion(mScanner);
    LOG("JAVA--- get version:%s\n", cVersion);
    if (cVersion == nullptr) 
        return NULL;
    jstring strver = env->NewStringUTF(cVersion);
    return strver;
}

extern "C"
JNIEXPORT jstring JNICALL
Java_com_huagao_scanner_DeviceManager_getSerialNum(JNIEnv * env, jobject thiz) 
{
    const char* cVersion = HG_GetSerialNum(mScanner);
    LOG("JAVA--- getSerialNum =%s \n", cVersion);
    if (cVersion == nullptr) 
        return NULL;

    jstring strver = env->NewStringUTF(cVersion);
    return strver;
}


extern "C"
JNIEXPORT void JNICALL
Java_com_huagao_scanner_DeviceManager_resetPatchIndex(JNIEnv * env, jobject thiz) 
{
    indexPatch = 0;
    LOG("JAVA--- clean indexPatch:%d\n", indexPatch);
}