#include "JsonConfig.h"
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <sstream>
#include <iomanip>
#include <QDir>
//#include <direct.h>
//#include <ShlObj_core.h>

using namespace std;

/************************************
**ɨ��������json��ʽ������������**
*************************************/

bool isFolderExist(const QString& folder)
{
    QDir dir(folder);
    return dir.exists();
}

int createDirectory(const QString& folder)
{
    QDir dir;
    return dir.mkdir(folder);
}


JsonConfig::JsonConfig(void)
{
}


JsonConfig::~JsonConfig(void)
{
}

/************************************************************************/
/*                ��������                                          */
/************************************************************************/

void JsonConfig::WriteToJson(GScanCap* pConfigItem, const std::string fileName, bool isConfigItem)
{
    std::string header = "Config";
    GScanCap& pp = *pConfigItem;
    json j;
    auto& jobject = j[header];
    //jobject[PIXTYPE][0] = false;
    jobject[PIXTYPE][0] = pConfigItem->pixelType;
    jobject[PAPERSIZE][0] = pConfigItem->paperSize;
    jobject[PAPERALIGN][0] = pConfigItem->paperAlign;
    jobject[AUTOCROP][0] = pConfigItem->imageProcess.autoCrop;
    jobject[RESOLUTION][0] = pConfigItem->resolution;
    jobject[DUPLEX][0] = pConfigItem->scanSide.duplex;
    jobject[DISCARBLANK][0] = pConfigItem->scanSide.discardBlank;
    jobject[DISCARBLANKVINCE][0] = pConfigItem->scanSide.discardBlankVince;
    jobject[FOLD][0] = pConfigItem->scanSide.fold;
    jobject[EXCHANGEFB][0] = pConfigItem->scanSide.switchFrontBack;

    jobject[BRIGHTNESS][0] = pConfigItem->imageProcess.brightness;
    jobject[CONTRAST][0] = pConfigItem->imageProcess.contrast;
    jobject[GAMMA][0] = pConfigItem->imageProcess.gamma;

    jobject[AUTODESCREW][0] = pConfigItem->imageProcess.autoDescrew;
    jobject[FILLBLACK][0] = pConfigItem->imageProcess.fillBlackRect;
    jobject[OUTHOLE][0] = pConfigItem->imageProcess.fillHole.enable;
    jobject[OUTHOLERATIO][0] = pConfigItem->imageProcess.fillHole.ratio;
    jobject[FILTERTYPE][0] = pConfigItem->imageProcess.filter;
    jobject[SHARPENTYPE][0] = pConfigItem->imageProcess.sharpenType;
    jobject[MULTIOUTPUTR][0] = pConfigItem->imageProcess.multiOutFilterRed;
    jobject[ANSWERSHEETR][0] = pConfigItem->imageProcess.answerSheetFilterRed;

    jobject[SCANCOUNT][0] = pConfigItem->scanCount;
    jobject[DOCORIENTATION][0] = pConfigItem->imageProcess.orentation;
    jobject[BACKROTATE180][0] = pConfigItem->imageProcess.backRotate180;
    jobject[ULTRADETECT][0] = pConfigItem->hardwareParam.doubleFeedDetection;
    jobject[BINDINGDETECT][0] = pConfigItem->hardwareParam.bindingDetection;
    jobject[SKEWDENABLE][0] = pConfigItem->hardwareParam.skewDetection.enable;
    jobject[SKEWLEVEL][0] = pConfigItem->hardwareParam.skewDetection.level;
    if (isConfigItem)
    {
        jobject[ITEMCAPTION][0] = pConfigItem->Caption;
        jobject[SAVEPATH][0] = pConfigItem->SavePath;
    }

    std::ofstream o(fileName);//TODO:֧����������json�ļ�д��
    o << std::setw(4) << j << std::endl;
}

void JsonConfig::WriteJsonData(const std::string fileName)
{

}


