#include "CorrectParam.h"
#include <iostream>
#include <fstream>
#include <sys/stat.h>
#include <sstream>
#include <iomanip>
#include "commondef.h"

using namespace std;

#define JSONPATH "/usr/local/huago/cameraparam.json"

#define TEXTLUT200COLORPATH "/usr/local/huago/Textlut200clr.bmp"
#define LUT200COLORPATH "/usr/local/huago/lut200clr.bmp"
#define LUT200_COLOR_BLACKPATH "/usr/local/huago/lut200clrbw.bmp"
#define LUT200_COLOR_WHITEPATH "/usr/local/huago/lut200clrwhite.bmp"

#define TEXTLUT200GRAYPATH "/usr/local/huago/Textlut200gray.bmp"
#define LUT200GRAYPATH "/usr/local/huago/lut200gray.bmp"
#define LUT200_GRAY_BLACKPATH "/usr/local/huago/lut200graybw.bmp"
#define LUT200_GRAY_WHITEPATH "/usr/local/huago/lut200graywhite.bmp"

#define TEXTLUT300COLORPATH "/usr/local/huago/Textlut300clr.bmp"
#define LUT300COLORPATH "/usr/local/huago/lut300clr.bmp"
#define LUT300_COLOR_BLACKPATH "/usr/local/huago/lut300clrbw.bmp"
#define LUT300_COLOR_WHITEPATH "/usr/local/huago/lut300clrwhite.bmp"

#define TEXTLUT300GRAYPATH "/usr/local/huago/Textlut300gray.bmp"
#define LUT300GRAYPATH "/usr/local/huago/lut300gray.bmp"
#define LUT300_GRAY_BLACKPATH "/usr/local/huago/lut300graybw.bmp"
#define LUT300_GRAY_WHITEPATH "/usr/local/huago/lut300graywhite.bmp"

#define LUT600COLORPATH "/usr/local/huago/lut600clr.bmp"
#define TEXTLUT600COLORPATH "/usr/local/huago/Textlut600clr.bmp"
#define LUT600_COLOR_BLACKPATH "/usr/local/huago/lut600clrbw.bmp"
#define LUT600_COLOR_WHITEPATH "/usr/local/huago/lut600clrwhite.bmp"

#define LUT600GRAYPATH "/usr/local/huago/lut600gray.bmp"
#define TEXTLUT600GRAYPATH "/usr/local/huago/Textlut600gray.bmp"
#define LUT600_GRAY_BLACKPATH "/usr/local/huago/lut600graybw.bmp"
#define LUT600_GRAY_WHITEPATH "/usr/local/huago/lut600graywhite.bmp"

CorrectParam::CorrectParam()
{
	initdefaultpapram();
}

CorrectParam::~CorrectParam()
{
}

std::vector<FPGAConfigParam> CorrectParam::GetCorrectParams()
{
	std::ifstream i(JSONPATH);
	json j;
	i >> j;
	i.close();
	std::vector<FPGAConfigParam> vct_param;
	for (json::iterator it = j.begin(); it != j.end(); ++it)
	{
		auto tmv = it.value();
		FPGAConfigParam param;
		from_json(tmv, param);
		vct_param.push_back(param);
	}
	return vct_param;
}

FPGAConfigParam CorrectParam::GetFpgaparam(int dpi,int mode)
{
	FPGAConfigParam param;
	auto filejson = GetCorrectParams();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == mode) &&
			(filejson[i].DpiMode == dpi))
		{
			param = filejson[i];
			break;
		}
	}
	return param;
}

void CorrectParam::SaveCorrectParam(FPGAConfigParam& parms)
{
	auto filejson = GetCorrectParams();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == parms.ColorMode) &&
			(filejson[i].DpiMode == parms.DpiMode))
		{
			memcpy(filejson[i].ExposureB, parms.ExposureB, sizeof(parms.ExposureB));
			memcpy(filejson[i].ExposureF, parms.ExposureF, sizeof(parms.ExposureF));
			memcpy(filejson[i].GainB, parms.GainB, sizeof(parms.GainB));
			memcpy(filejson[i].GainF, parms.GainF, sizeof(parms.GainF));
			memcpy(filejson[i].OffsetB, parms.OffsetB, sizeof(parms.OffsetB));
			memcpy(filejson[i].OffsetF, parms.OffsetF, sizeof(parms.OffsetF));
			filejson[i].LutPath = parms.LutPath;
			filejson[i].TextLutPath = parms.TextLutPath;
			filejson[i].Flat_BwPath = parms.Flat_BwPath;
			filejson[i].Flat_WhitePath = parms.Flat_WhitePath;
			filejson[i].Sp = parms.Sp;
			filejson[i].HRatio = parms.HRatio;
			filejson[i].VRatio = parms.VRatio;
			break;
		}
	}
	json j = json::array();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		json t_j;
		to_json(t_j, filejson[i]);
		j.push_back(t_j);
	}
	ofstream ofs(JSONPATH);
	ofs << std::setw(4) << j << std::endl;
	ofs.close();
}

