#include "imageusbhandler.h"
#include "opencv2/opencv.hpp"
#include "imgproc.h"
#include "stringex.hpp"
#include "memoryex.h"
#include "usbimageprocqueue.h"
#include "applog.h"
#include "StopWatch.h"
#include "jpeglib.h"
#include "imageencode.h"
#include <iostream>
#include "ImageApplyAutoCrop.h"
#include "ImageApplyColorCastCorrect.h"
#include "hgutils.h"
#include "correct_ultis.h"

static const std::string loggername = "imageusbhandler";

ImageUsbHandler::ImageUsbHandler(std::shared_ptr<UsbImageProcQueue> images)
    : pool(1), encodepools(6),pushpool(1)
{
    LOG_INIT();
    this->images = images;
    m_dog.reset(new CImageApplyDogEarDetection(40,1.0,50));
    m_colorcast.reset(new CImageApplyColorCastCorrect(CImageApplyColorCastCorrect::CIS_DN_PATCH1));
    m_sizedetect.reset(new CSizedetect(1));
    initLut();
    auto info= jsonconfig().getscannerinfo();
    H_ratio =*((float*)(&info.H_ratio));
    V_ratio =*((float*)(&info.V_ratio));
}
ImageUsbHandler::~ImageUsbHandler()
{
    
}
static int num = 0;
void ImageUsbHandler::add_image(void *data, int width, int height, int type, int scannnum,unsigned int fpgaversion)
{
    printf("ImageUsbHandler::add_image(%d * %d), fpgaversion = %d\n", width, height, fpgaversion);
    
    if(images->push_raw(data, width, height, type == CV_8UC1 ? COLOR_CHANNEL_GRAY : COLOR_CHANNEL_RGB, scannnum, fpgaversion, 0))
    {
        return;
    }

    images->push(nullptr, false);   // notify ONE paper passed 

    // img_one_paper   *paper = new img_one_paper();
    // paper->init_from(data, width, height, scannnum, PAPER_SIDE_LEFT, type == CV_8UC1 ? COLOR_CHANNEL_GRAY : COLOR_CHANNEL_RGB);
    // imgproc_->push_image(paper);
    // paper->release();
    
    std::string ext = ".jpg";
    {
        if (m_imgstatus.status != NO_error)
            return;
        cv::Mat mat;
        if(m_scanconfig.g200params.dpi == 3) 
            mat = cv::Mat(height, width, CV_8UC1, data);
        else
            mat =  cv::Mat(height, width, CV_8UC1, data).clone();                         
        capture_data.Put(mat);
        StopWatch checktime;
        if (m_hgimgconfig.is_dogeardetection || m_hgimgconfig.en_sizecheck)
        {
            cv::Mat tmp = cv::Mat(height, width, CV_8UC1, data);
            if (tmp.empty())
                return;
            m_imgstatus.status = Img_Detecting;
            auto mergemat = GetMergeMat(type == CV_8UC1 ? width : width / 3, height, type, tmp,fpgaversion);
            if (m_scanconfig.g200params.dpi == 1)
                cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 1.0);
            else if (m_scanconfig.g200params.dpi == 2)
                cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 200.0 / 300.0);
            else
            {
#ifdef G200
                cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.43434/3);
#else
                cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.432323/3);