void JsonConfig::WriteJsonArrayToFile(std::vector<GScanCap> cfgArray, const std::string filename)
{
    /*std::string header = "Config";
    json j;
    auto& jobject = j[header];
    jobject[PIXTYPE] = nullptr;
    jobject[PAPARSIZE] = nullptr;
    jobject[AUTOCROP] = nullptr;
    jobject[RESOLUTION] = nullptr;
    jobject[DUPLEX] = nullptr;
    jobject[DISCARBLANK] = nullptr;
    jobject[DISCARBLANKVINCE] = nullptr;
    jobject[DB_AREANUM] = nullptr;
    jobject[DB_DEVNMAX] = nullptr;
    jobject[FOLD] = nullptr;
    jobject[EXCHANGEFB] = nullptr;

    jobject[BRIGHTNESS] = nullptr;
    jobject[AUTOCONTRAST] = nullptr;
    jobject[CONTRAST] = nullptr;
    jobject[GAMMA_] = nullptr;

    jobject[FILTERTYPE] = nullptr;
    jobject[SHARPENTYPE] = nullptr;
    jobject[AUTODESCREW] = nullptr;
    jobject[FILLBLACK] = nullptr;
    jobject[MULTIOUTPUTR] = nullptr;
    jobject[OUTHOLE] = nullptr;
    jobject[OUTHOLERATIO] = nullptr;
    jobject[ANSWERSHEETR] = nullptr;

    jobject[ULTRADETECT] = nullptr;
    jobject[BINDINGDETECT] = nullptr;
    jobject[SCANCOUNT] = nullptr;
    jobject[DOCORIENTATION] = nullptr;
    jobject[BACKROTATE180] = nullptr;
    jobject[SCREWDETECT] = nullptr;
    jobject[SCREWLEVEL] = nullptr;

    jobject[ITEMCAPTION] = nullptr;
    jobject[SAVEPATH] = nullptr;

    for (int i = 0; i < cfgArray.size(); i++)
    {
        jobject[PIXTYPE][0] = cfgArray[i].Pixtype;
        jobject[PAPARSIZE][0]= cfgArray[i].PaperSize;
        jobject[AUTOCROP][i] = cfgArray[i].EnAutoCrop;
        jobject[RESOLUTION][0]= cfgArray[i].Resolution;
        jobject[DUPLEX][0] = cfgArray[i].EnDuplex;
        jobject[DISCARBLANK][i] = cfgArray[i].EnDiscardBlank;
        jobject[DISCARBLANKVINCE][i] = cfgArray[i].EnDiscardBlankVince;
        jobject[DB_AREANUM][0] = cfgArray[i].DBlank_AreaNum;
        jobject[DB_DEVNMAX][0] = cfgArray[i].DBlank_DevnMax;
        jobject[FOLD][i] = cfgArray[i].EnFold;
        jobject[EXCHANGEFB][i] = cfgArray[i].EnExchangeFrontBack;

        jobject[BRIGHTNESS][0] = cfgArray[i].Brightness;
        jobject[AUTOCONTRAST][i]= cfgArray[i].EnAutoContrast;
        jobject[CONTRAST][0] = cfgArray[i].Contrast;
        jobject[GAMMA_][0] = cfgArray[i].Gamma;

        jobject[FILTERTYPE][0]=(cfgArray[i].Filter);
        jobject[SHARPENTYPE][0]=(cfgArray[i].Sharpen);
        jobject[AUTODESCREW][0]=(i,cfgArray[i].EnAutoDescrew);
        jobject[FILLBLACK][0]=(i,cfgArray[i].EnFillBlack);
        jobject[MULTIOUTPUTR][0]=(i,cfgArray[i].EnMultiOutPutR);
        jobject[OUTHOLE][0]=(i,cfgArray[i].EnOutHole);
        jobject[OUTHOLERATIO][0]=(cfgArray[i].OutHoleRatio);
        jobject[ANSWERSHEETR][0] = (i, cfgArray[i].EnAnswerSheetR);

        jobject[ULTRADETECT][0]=(i,cfgArray[i].EnUltrasonicDetect);
        jobject[BINDINGDETECT][0]=(i,cfgArray[i].EnBindingDetect);
        jobject[SCANCOUNT][0]=(cfgArray[i].ScanCount);
        jobject[DOCORIENTATION][0]=(cfgArray[i].Orentation);
        jobject[BACKROTATE180][0]=(i,cfgArray[i].EnBackRotate180);
        jobject[SCREWDETECT][0]=(i,cfgArray[i].EnScrewDetect);
        jobject[SCREWLEVEL][0]=(cfgArray[i].ScrewDetectLevel);

        if (cfgArray[i].Caption.c_str()!=NULL)
            jobject[ITEMCAPTION][0]=(cfgArray[i].Caption);

        if (cfgArray[i].SavePath.c_str()!=NULL)
            jobject[SAVEPATH][0]=(cfgArray[i].SavePath);
    }
    std::ofstream o(filename);
    o << std::setw(4) << j << std::endl;*/
}


GScanCap JsonConfig::ReadDefaultConfig()
{
    return GetDefaultConfigParams();
}

bool JsonConfig::DeleteJsonFile(std::string path)
{
    return (remove(path.c_str()));
}