void CorrectParam::initdefaultpapram()
{
	struct stat buff;
	if (stat(JSONPATH, &buff) != 0)//存在
	{
		json js = json::array();
		{
			FPGAConfigParam param;
			json t_j;

			//彩色 300 dpi
			param.ColorMode = 1;//彩色
			param.DpiMode = 2;//300 dpi
			param.MaxBright = 200;
			param.MaxExp = 1100;
			param.HRatio = 1065353216;
			param.VRatio = 1065353216;
			param.LutPath = LUT300COLORPATH;
			param.TextLutPath = TEXTLUT300COLORPATH;
			param.Flat_BwPath = LUT300_COLOR_BLACKPATH;
			param.Flat_WhitePath = LUT300_COLOR_WHITEPATH;
			param.Sp = 1200;
			for (size_t i = 0; i < 6; i++)
			{
				if(i<3)
					param.ExposureB[i] = param.ExposureF[i] = 700;//1500
				param.GainF[i] = param.GainB[i] = 170;
				param.OffsetF[i] = param.OffsetB[i] = 125;

			}
			to_json(t_j, param);
			js.push_back(t_j);

			//灰度 300 dpi
			param.ColorMode = 0;//灰度
			param.MaxBright = 220;
			param.LutPath = LUT300GRAYPATH;
			param.TextLutPath = TEXTLUT300GRAYPATH;
			param.Flat_BwPath = LUT300_GRAY_BLACKPATH;
			param.Flat_WhitePath = LUT300_GRAY_WHITEPATH;
			to_json(t_j, param);
			js.push_back(t_j);

			//彩色 200 dpi
			param.MaxBright = 200;
			param.ColorMode = 1;//彩色
			param.DpiMode = 1;//200 dpi
			param.LutPath = LUT200COLORPATH;
			param.TextLutPath = TEXTLUT200COLORPATH;
			param.Flat_BwPath = LUT200_COLOR_BLACKPATH;
			param.Flat_WhitePath = LUT200_COLOR_WHITEPATH;
			for (size_t i = 0; i < 6; i++)
			{
				if(i<3)
					param.ExposureB[i] = param.ExposureF[i] = 650;//1500
				param.GainF[i] = param.GainB[i] = 170;
				param.OffsetF[i] = param.OffsetB[i] = 125;
			}
			to_json(t_j, param);
			js.push_back(t_j);

			//灰度 200dpi
			param.MaxBright = 220;
			param.ColorMode = 0;//灰度
			param.LutPath = LUT200GRAYPATH;
			param.TextLutPath = TEXTLUT200GRAYPATH;
			param.Flat_BwPath = LUT200_GRAY_BLACKPATH;
			param.Flat_WhitePath = LUT200_GRAY_WHITEPATH;
			to_json(t_j, param);
			js.push_back(t_j);

			//彩色 600 dpi
			param.MaxBright = 200;
			param.ColorMode = 1;//彩色
			param.DpiMode = 0x03;//200 dpi
			param.LutPath = LUT600COLORPATH;
			param.TextLutPath = TEXTLUT600COLORPATH;
			param.Flat_BwPath = LUT600_COLOR_BLACKPATH;
			param.Flat_WhitePath = LUT600_COLOR_WHITEPATH;
			for (size_t i = 0; i < 6; i++)
			{
				if(i<3)
					param.ExposureB[i] = param.ExposureF[i] = 1350;//1500
				param.GainF[i] = param.GainB[i] = 170;
				param.OffsetF[i] = param.OffsetB[i] = 125;

			}
			to_json(t_j, param);
			js.push_back(t_j);


			//灰度 600dpi
			param.MaxBright = 220;
			param.ColorMode = 0;//灰度
			param.LutPath = LUT600GRAYPATH;
			param.TextLutPath = TEXTLUT600GRAYPATH;
			param.Flat_BwPath = LUT600_GRAY_BLACKPATH;
			param.Flat_WhitePath = LUT600_GRAY_WHITEPATH;
			to_json(t_j, param);
			js.push_back(t_j);

			std::ofstream ofs(JSONPATH);
			ofs << std::setw(4) << js << std::endl;
			ofs.close();
		}
	}
}

void CorrectParam::to_json(json& j, FPGAConfigParam& param)
{
	j = json{ {"ExposureF",param.ExposureF},
				{"GainF",param.GainF},
				{"OffsetF",param.OffsetF},
				{"ExposureB",param.ExposureB},
				{"GainB",param.GainB},
				{"OffsetB",param.OffsetB},
				{"DpiMode",param.DpiMode},
				{"ColorMode",param.ColorMode},
				{"MaxBright",param.MaxBright},
				{"MaxExp",param.MaxExp},
				{"Sp",param.Sp},
				{"HRatio",param.HRatio},
				{"VRatio",param.VRatio},
				{"LutPath",param.LutPath},
				{"TextLutPath",param.TextLutPath},
				{"FlatBlackPath",param.Flat_BwPath},
				{"FlatWhitePath",param.Flat_WhitePath}
	};
}

void CorrectParam::from_json(json& j, FPGAConfigParam& param)
{
	j.at("ExposureF").get_to(param.ExposureF);
	j.at("GainF").get_to(param.GainF);
	j.at("OffsetF").get_to(param.OffsetF);
	j.at("ExposureB").get_to(param.ExposureB);
	j.at("GainB").get_to(param.GainB);
	j.at("OffsetB").get_to(param.OffsetB);
	j.at("DpiMode").get_to(param.DpiMode);
	j.at("ColorMode").get_to(param.ColorMode);
	j.at("MaxBright").get_to(param.MaxBright);
	j.at("MaxExp").get_to(param.MaxExp);
	j.at("Sp").get_to(param.Sp);
	j.at("HRatio").get_to(param.HRatio);
	j.at("VRatio").get_to(param.VRatio);
	j.at("LutPath").get_to(param.LutPath);
	j.at("TextLutPath").get_to(param.TextLutPath);
	j.at("FlatBlackPath").get_to(param.Flat_BwPath);
	j.at("FlatWhitePath").get_to(param.Flat_WhitePath);
}