#include "ScanConfig.h"
#include <sstream>
#include <unistd.h>


const char * PATH_FPAG_DUNNAN_CONFIG = "/usr/local/huago/dunnan_fpga.properties";
const char * PATH_FPAG_HUALING_CONFIG = "/usr/local/huago/hualing_fpga.properties";
//#define PATH_FPAG_CONFIG "/usr/local/huago/fpga.properties"
#define ETC_FPAG_CONFIG "/etc/fpga.properties"

Properties ScanConfig::fpgaProperties;
CaptureParams ScanConfig::captureParmars;

static const char *keys[] = {
	"fpga.correctColor.AExposureR", 
	"fpga.correctColor.AExposureG",
	"fpga.correctColor.AExposureB", 
	"fpga.correctColor.BExposureR", 
	"fpga.correctColor.BExposureG",
	"fpga.correctColor.BExposureB", 
	"fpga.correctColor.gainA",
	"fpga.correctColor.gainB",
	"fpga.correctColor.AOffset",
	"fpga.correctColor.BOffset",
	"fpga.correctGray.AExposureR",
	"fpga.correctGray.AExposureG",
	"fpga.correctGray.AExposureB",
	"fpga.correctGray.BExposureR",
	"fpga.correctGray.BExposureG",
	"fpga.correctGray.BExposureB",
	"fpga.correctGray.gainA",
	"fpga.correctGray.gainB",
	"fpga.correctGray.AOffset",
	"fpga.correctGray.BOffset", 
	"fpga.color.AExposureR", 
	"fpga.color.AExposureG", 
	"fpga.color.AExposureB", 
	"fpga.color.BExposureR", 
	"fpga.color.BExposureG", 
	"fpga.color.BExposureB", 
	"fpga.color.gainA", 
	"fpga.color.gainB", 
	"fpga.color.AOffset", 
	"fpga.color.BOffset", 
	"fpga.gray.AExposureR", 
	"fpga.gray.AExposureG", 
	"fpga.gray.AExposureB", 
	"fpga.gray.BExposureR", 
	"fpga.gray.BExposureG", 
	"fpga.gray.BExposureB", 
	"fpga.gray.gainA", 
	"fpga.gray.gainB",
	"fpga.gray.AOffset", 
	"fpga.gray.BOffset", 
	"fpga.correctColor.UVExposureA", 
	"fpga.correctGray.UVExposureB", 
	"fpga.color.UVExposureA", 
	"fpga.gray.UVExposureA", 
};

int parseInt(const std::string str){
	if(str.compare(0, 2, "0X") == 0 || str.compare(0, 2, "0x") == 0){
		return (int)std::strtol(str.c_str(),nullptr,16);
	}else{
		return std::atoi(str.c_str());
	}
}

void ScanConfig::parseIntArray(const std::string& str, std::string split,int* p, int size){
    int lastPosition = 0; 
    int index = -1; 
	int i = 0;
    while(-1 != (index=str.find(split , lastPosition)) && i < size) 
    { 
//        vecString.push_back(str.substr(lastPosition, index - lastPosition)); 
		*(p + i) = parseInt(str.substr(lastPosition, index - lastPosition));
        lastPosition = index + split.size();
		i ++;
    } 
    std::string lastStr = str.substr(lastPosition); 
    if ( !lastStr.empty() && i < size) 
    { 
		*(p + i) = parseInt(lastStr);
    } 
} 



ScanConfig::ScanConfig():cistype(CIS_T_S0,CIS_T_S1,CIS_T_S2,CIS_T_S3){
	
	if(cistype.GetCisType () == CISVendor::DUNNAN_CIS_V0)
	{
		PATH_FPAG_CONFIG = PATH_FPAG_DUNNAN_CONFIG;
		if(access(PATH_FPAG_CONFIG,F_OK) == -1){
		PATH_FPAG_CONFIG = "/usr/local/huago/fpga.properties";
		}
	}

    if(cistype.GetCisType () == CISVendor::HUALIN_CIS_V0)
	{
		PATH_FPAG_CONFIG = PATH_FPAG_HUALING_CONFIG;
		if(access(PATH_FPAG_CONFIG,F_OK) == -1){
		PATH_FPAG_CONFIG = "/usr/local/huago/fpga.properties";
		}
	}

	//printf("PATH_FPAG_CONFIG  == %s \r\n",PATH_FPAG_CONFIG);
	if(access(PATH_FPAG_CONFIG,F_OK) !=-1){
		fpgaProperties = PropertiesParser::Read(PATH_FPAG_CONFIG);
	}else{
		fpgaProperties = PropertiesParser::Read(ETC_FPAG_CONFIG);
		std::cout<<"error 88888888888888888888"<<std::endl;
	}
	std::cout << "fpgaProperties:" << fpgaProperties.GetProperty(std::string("fpga.").append("color").append(".gainB"), "200") << std::endl;
	parseCaptureParams();
}


