#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::string m_default_prefix = "1000";
static std::map< HG_CACHEIMGFORMAT, std::string> m_mapcaches = {
    {HG_CJPG,".jpg"},
    {HG_CPNG,".png"},
    {HG_CBMP,".bmp"},
    {HG_CTIFF,".tiff"}
};
#include <regex>

//// 使用正则表达式判断文件名是否有效(不含非法字符)
//inline bool IsValidFileName(const std::string& strFileName)
//{
//    // Windows下文件名中不能包含\/:*?"<>|这些字符
//    std::regex regExpress("[\\/:*?\"<>|]");
//    bool bValid = !std::regex_search(strFileName, regExpress);
//    return bValid;
//}

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)
    {
        LOG("JAVA--- mUserCallback is null\n");
        return;
    }

    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 += m_default_prefix;
        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 + "/" + m_default_prefix + 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())
    {
        LOG("JAVA---  Get Image data is NULL");
        return;
    }
    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()));

    if (ret < 0)
        g_vm->DetachCurrentThread();

}

//aaa
void onEvent(HG_STATUSCODE statuscode, void *obj) 
{
    std::lock_guard<std::mutex> lock(m_mutex);
    LOG("JAVA---  Enter  onEvent callback 1  statuscode=%d \n", (int)statuscode);
    if (statuscode <= 0 || statuscode > 13)
        return;
    if (!mUserListener) 
    {
        LOG("JAVA--- onEvent is NULL\n");
        return;
    }
    JNIEnv *env;
    jint ret = g_vm->GetEnv((void **) &env, JNI_VERSION_1_6);
    if (ret < 0) 
    {
        jint ret2=  g_vm->AttachCurrentThread((void**)&env, NULL);
        LOG("JAVA--- Enter AttachCurrentThread ret2=%d \n", (int)ret2);
    }
    jclass listenerClazz = env->GetObjectClass(mUserListener);
    jmethodID methodEventId = env->GetMethodID(listenerClazz, "onEvent", "(I)V");
    env->CallVoidMethod(mUserListener, methodEventId, (jint)statuscode);
    if (ret < 0) 
    {
        LOG("JAVA--- Enter  onEvent callback DetachCurrentThread\n");
        g_vm->DetachCurrentThread();
    }
}

extern "C" JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *vm, void *reserved) {
    LOG("JAVA--- enter JNI_OnLoad\n");
    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--- exit JNI_OnLoad\n");
    return JNI_VERSION_1_6;
}

extern "C"
JNIEXPORT jobjectArray JNICALL
Java_com_huagao_scanner_DeviceManager_getDevices(JNIEnv *env, jobject thiz) {
    LOG("JAVA--- ENTER GETDEVICES\n");

    const char* sp=";";
    char *cDevices = HG_GetDevices(const_cast<char*>(sp));
    if (cDevices == nullptr) 
    {
        LOG(" JAVA--- get no device\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;");
    LOG("JAVA--- EXIT getDevices\n");
    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)
        {
            LOG("JAVA---SET SCAN PARAM FAIL!!!");
            return false;
        }
  
        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) - 1);
        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), "noiseDetachEnable", "I");
        //cParams.ImageProcess.NosieDetachEnable = env->GetIntField(fieldObj, fieldId);
        //LOG("JAVA--- NosieDetachEnable =%d \n", cParams.ImageProcess.NosieDetachEnable);

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

        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);

}

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);//调用构造函数

//        jfieldID  fieldId = env->GetFieldID(myclass, "colorMode", "Lcom/huagao/scanner/enums/ColorMode;");
//        env->SetIntField(jvScanparam, fieldId, (jint)cparams.PixelType);

//        fieldId = env->GetFieldID(myclass, "multiOutput", "Lcom/huagao/scanner/enums/MultiOutput;");
//        env->SetIntField(jvScanparam, fieldId, (jint)cparams.MultiOutput);

//        fieldId = env->GetFieldID(myclass, "paperType", "Lcom/huagao/scanner/enums/PaperType;");
//        env->SetIntField(jvScanparam, fieldId, (jint)cparams.PaperSize);

//        fieldId = env->GetFieldID(myclass, "paperAlign", "Lcom/huagao/scanner/enums/PaperAlign;");
//        env->SetIntField(jvScanparam, fieldId, cparams.PaperAlign);

//        fieldId = env->GetFieldID(myclass, "resolution", "I");
//        env->SetIntField(jvScanparam, fieldId, cparams.Resolution);