GScanCap JsonConfig::ReadJsonFromFile(const std::string filename)
{
    GScanCap re;
    FILE* file = fopen(filename.c_str(), "rb");
    if (!file)
    {
        return re;
    }
    fseek(file, 0, SEEK_END);
    long size = ftell(file);
    fseek(file, 0, SEEK_SET);
    std::string text;
    char* buffer = new char[size + 1];
    buffer[size] = 0;
    if (!fread(buffer, 1, size, file) == (unsigned long)size)
    {
        return re;
    }
    text = buffer;

    fclose(file);
    delete[]buffer;
    re = parseJsonFromString(text);
    return re;
}

GScanCap JsonConfig::GetDefaultConfigParams()
{
    GScanCap params;
    params.pixelType = ColorMode::RGB;
    params.paperSize = TwSS::A3;
    params.paperAlign = PaperAlign::Rot0;
    params.imageProcess.autoCrop = 1;
    params.resolution = 200;
    params.scanSide.duplex = 1;
    params.scanSide.discardBlank = 0;
    params.scanSide.discardBlankVince = 0;
    params.scanSide.fold = 0;
    params.scanSide.switchFrontBack = 0;

    params.imageProcess.brightness = 128;
    params.imageProcess.contrast = 4;
    params.imageProcess.gamma = 1.0f;

    params.imageProcess.autoDescrew = 1;
    params.imageProcess.fillBlackRect = 0;
    params.imageProcess.fillHole.enable = 0;
    params.imageProcess.fillHole.ratio = 10;
    params.imageProcess.filter = ColorFilter::FILTER_NONE;
    params.imageProcess.sharpenType = SharpenType::STNone;
    params.imageProcess.multiOutFilterRed = 0;
    params.imageProcess.answerSheetFilterRed = 0;

    params.scanCount = -1;
    params.imageProcess.orentation = Orentation::ROTATE_NONE;
    params.imageProcess.backRotate180 = 0;
    params.hardwareParam.doubleFeedDetection = 1;
    params.hardwareParam.bindingDetection = 0;
    params.hardwareParam.skewDetection.enable = 1;
    params.hardwareParam.skewDetection.level = 3;
    return params;
}

GScanCap JsonConfig::parseJsonFromString(const std::string str)
{
    std::string header = "Config";
    json j = json::parse(str);
    auto& jobject = j[header];

    GScanCap cfg;
    cfg.pixelType = jobject[PIXTYPE][0];
    cfg.paperSize = jobject[PAPERSIZE][0];
    cfg.paperAlign = jobject[PAPERALIGN][0];
    cfg.imageProcess.autoCrop = jobject[AUTOCROP][0];
    cfg.resolution = jobject[RESOLUTION][0];
    cfg.scanSide.duplex = jobject[DUPLEX][0];
    cfg.scanSide.discardBlank = jobject[DISCARBLANK][0];
    cfg.scanSide.discardBlankVince = jobject[DISCARBLANKVINCE][0];
    cfg.scanSide.fold = jobject[FOLD][0];
    cfg.scanSide.switchFrontBack = jobject[EXCHANGEFB][0];

    cfg.imageProcess.brightness = jobject[BRIGHTNESS][0];
    cfg.imageProcess.contrast = jobject[CONTRAST][0];
    cfg.imageProcess.gamma = jobject[GAMMA][0];

    cfg.imageProcess.autoDescrew = jobject[AUTODESCREW][0];
    cfg.imageProcess.fillBlackRect = jobject[FILLBLACK][0];
    cfg.imageProcess.fillHole.enable = jobject[OUTHOLE][0];
    cfg.imageProcess.fillHole.ratio = jobject[OUTHOLERATIO][0];
    cfg.imageProcess.filter = jobject[FILTERTYPE][0];
    cfg.imageProcess.sharpenType = jobject[SHARPENTYPE][0];
    cfg.imageProcess.multiOutFilterRed = jobject[MULTIOUTPUTR][0];
    cfg.imageProcess.answerSheetFilterRed = jobject[ANSWERSHEETR][0];

    cfg.scanCount = jobject[SCANCOUNT][0];
    cfg.imageProcess.orentation = jobject[DOCORIENTATION][0];
    cfg.imageProcess.backRotate180 = jobject[BACKROTATE180][0];
    cfg.hardwareParam.doubleFeedDetection = jobject[ULTRADETECT][0];
    cfg.hardwareParam.bindingDetection = jobject[BINDINGDETECT][0];
    cfg.hardwareParam.skewDetection.enable = jobject[SKEWDENABLE][0];
    cfg.hardwareParam.skewDetection.level = jobject[SKEWLEVEL][0];

    return cfg;
}