#include <stdlib.h>
#include <sstream>
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include "HG_SCANNER_API.h"
using namespace std;

char *devBuf = NULL;
HG_Scanner_Handle scannerPtr = NULL;
std::string img_type_ = ".jpg";
HG_SCANPARAMS param;
map<int, string> m_statusmap = {
    {(int)HG_STATUSCODE::HG_STATUS_SCANNING, "Scanning... "},
    {(int)HG_STATUSCODE::HG_STATUS_SCANSTOP, "Scan Stopped "},
    {(int)HG_STATUSCODE::HG_STATUS_NO_FEED, "No Feed "},
    {(int)HG_STATUSCODE::HG_STATUS_COVEROPEN, "Cover Open "},
    {(int)HG_STATUSCODE::HG_STATUS_FEED_IN_ERROR, "Feed Error "},
    {(int)HG_STATUSCODE::HG_STATUS_PAPER_JAM, "Paper Jam "},
    {(int)HG_STATUSCODE::HG_STATUS_DETECT_STAPLE, "Staple detected "},
    {(int)HG_STATUSCODE::HG_STATUS_DETECT_DOUBLE_FEED, "Double Feed "},
    {(int)HG_STATUSCODE::HG_STATUS_DETECT_SIZECHECKERROR, "Size Error"},
    {(int)HG_STATUSCODE::HG_STATUS_PAPER_SKEW, "Paper Screw"},
    {(int)HG_STATUSCODE::HG_STATUS_USBCONNECT, "USB connected"},
    {(int)HG_STATUSCODE::HG_STATUS_USBDISCONNECT, "USB Disconnected"},
    {(int)HG_STATUSCODE::HG_STATUS_USBERROR, "USB communicate error"}
};

void Set_SnapParams();
void on_aquireimage(HG_IMG *img, void *obj);
void on_deviceevent(HG_STATUSCODE statuscode, void *obj);
int  writeimage(std::string filename, std::vector<unsigned char>& imagedata);

int menu()
{
    int select = -1;
    cout << "-----------------------------------Menu--------------------------------------------" << endl;
    cout << "1:Start Scan" << endl;
    cout << "2:Stop Scan" << endl;
    cout << "3:Get Devs Lists" << endl;
    cout << "4:Get parms Lists" << endl;
    cout << "5:exit demo" << endl;
    cout << "6:testsleep,get is paper" << endl;
    cout << "7:test set color" << endl;
    cout << "8:test set save pic type" << endl;
    cout << "9:test paper size" << endl;
    cout << "-----------------------------------Menu End-----------------------------------------" << endl;
    cout << "\n Please input your choice: " << endl;
    cin >> select;
    return select;
}


int init()
{
    HG_Init();
    char buf[] = ";";
    devBuf = HG_GetDevices(buf);
    if (devBuf == NULL)
    {
        cout << "Get Dev List fial:" << endl;
        return -1;
    }

    scannerPtr = HG_OpenScanner(devBuf);
    if (scannerPtr)
    {
        HG_ImgSaveType(img_type_.c_str());
        HG_Set_AquireImg_callback(on_aquireimage, nullptr);
        HG_Set_OnDeviceEvent_callback(on_deviceevent,nullptr);
    }
    Set_SnapParams();
    return 0;
}

void get_Params()
{
    if (scannerPtr == NULL)
    {
        return;
    }
    HG_SCANPARAMS param_i;
    HG_Get_Scan_Params(scannerPtr, &param_i);

    cout << " PixelType:" << param_i.PixelType
         << " MultiOutput:" << param_i.MultiOutput
         << " PaperSize:" << param_i.PaperSize
         << " PaperAlign:" << param_i.PaperAlign
         << " Resolution:" << param_i.Resolution << endl;
}

void Set_SnapParams()
{
    if (scannerPtr == NULL)
        return;

    int ret = 0;
    
    ret = HG_Get_Scan_Params(scannerPtr, &param);
    if (ret != 0)
    {
        cout << "Get Scan Params Fial!!!  ret:" << endl;
        return;
    }
    param.ImageProcess.AutoDescrew = 1;
    param.PixelType = HG_COLORMODE::HG_RGB; // 0 blackwhite 1 gray 2 color
    param.ImageProcess.FillBlackRect = 1;   //     ڿ 
    param.Resolution = 300;
    //param.ScanSide.Duplex = 0;
    
    ret = HG_Set_Scan_Params(scannerPtr, param);
    if (ret != 0)
    {
        cout << "Set Scan Params Fial!!!  ret:" << endl;
        return;
    }
    cout << "\r\nSet Scan Params Succes!!!  ret:" << ret << endl;
    HG_Set_Img_Quality(scannerPtr, false);
    ret = HG_Get_Scan_Params(scannerPtr, &param);
}
void test_Set_SnapParams()
{
    int ret = HG_Set_Scan_Params(scannerPtr, param);
    if (ret != 0)
    {
        cout << "Get Scan Params Fial!!!  ret:" << endl;
        return;
    }
    cout << "\r\nGet Scan Params Succes!!!  ret:" << ret << endl;
}