//        fieldId = env->GetFieldID(myclass, "scanSide", "Lcom/huagao/scanner/params/ScanSide;");
//        jobject fieldObj = env->GetObjectField(jvScanparam, fieldId);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "switchFrontBack", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ScanSide.SwitchFrontBack);//交换正反面
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "discardBlank", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ScanSide.DiscardBlank);//跳过空白页通用
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "discardBlankVince", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ScanSide.DiscardBlankVince);//跳过空白页发票
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "duplex", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ScanSide.Duplex);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fold", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ScanSide.Fold);

//        fieldId = env->GetFieldID(myclass, "imageProcessParams", "Lcom/huagao/scanner/params/ImageProcessParams;");
//        fieldObj = env->GetObjectField(jvScanparam, fieldId);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "answerSheetFilterRed", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.AnswerSheetFilterRed);

//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoCrop", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.AutoCrop);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoCropThreshold", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.AutoCrop_threshold);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoDescrew", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.AutoDescrew);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "backRotate180", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.BackRotate180);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "colorCorrection", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.ColorCorrection);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "contrast", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.Contrast);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "brightness", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.Brightness);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "errorExtention", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.ErrorExtention);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fillBlackRect", "I");
//        env->SetIntField(fieldObj, fieldId, 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");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.FillHole.enable);
//        fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "SearchRatio", "I");
//        env->SetIntField(fieldObj, fieldId, 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");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.Filter);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "gamma", "F");
//        env->SetFloatField(fieldObj, fieldId, cparams.ImageProcess.Gamma);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "indent", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.Indent);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "IsConvex", "Z");
//        env->SetBooleanField(fieldObj, fieldId,(jboolean)cparams.ImageProcess.Is_convex);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "multiOutFilterRed", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.MultiOutFilterRed);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "noise", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.Noise);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "noiseDetach", "I");
//        env->SetIntField(fieldObj, fieldId, 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");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.Orentation);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "refuseInflow", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.RefuseInflow);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "removeMorre", "I");
//        env->SetIntField(fieldObj, fieldId, 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");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.SharpenType);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "splitImage", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.SplitImage);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "textureRemove", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.ImageProcess.TextureRemove);

//        fieldId = env->GetFieldID(myclass, "hardwareCaps", "Lcom/huagao/scanner/params/HardwareCaps;");
//        fieldObj = env->GetObjectField(jvScanparam, fieldId);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "bindingDetect", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.HardwareParam.bindingDetection);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "capturePixType", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.PixelType);
//        fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "doubleFeedDetection", "I");
//        env->SetIntField(fieldObj, fieldId, cparams.HardwareParam.doubleFeedDetection);
        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) {
    LOG("JAVA--- stop scan\n");
    return HG_StopScan(mScanner);
}

extern "C"
JNIEXPORT jboolean JNICALL
Java_com_huagao_scanner_DeviceManager_isRunning(JNIEnv *env, jobject thiz) {
    if (mScanner) 
    {
        LOG("JAVA---  scanner is running\n");
        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;
    return 0;
}

extern "C"
JNIEXPORT jstring JNICALL
Java_com_huagao_scanner_DeviceManager_getSDKVersion(JNIEnv * env, jobject thiz) {
    LOG("enter getDevices\n");

    char* cVersion = HG_GetSDKVersion();
    if (cVersion == nullptr) {
        LOG("JAVA--- get SDKVersion  is NULL\n");
        return NULL;
    }
    LOG("JAVA--- get SDKVersion:%s\n", cVersion);
    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);
    if (cVersion == nullptr) 
    {
        LOG("JAVA--- get FwVersion is null\r\n");
        return NULL;
    }
    LOG("JAVA--- get FwVersion:%s\n", cVersion);
    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);
    if (cVersion == nullptr) 
    {
        LOG("JAVA--- get GetSerialNum is null \r\n");
        return NULL;
    }
    LOG("JAVA--- get GetSerialNum:%s\n", cVersion);
    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);
}


extern "C"
JNIEXPORT void JNICALL
Java_com_huagao_scanner_DeviceManager_setPrefix(JNIEnv * env, jobject thiz, jstring prefix)
{
    char* cName = const_cast<char*>(env->GetStringUTFChars(prefix, 0));
    if (cName)
    {
        auto len =  strlen(cName);
        LOG("JAVA--- setPrefix prefix_len = %d  prefix = %s \n", len, cName);
        if (len > 0)
        {
            m_default_prefix.resize(len);
            memcpy((void*)m_default_prefix.data(), cName, len);
            LOG("JAVA--- setPrefix m_default_prefix = %d  prefix = %s \n", m_default_prefix.length(), m_default_prefix.c_str());
        }
        env->ReleaseStringUTFChars(prefix, cName);
    }
}