#endif
            }
               
            if (m_hgimgconfig.is_dogeardetection)
            {
                printf("\n is_dogeardetection");
                if(!m_scanconfig.g200params.pc_correct)
                     correctColor(mergemat, false);
                auto dogmat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
                m_dog->apply(dogmat,0);
                if(m_dog->getResult())
                {
                    m_imgstatus.status=Dog_error;
                    m_imgstatus.sannum=scannnum;
                    add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.sannum});
                    return;
                }
            }   
            if(m_hgimgconfig.en_sizecheck)
            {
                auto sizemat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
                printf("\n en_sizecheck %d",m_scanconfig.g200params.paper);
                m_sizedetect->SetPapertype(m_scanconfig.g200params.paper);
                if(m_sizedetect->preprocess(sizemat,NULL))
                {
                    m_imgstatus.status=Size_error;  
                    m_imgstatus.sannum=scannnum;
                    add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.sannum});
                    return;
                }                                  
            }
            m_imgstatus.status = NO_error;
        }
        //tmp.release();

        //std::lock_guard<std::mutex> guard(mtx);
        results.emplace(
            pool.enqueue([this, width, height, type, ext, scannnum, data ,fpgaversion]
                         {
                             printf("enqueue image index %d \n",scannnum);
                             StopWatch sw;
                             cv::Mat mat = capture_data.Take();

                             int dstwidth = type==CV_8UC1?width:width/3;
                             static int it=0;
                             StopWatch sss;                            
                             cv::Mat saveMat =GetMergeMat(dstwidth, height, type,mat,fpgaversion);
                             printf("\n Merge time  %f  fpgaversion %d \n",sss.elapsed_ms(),fpgaversion);
                             //cv::imwrite("/home/"+to_string(it++)+".bmp",saveMat);
                             //int dpi = saveMat.cols==7344?2:3;
                             if(!m_scanconfig.g200params.pc_correct)
                                correctColor(saveMat,m_scanconfig.g200params.dpi,saveMat.channels()==3?1:0,!m_scanconfig.g200params.is_textcorrect);
                             printf("\n correctColor time  %f \n",sw.elapsed_ms());

                            //  if((H_ratio != 1.0f) || (V_ratio != 1.0f))
                            //     cv::resize(saveMat,saveMat,cv::Size(),H_ratio,V_ratio); 
                             encode_data.Put(saveMat);
                             
                             encodeimgs.push(encodepools.enqueue([this,width,height,type]() -> std::vector<MemoryPtr>
                                                             {
                                                                auto saveMat = encode_data.Take();   
                                                                if(H_ratio>1.2f ||H_ratio<0.8f)
                                                                    H_ratio=1.0f;
                                                                if(V_ratio>1.2f || V_ratio <0.8f)
                                                                    V_ratio=1.0f;
                                                                if(m_scanconfig.g200params.dpi==1)
                                                                {
                                                                    cv::resize(saveMat,saveMat,cv::Size(0,0),200.0/300.0*H_ratio,1.0*V_ratio);
                                                                }
                                                                if(m_scanconfig.g200params.dpi == 2)
                                                                {
                                                                    if((H_ratio != 1.0f) || (V_ratio != 1.0f))
                                                                        cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio); 
                                                                }
                                                                if(m_scanconfig.g200params.dpi == 3)
                                                                #ifdef G200
                                                                    cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.43434*V_ratio);  // 600 dpi ��������ʵ600�ɼ� 
                                                                #else
                                                                    cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.432323*V_ratio);
                                                                #endif                                                            
                                                                cv::Mat imageMat;
                                                                std::vector<cv::Mat> imgs;
                                                                int actwidth = saveMat.cols / 2;
                                                                int actheight = saveMat.rows;
                                                                for (int i = 0; i < 2; i++)
                                                                {
                                                                    imageMat = saveMat(cv::Rect(i * actwidth, 0, actwidth, actheight));
                                                                    if (!imageMat.empty())
                                                                    {                                     
                                                                        imgs.push_back(imageMat);
                                                                    }
                                                                }
                                                                 std::shared_ptr<IImageEncode> imageencode; //(new BmpImageEncode());
                                                                 std::vector<MemoryPtr> encodedata;
                                                                 if (!m_scanconfig.g200params.iscorrect_mode)
                                                                 {
                                                                     if (m_hgimgconfig.is_switchfrontback && (imgs.size() > 1))
                                                                         std::swap(imgs[0], imgs[1]);
                                                                     CImageApply* ptr = m_ials[0].get();
		                                                             if (typeid(*ptr) != typeid(CImageApplyOutHole)){
                                                                        if(m_hgimgconfig.imageRotateDegree != 0.0 && m_hgimgconfig.imageRotateDegree != 180.0 && (imgs.size() > 1))
                                                                        {
                                                                            cv::flip(imgs[1], imgs[1], 0);
                                                                            cv::flip(imgs[1], imgs[1], 1);
                                                                        }
                                                                    }

                                                                     for (auto &ialsnode : m_ials)
                                                                     {
                                                                         ialsnode->apply(imgs, bool(m_hgimgconfig.is_duplex));
                                                                     }
                                                                     if ((!m_hgimgconfig.is_duplex) && (imgs.size() > 1))
                                                                         imgs.pop_back();

                                                                 }
                                                                 
                                                                 for (auto &img : imgs)
                                                                 {
                                                                     cv::Mat enMat = img;
                                                                     if (!(enMat.empty() && (m_hgimgconfig.is_autodiscradblank_normal || m_hgimgconfig.is_autodiscradblank_vince)))
                                                                     {
                                                                        if(m_hgimgconfig.fadeback!=0)
                                                                        {
                                                                            if(enMat.channels()==3&&m_hgimgconfig.pixtype==1)
                                                                                cv::cvtColor(enMat,enMat,cv::COLOR_BGR2GRAY);
                                                                        }
                                                                         if(m_scanconfig.g200params.iscorrect_mode)
                                                                            imageencode.reset(new JpegImageEncode(false, m_hgimgconfig.resolution_dst));
                                                                         else
                                                                            imageencode.reset(new JpegImageEncode(m_hgimgconfig.pixtype == 0, m_hgimgconfig.resolution_dst));
                                                                         encodedata.push_back(imageencode->encode(enMat));
                                                                     }
                                                                 }
                                                                 return encodedata;
                                                             }));
                             pushpool.enqueue([this]{
                                auto mem = encodeimgs.front().get();
                                encodeimgs.pop();
                                if (!mem.empty())
                                {
                                    for (auto &data : mem)
                                    {
                                        if (data.get())
                                            images->push(data, true);
                                        else
                                            add_scanevent({.From = V4L2, .Code = 1});
                                    }
                                }
                             });
                             printf("imgproce time = %f \n", sw.elapsed_ms());
                             LOG_TRACE(string_format("imgproce time = %f\n", sw.elapsed_ms())); }));
    }
}