int StartScan(int num)
{
    int ret = HG_StartScan(scannerPtr, num);
     ret == 0 ? cout << "\r\nStart Scan" << endl : cout << "\r\nStart Scan fial!!!" << endl;
     return ret;
}

void StopScan()
{
    int ret = HG_StopScan(scannerPtr);
    ret == 0 ? cout << "\r\nStop Scanner success " << endl : cout << "\r\nStop Scanner failed " << endl;
}

void Is_FeederLoaded()
{
    int ret = HG_Is_FeederLoaded(scannerPtr);
    if (ret == 0)
        cout << "\r\nDetect No Feed!!!" << endl;
    else
        cout << "\r\nFeeded" << endl;
}

void Is_SleepStatus()
{
    int ret = HG_GET_IS_SLEEP_STATUS(scannerPtr);
    if (ret == 0)
        cout << "\r\nDetect No sleep!!!" << endl;
    else
        cout << "\r\nsleep fial" << endl;
}

void on_aquireimage(HG_IMG *img, void *obj)
{

    if (img == NULL)
        return;
    HG_IMG *getimg = img;
    if (getimg->height == 0 || getimg->width == 0 || getimg->bitdepth == 0)
    {
        cout << "GetImg param Fial" << endl;
        return;
    }

    static int imgindex = 0;
    string savepath = std::to_string(++imgindex) + img_type_;

    vector<unsigned char>imagedata;
    imagedata.insert(imagedata.end(), img->pimgdata, img->pimgdata + img->bufferlength);

    writeimage(savepath, imagedata);
   //bool b = G4TiffSave((char *)savepath.c_str());
   //if (!b)
   //{
   //    printf("Tiff G4 Conversion Fail \r\n");
   //    return;
   //}
    printf("--------------------savepath:%s-------------------------------------------\r\n", savepath.c_str());
   /* ofstream o(savepath);
    
    o.write((const char *)img->pimgdata, img->bufferlength);
    o.flush();
    o.close();*/
}

void on_deviceevent(HG_STATUSCODE statuscode, void *obj)
{
    if(m_statusmap.count(statuscode))
    {
        cout<<"Status: "<<m_statusmap[(int)statuscode]<<endl;
    }
    else
        cout<<"Unknowun Status, status code : "<<(int)statuscode<<endl;
}


int  writeimage(std::string filename, std::vector<unsigned char>& imagedata)
{
    if (filename.empty() || imagedata.empty())
    {
        return -1;
    }
    FILE* fp = NULL;
    if (NULL == imagedata.data() || imagedata.size() <= 0) return -1;
    fp = fopen(filename.c_str(), "wb");

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

    size_t size = fwrite(imagedata.data(), imagedata.size(), 1, fp); //      
    fclose(fp);
    fp = NULL;
    if (size <= 0)
    {
        return -1;
    }
    return 0;
}

int main(int argc, char *argv[])
{

    bool flag = false;
    init();
    int ret = 0;
    int funparam = menu();
    while (funparam >= 0)
    {

        Is_FeederLoaded();
        cout << "funparam = " << funparam << endl;
        switch (funparam)
        {
        case 1:
            cout << "Please input number of Pages to scan:" << endl;
            int scanNum;
            cin >> scanNum;
            if (scanNum <= 0)
                scanNum = 500;
            ret = StartScan(scanNum);
            if (ret)
                flag = true;
            break;
        case 2:
            StopScan();
            break;
        case 5:
            return 0;
        case 6:
            Is_SleepStatus();
            Is_FeederLoaded();
            break;
        case 7:
            cout << "1:blackwhite 2:gray 3:color" << endl;
            int scanNum1;
            cin >> scanNum1;

            if (scanNum1 == 1)
                param.PixelType= HG_COLORMODE::HG_BlackWhite;
            else if (scanNum1 == 2)
                param.PixelType= HG_COLORMODE::HG_Gray;
            else
                param.PixelType= HG_COLORMODE::HG_RGB;

             test_Set_SnapParams();
           break;
        case 8:
            cout << "1:png 2:jpg" << endl;
            int scanNum2;
            cin >> scanNum2;

            if (scanNum2 == 1)
                img_type_ = ".png";
            else
                img_type_ = ".jpg";
                
            HG_ImgSaveType(img_type_.c_str());
            break;
        case 9:
            cout << "1:A4 2:A4R 3:A3 4:A3R" << endl;
            int scanNum3;
            cin >> scanNum3;

            if (scanNum3 == 1)
            {
                param.PaperSize = HG_PAPERTYPE::HG_A4;
            }
            else if(scanNum3 == 2)
            {
                param.PaperSize = HG_PAPERTYPE::HG_A4;
                param.PaperAlign = HG_PAPERALIGN::HG_Rot270;
            }
            else if(scanNum3 == 3)
            {
                param.PaperSize = HG_PAPERTYPE::HG_A3;
            }
            else if(scanNum3 == 4)
            {
                param.PaperSize = HG_PAPERTYPE::HG_A3;
                param.PaperAlign = HG_PAPERALIGN::HG_Rot270;
            }
            test_Set_SnapParams();
            break;
        default:
            cout << "\r\nUncorrect command!" << endl;
            break;
        }
        funparam = menu();
    }
    return 0;
}