ScanConfig::~ScanConfig(){
}

void ScanConfig::parseCaptureParams(){
	std::string str = fpgaProperties.GetProperty("fpga.correctColor.gainA", "50,50,50,50,50,50");
	 printf(" --------1111111111 strstrstr   =  %s \r\n",str.c_str());



	parseIntArray(str, std :: string(","), captureParmars.correctColorGain[0], 6);
	str = fpgaProperties.GetProperty("fpga.correctColor.gainB", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.correctColorGain[1], 6);
	
	str = fpgaProperties.GetProperty("fpga.correctColor.AOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.correctColorOffset[0], 6);
	str = fpgaProperties.GetProperty("fpga.correctColor.BOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.correctColorOffset[1], 6);
	
	str = fpgaProperties.GetProperty("fpga.correctGray.gainA", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.correctGrayGain[0], 6);
	str = fpgaProperties.GetProperty("fpga.correctGray.gainB", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.correctGrayGain[1], 6);

	str = fpgaProperties.GetProperty("fpga.correctGray.AOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.correctGrayOffset[0], 6);
	str = fpgaProperties.GetProperty("fpga.correctGray.BOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.correctGrayOffset[1], 6);

	str = fpgaProperties.GetProperty("fpga.color.gainA", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.colorGain[0], 6);
	str = fpgaProperties.GetProperty("fpga.color.gainB", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.colorGain[1], 6);

	str = fpgaProperties.GetProperty("fpga.color.AOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.colorOffset[0], 6);
	str = fpgaProperties.GetProperty("fpga.color.BOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.colorOffset[1], 6);

	str = fpgaProperties.GetProperty("fpga.gray.gainA", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.grayGain[0], 6);
	str = fpgaProperties.GetProperty("fpga.gray.gainB", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.grayGain[1], 6);

	str = fpgaProperties.GetProperty("fpga.gray.AOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.grayOffset[0], 6);
	str = fpgaProperties.GetProperty("fpga.gray.BOffset", "50,50,50,50,50,50");
	parseIntArray(str, std :: string(","), captureParmars.grayOffset[1], 6);

	str = fpgaProperties.GetProperty("fpga.correctColor.AExposureR", "200");
	captureParmars.correctColorExposure[0][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctColor.AExposureG", "200");
	captureParmars.correctColorExposure[0][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctColor.AExposureB", "200");
	captureParmars.correctColorExposure[0][2] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.correctColor.BExposureR", "200");
	captureParmars.correctColorExposure[1][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctColor.BExposureG", "200");
	captureParmars.correctColorExposure[1][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctColor.BExposureB", "200");
	captureParmars.correctColorExposure[1][2] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.correctGray.AExposureR", "200");
	captureParmars.correctGrayExposure[0][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctGray.AExposureG", "200");
	captureParmars.correctGrayExposure[0][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctGray.AExposureB", "200");
	captureParmars.correctGrayExposure[0][2] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.correctGray.BExposureR", "200");
	captureParmars.correctGrayExposure[1][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctGray.BExposureG", "200");
	captureParmars.correctGrayExposure[1][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctGray.BExposureB", "200");
	captureParmars.correctGrayExposure[1][2] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.color.AExposureR", "200");
	captureParmars.colorExposure[0][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.color.AExposureG", "200");
	captureParmars.colorExposure[0][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.color.AExposureB", "200");
	captureParmars.colorExposure[0][2] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.color.BExposureR", "200");
	captureParmars.colorExposure[1][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.color.BExposureG", "200");
	captureParmars.colorExposure[1][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.color.BExposureB", "200");
	captureParmars.colorExposure[1][2] = parseInt(str);

	
	str = fpgaProperties.GetProperty("fpga.gray.AExposureR", "200");
	captureParmars.grayExposure[0][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.gray.AExposureG", "200");
	captureParmars.grayExposure[0][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.gray.AExposureB", "200");
	captureParmars.grayExposure[0][2] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.gray.BExposureR", "200");
	captureParmars.grayExposure[1][0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.gray.BExposureG", "200");
	captureParmars.grayExposure[1][1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.gray.BExposureB", "200");
	captureParmars.grayExposure[1][2] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.correctColor.UVExposureA", "200");
	captureParmars.uvCorrectColorExposure[0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctColor.UVExposureB", "200");
	captureParmars.uvCorrectColorExposure[1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.color.UVExposureA", "200");
	captureParmars.uvColorExposure[0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.color.UVExposureB", "200");
	captureParmars.uvColorExposure[1] = parseInt(str);

	str = fpgaProperties.GetProperty("fpga.correctGray.UVExposureA", "0");
	captureParmars.uvCorrectGrayExposure[0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.correctGray.UVExposureB", "0");
	captureParmars.uvCorrectGrayExposure[1] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.gray.UVExposureA", "0");
	captureParmars.uvGrayExposure[0] = parseInt(str);
	str = fpgaProperties.GetProperty("fpga.gray.UVExposureB", "0");
	captureParmars.uvGrayExposure[1] = parseInt(str);

}


std::string parseString(int value){
	std::string s;
	std::stringstream ss;
	ss << value;
 	ss >> s;
	return s;
}

std::string parseArrayString(int *array, int len){
	std::string s;
	for(int i= 0; i < len; i ++){
		s.append(parseString(array[i]));
		if(i < len - 1)s.append(",");
	}
	return s;
}


//δʹ��
void ScanConfig::modifyCaptureParams(const char * key, const char * value){
	fpgaProperties.AddProperty(key, value);
	parseCaptureParams();
	PropertiesParser::Write(PATH_FPAG_CONFIG, fpgaProperties);
}

std::string ScanConfig::getCaptureParmas(std::string key){
	std::string ret = fpgaProperties.GetProperty(key, "");
	if(ret.length() == 0){
		fpgaProperties = PropertiesParser::Read(PATH_FPAG_CONFIG);
		ret = fpgaProperties.GetProperty(key, "");
	}
	return ret;
}

void ScanConfig::save(){
	int *p = (int *)&captureParmars;
	for(int i = 0; i < 4;  i ++ ){
		int *params = p + 30 * i;		
		for(int j = 0; j < 6; j ++ ){
			fpgaProperties.AddProperty(keys[10 * i + j ], parseString(params[j]));
		}
		for(int k = 0; k < 4; k ++ ){
			fpgaProperties.AddProperty(keys[10 * i + k + 6],  parseArrayString(&params[6 + 6 * k], 6));
		}
	}
	PropertiesParser::Write(PATH_FPAG_CONFIG, fpgaProperties);
}


//�����޸�
void ScanConfig::writeParamars(std::string type, int * params){
	if(type.compare("color") == 0){
		memcpy(captureParmars.colorExposure, params, 6 * sizeof(int));
		memcpy(captureParmars.colorGain, &params[6], 12 * sizeof(int));
		memcpy(captureParmars.colorOffset, &params[18], 12 * sizeof(int));
	}else if(type.compare("correctColor") == 0){
		memcpy(captureParmars.correctColorExposure, params, 6 * sizeof(int));
		memcpy(captureParmars.correctColorGain, &params[6], 12 * sizeof(int));
		memcpy(captureParmars.correctColorOffset, &params[18], 12 * sizeof(int));
	}else if(type.compare("gray") == 0){
		memcpy(captureParmars.grayExposure, params, 6 * sizeof(int));
		memcpy(captureParmars.grayGain, &params[6], 12 * sizeof(int));
		memcpy(captureParmars.grayOffset, &params[18], 12 * sizeof(int));
	}else if(type.compare("correctGray") == 0){
		memcpy(captureParmars.correctGrayExposure, params, 6 * sizeof(int));
		memcpy(captureParmars.correctGrayGain, &params[6], 12 * sizeof(int));
		memcpy(captureParmars.correctGrayOffset, &params[18], 12 * sizeof(int));
	}
	
	fpgaProperties.AddProperty("fpga." + type + ".AExposureR", parseString(params[0]));
	fpgaProperties.AddProperty("fpga." + type + ".AExposureG", parseString(params[1]));
	fpgaProperties.AddProperty("fpga." + type + ".AExposureB", parseString(params[2]));
	fpgaProperties.AddProperty("fpga." + type + ".BExposureR", parseString(params[3]));
	fpgaProperties.AddProperty("fpga." + type + ".BExposureG", parseString(params[4]));
	fpgaProperties.AddProperty("fpga." + type + ".BExposureB", parseString(params[5]));

	fpgaProperties.AddProperty("fpga." + type + ".gainA", parseArrayString(&params[6], 6));
	fpgaProperties.AddProperty("fpga." + type + ".gainB", parseArrayString(&params[12], 6));
	fpgaProperties.AddProperty("fpga." + type + ".AOffset", parseArrayString(&params[18], 6));
	fpgaProperties.AddProperty("fpga." + type + ".BOffset", parseArrayString(&params[24], 6));

	PropertiesParser::Write(PATH_FPAG_CONFIG, fpgaProperties);
}