bool ImageUsbHandler::is_limit(){
    if (m_hgimgconfig.resolution_dst > 200.0 || m_hgimgconfig.papertype == 52 || m_hgimgconfig.papertype == 54 ||
        m_hgimgconfig.papertype == 131)
    {
        while (results.size() >= (m_scanconfig.g200params.dpi == 3 ? 1 : 2))
        {
            results.front().get();
            {
                //std::lock_guard<std::mutex> guard(mtx);
                results.pop();
            }
        }
        if (encodeimgs.size() >= (m_scanconfig.g200params.dpi == 3 ? 1 : 2))
        {
            return true;
        }
    }
    else
    {
        while (results.size() >= 15)
        {
            results.front().get();
            {
                //std::lock_guard<std::mutex> guard(mtx);
                results.pop();
            }
        }
        if (encodeimgs.size() >= 15)
        {
            //printf("\n encodeimgs size  = %d ", encodeimgs.size());
            return true;
        }
    }
    return false;
}

void ImageUsbHandler::add_scanevent(HGIntInfo status)
{
    VectorMemroyPtr mem = VectorMemroyPtr(new VectorMemroy());
    HGIntInfo info = status;
    mem->resize(sizeof(info));
    memcpy(&mem->buf()[0], &info, sizeof(info));
    images->push(mem, false);
}

void ImageUsbHandler::clear()
{
    if (images.get())
        images->clear();
    while (results.size() > 0)
        results.pop();
    while (encodeimgs.size() > 0)
        encodeimgs.pop();
    capture_data.Clear();
}

void ImageUsbHandler::Set_ratio(u32 h_ratio,u32 v_ratio)
{
    H_ratio =*((float*)(&h_ratio));
    V_ratio =*((float*)(&v_ratio));
}

bool ImageUsbHandler::done()
{
    std::lock_guard<std::mutex> guard(mtx);
    if(results.size() >= 1){
        auto &fu_run = results.back();
        if((fu_run.valid() && (fu_run.wait_for(std::chrono::seconds(0)) != std::future_status::ready)))
            return false;
    }
    if(encodeimgs.size()>=1)
    {
        auto &fu_encode = encodeimgs.back();
        if((!fu_encode.valid()) && encodeimgs.size() == 1)
            return true;
        else
            return false;
        return !(fu_encode.wait_for(std::chrono::seconds(0)) != std::future_status::ready);
        //return (!(fu_run.wait_for(std::chrono::seconds(0)) != std::future_status::ready))&&(!(fu_encode.wait_for(std::chrono::seconds(0)) != std::future_status::ready));
    }
    return true;
}

void ImageUsbHandler::config_procparams(HGImgProcParms params)
{
    LOG_TRACE("****ImageUsbHandler config_procparams****\n");
    LOG_TRACE(string_format("HGImgProcParms.value = %d \n", params.value));
    LOG_TRACE(string_format("HGImgProcParms.papertype = %d  HGImgProcParms.scanside = %d \n", params.imgprocparams.papertype, params.imgprocparams.scanside));
    LOG_TRACE(string_format("HGImgProcParms.res = %d  HGImgProcParms.rotate = %d \n", params.imgprocparams.res, params.imgprocparams.rotate));
    LOG_TRACE(string_format("HGImgProcParms.autodescrew = %d  HGImgProcParms.fillbackground = %d \n", params.imgprocparams.autodescrew, params.imgprocparams.fillbackground));
    LOG_TRACE(string_format("HGImgProcParms.filter = %d  HGImgProcParms.enhancecolor = %d \n", params.imgprocparams.filter, params.imgprocparams.enhancecolor));
    LOG_TRACE(string_format("HGImgProcParms.fillhole = %d \n", params.imgprocparams.fillhole));
    m_procparams = params;
}