#include "HGPdtToolDbImpl.hpp"
#include "HGPdtToolDb.h"
#include "base/HGInc.h"
#include "HGString.h"

const HGChar* INITTIAL_INSPECTION[] =
{
	"dial_switch",
	"rocker_switch",
	"boot_status",
	"lcd_display",
	"clear_paper_path",
	"key_function",
	"counting_mode",
	"skew_detection",
	"separater_motor",
	"cis_original_image",
	"host_fan",
	"ultrasonic_module",
	"led_light",
	"reset",
	"paper_feed",
	"cover_sensor",
	"scanning_sensor"
};

const HGChar* INITTIAL_INSPECTION_CN[] =
{
	"拨码开关校验",
	"检查船型开关功能",
	"设备上电并观察开机状态",
	"检查液晶显示",
	"清理纸道功能确认",
	"按键功能检测",
	"计数模式检测",
	"歪斜检测",
	"分纸电机检测",
	"CIS原图初检",
	"主机风扇功能检测",
	"超声波模块检验",
	"LED灯状态检查",
	"复位检查",
	"走纸检查",
	"开盖传感器检查",
	"扫描传感器检查"
};

const HGChar* IMAGE_INSPECTION[] =
{
	"configure_speed_mode",
	"place_correction_paper",
	"auto_flat_field",
	"reboot_device",
	"image_quality",
	"colorcard_imaging_quality",
	"colorcard_bias_imaging_quality",
	"clarity_quality",
	"distortion",
	"dormancy",
	"skew_gear",
	"paper_separater_strengch",
	"mech_paper_feeding_inclination"
};

const HGChar* IMAGE_INSPECTION_CN[] =
{
	"配置速度模式",
	"放置校正纸",
	"自动平场校正",
	"重启设备",
	"扫描图像质量确认",
	"色卡纸成像质量评估",
	"色卡纸偏色成像质量评估",
	"清晰度质量评估",
	"畸变修正",
	"设置休眠",
	"歪斜挡位检测",
	"分纸强度检测",
	"机械走纸倾斜检测"
};

const HGChar* PRESSURE_INSPECTION[] =
{
	"single_page_test_1",
	"single_page_test_2",
	"single_page_test_3",
	"pressure_test",
	"clear_roller_count"
};

const HGChar* PRESSURE_INSPECTION_CN[] =
{
	"单张测试1",
	"单张测试2",
	"单张测试3",
	"压力测试2轮",
	"清除滚轴计数"
};


HGPdtToolDbUserMgrImpl::HGPdtToolDbUserMgrImpl()
{
	m_sql = NULL;
	m_userName.clear();
	m_deviceList.clear();
}

HGPdtToolDbUserMgrImpl::~HGPdtToolDbUserMgrImpl()
{

}

HGResult HGPdtToolDbUserMgrImpl::Create(const HGChar* host, HGUShort port, const HGChar* userName, const HGChar* pwd)
{
	if (NULL != m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL* sql = mysql_init(NULL);
	if (NULL == sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == mysql_real_connect(sql, host, userName, pwd, "huago_production_tool", port, NULL, 0))
	{
		mysql_close(sql);
		return HGBASE_ERR_FAIL;
	}

	if (0 != CreateUserConfigTable(sql, userName) || 0 != CreateMainTestTable(sql)
		|| 0 != CreateInitInspTestTable(sql) || 0 != CreateInitInspDescTable(sql)
		|| 0 != CreateImgInspTestTable(sql) || 0 != CreateImgInspDescTable(sql)
		|| 0 != CreatePreInspTestTable(sql) || 0 != CreatePreInspDescTable(sql))
	{
		mysql_close(sql);
		return HGBASE_ERR_FAIL;
	}

	m_sql = sql;
	m_userName = userName;
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::Destroy()
{
	if (NULL == m_sql || !m_deviceList.empty())
	{
		return HGBASE_ERR_FAIL;
	}

	mysql_close(m_sql);
	m_sql = NULL;
	m_userName.clear();
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetUserType(HGUInt* userType)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userType)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	*userType = HGPDTTOOLDB_USERTYPE_NORMAL;
	if (0 == strcmp(m_userName.c_str(), "root"))
		*userType = HGPDTTOOLDB_USERTYPE_ROOT;
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetUserName(HGChar* userName, HGUInt maxLen)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (maxLen < m_userName.size() + 1)
	{
		return HGBASE_ERR_FAIL;
	}

	strcpy(userName, m_userName.c_str());
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetUserList(HGChar** userNameList, HGUInt maxLen, HGUInt* count)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userNameList || 0 == maxLen || NULL == count)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "select user, host from mysql.user");
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	*count = 0;
	MYSQL_ROW row = NULL;
	while ((row = mysql_fetch_row(sqlRes)) != NULL)
	{
		if (*count >= maxLen)
		{
			break;
		}

		assert(NULL != row[0] && NULL != row[1]);
		if (0 == strcmp(row[1], "%"))
		{
			userNameList[*count] = (HGChar*)malloc(strlen(row[0]) + 1);
			assert(NULL != userNameList[*count]);
			strcpy(userNameList[*count], row[0]);
			++(*count);
		}
	}

	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::ReleaseUserList(HGChar** userNameList, HGUInt count)
{
	if (NULL == userNameList || 0 == count)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	for (HGUInt i = 0; i < count; ++i)
	{
		free(userNameList[i]);
	}

	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::CreateUser(const HGChar* userName, const HGChar* defPwd)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName || NULL == defPwd || 0 == *defPwd)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	if (0 == strcmp(userName, "root"))
	{
		return HGBASE_ERR_FAIL;
	}

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "create user '%s'@'%%' identified by '%s';", userName, defPwd);
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}
	
	sprintf(sqlCmd, "grant all privileges on huago_production_tool.* to '%s'@'%%' with grant option;", userName);
	ret = mysql_query(m_sql, sqlCmd);
	assert(0 == ret);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::DestroyUser(const HGChar* userName)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	if (0 == strcmp(userName, "root"))
	{
		return HGBASE_ERR_FAIL;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "drop user '%s'@'%%';", userName);
	int ret = mysql_query(m_sql, sqlCmd);
	return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbUserMgrImpl::SetPassword(const HGChar* userName, const HGChar* pwd)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName || NULL == pwd || 0 == *pwd)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "set password for '%s'@'%%' = password('%s');", userName, pwd);
	int ret = mysql_query(m_sql, sqlCmd);
	return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbUserMgrImpl::ModifyPassword(const HGChar* newPwd)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == newPwd || 0 == *newPwd)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "set password for '%s'@'%%' = password('%s');", m_userName.c_str(), newPwd);
	int ret = mysql_query(m_sql, sqlCmd);
	return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbUserMgrImpl::Export(const HGChar* xlsPath)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == xlsPath || 0 == *xlsPath)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	std::string cmd = "select main_test.sn";
	cmd += ", main_test.create_time";
	cmd += ", main_test.create_user";
	cmd += ", main_test.last_modify_time";
	cmd += ", main_test.last_modify_user";
	cmd += ", main_test.current_entry";

	for (int i = 0; i < sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*); ++i)
	{
		cmd += ", initial_inspection_test.";
		cmd += INITTIAL_INSPECTION[i];
		cmd += ", initial_inspection_desc.";
		cmd += INITTIAL_INSPECTION[i];
	}
	for (int i = 0; i < sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*); ++i)
	{
		cmd += ", image_inspection_test.";
		cmd += IMAGE_INSPECTION[i];
		cmd += ", image_inspection_desc.";
		cmd += IMAGE_INSPECTION[i];
	}
	for (int i = 0; i < sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*); ++i)
	{
		cmd += ", pressure_inspection_test.";
		cmd += PRESSURE_INSPECTION[i];
		cmd += ", pressure_inspection_desc.";
		cmd += PRESSURE_INSPECTION[i];
	}

	cmd += " from main_test";
	cmd += " inner join initial_inspection_test on main_test.sn = initial_inspection_test.sn";
	cmd += " inner join initial_inspection_desc on main_test.sn = initial_inspection_desc.sn";
	cmd += " inner join image_inspection_test on main_test.sn = image_inspection_test.sn";
	cmd += " inner join image_inspection_desc on main_test.sn = image_inspection_desc.sn";
	cmd += " inner join pressure_inspection_test on main_test.sn = pressure_inspection_test.sn";
	cmd += " inner join pressure_inspection_desc on main_test.sn = pressure_inspection_desc.sn";
	cmd += ";";

	int ret = mysql_query(m_sql, cmd.c_str());
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	FILE* file = fopen(xlsPath, "wb");
	if (NULL == file)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	const HGChar* MAIN_TEST_CN[] = {"序列号", "创建时间", "创建用户", "最后修改时间", "最后修改用户", "当前测试项"};
	for (int i = 0; i < sizeof(MAIN_TEST_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)MAIN_TEST_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
	}
	for (int i = 0; i < sizeof(INITTIAL_INSPECTION_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)INITTIAL_INSPECTION_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
		std::string descTitle = (std::string)INITTIAL_INSPECTION_CN[i] + "异常说明" + "\t";
		fwrite(descTitle.c_str(), 1, descTitle.size(), file);
	}
	for (int i = 0; i < sizeof(IMAGE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)IMAGE_INSPECTION_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
		std::string descTitle = (std::string)IMAGE_INSPECTION_CN[i] + "异常说明" + "\t";
		fwrite(descTitle.c_str(), 1, descTitle.size(), file);
	}
	for (int i = 0; i < sizeof(PRESSURE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)PRESSURE_INSPECTION_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
		std::string descTitle = (std::string)PRESSURE_INSPECTION_CN[i] + "异常说明" + "\t";
		fwrite(descTitle.c_str(), 1, descTitle.size(), file);
	}
	fwrite("\n", 1, strlen("\n"), file);

	MYSQL_ROW row = NULL;
	while ((row = mysql_fetch_row(sqlRes)) != NULL)
	{
		unsigned int cols = mysql_num_fields(sqlRes);
		for (unsigned int i = 0; i < cols; ++i)
		{
			std::string value;

			if (i < 5)
			{
				assert(NULL != row[i]);
				value = row[i];
			}
			else if (i == 5)
			{
				assert(NULL != row[i]);
				value = GetEntryNameCnStr((HGUInt)atoll(row[i]));
			}
			else
			{
				if (0 == (i - 6) % 2)
				{
					assert(NULL != row[i]);
					const HGChar* ENTRY_STATUS_CN[] = { "未测试", "不通过", "不支持", "通过" };
					value = ENTRY_STATUS_CN[(HGUInt)atoll(row[i])];
				}
				else
				{
					if (NULL != row[i])
					{
						value = Utf8ToStdString(row[i]);
					}
				}
			}

			value += "\t";
			fwrite(value.c_str(), 1, value.size(), file);
		}

		fwrite("\n", 1, strlen("\n"), file);
	}

	fclose(file);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetConfig(const HGChar* key, HGChar* value, HGUInt maxLen)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == key || 0 == *key || NULL == value || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select config_value from %s_config where config_key = '%s';", m_userName.c_str(), key);
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	if (NULL == row[0])
	{
		*value = '\0';
		mysql_free_result(sqlRes);
		return HGBASE_ERR_OK;
	}

	if (maxLen < strlen(row[0]) + 1)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	strcpy(value, row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::SetConfig(const HGChar* key, const HGChar* value)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == key || 0 == *key)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "insert into %s_config (config_key, config_value) values ('%s', '%s')", 
		m_userName.c_str(), key, (NULL != value) ? value : "");
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 == ret)
	{
		return HGBASE_ERR_OK;
	}

	if (1062 == mysql_errno(m_sql))
	{
		sprintf(sqlCmd, "update %s_config set config_value = '%s' where config_key = '%s'",
			m_userName.c_str(), (NULL != value) ? value : "", key);
		int ret = mysql_query(m_sql, sqlCmd);
		return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
	}

	return HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbUserMgrImpl::OpenDevice(const HGChar* sn, class HGPdtToolDbDeviceImpl** deviceImpl)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == sn || 0 == *sn || NULL == deviceImpl)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	// 事务开始
	int ret = mysql_query(m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	if (0 != InitMainTestItem(sn) || 0 != InitInspTestItem("initial_inspection_test", sn)
		|| 0 != InitInspTestItem("initial_inspection_desc", sn) || 0 != InitInspTestItem("image_inspection_test", sn)
		|| 0 != InitInspTestItem("image_inspection_desc", sn) || 0 != InitInspTestItem("pressure_inspection_test", sn)
		|| 0 != InitInspTestItem("pressure_inspection_desc", sn))
	{
		mysql_query(m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_sql, "commit;");
	assert(0 == ret);

	*deviceImpl = new HGPdtToolDbDeviceImpl(this, sn);
	m_deviceList.push_back(*deviceImpl);
	return HGBASE_ERR_OK;
}

void HGPdtToolDbUserMgrImpl::RemoveDevice(class HGPdtToolDbDeviceImpl* deviceImpl)
{
	std::list<class HGPdtToolDbDeviceImpl*>::iterator iter;
	for (iter = m_deviceList.begin(); iter != m_deviceList.end(); ++iter)
	{
		if (deviceImpl == *iter)
		{
			m_deviceList.erase(iter);
			break;
		}
	}
}

const HGChar* HGPdtToolDbUserMgrImpl::GetEntryNameCnStr(HGUInt entryName)
{
	if (0 == entryName)
		return "未开始测试";
	else if (0xFFFFFFFF == entryName)
		return "已完成测试";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return INITTIAL_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return IMAGE_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return PRESSURE_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1];
	return NULL;
}

int HGPdtToolDbUserMgrImpl::CreateUserConfigTable(MYSQL* sql, const HGChar* user)
{
	assert(NULL != sql);
	assert(NULL != user && 0 != *user);

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "create table if not exists %s_config (config_key varchar(40) not null primary key, config_value text)", user);
	return mysql_query(sql, sqlCmd);
}

int HGPdtToolDbUserMgrImpl::CreateMainTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists main_test (sn varchar(20) not null primary key";
	cmd += ", create_time datetime";
	cmd += ", create_user text not null";
	cmd += ", last_modify_time datetime";
	cmd += ", last_modify_user text not null";
	cmd += ", current_entry int unsigned default 0";
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateInitInspTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists initial_inspection_test (sn varchar(20) not null primary key";
	int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += INITTIAL_INSPECTION[i];
		cmd += " tinyint unsigned default 0";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateInitInspDescTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists initial_inspection_desc (sn varchar(20) not null primary key";
	int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += INITTIAL_INSPECTION[i];
		cmd += " text";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateImgInspTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists image_inspection_test (sn varchar(20) not null primary key";
	int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += IMAGE_INSPECTION[i];
		cmd += " tinyint unsigned default 0";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateImgInspDescTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists image_inspection_desc (sn varchar(20) not null primary key";
	int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += IMAGE_INSPECTION[i];
		cmd += " text";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreatePreInspTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists pressure_inspection_test (sn varchar(20) not null primary key";
	int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += PRESSURE_INSPECTION[i];
		cmd += " tinyint unsigned default 0";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreatePreInspDescTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists pressure_inspection_desc (sn varchar(20) not null primary key";
	int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += PRESSURE_INSPECTION[i];
		cmd += " text";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::InitMainTestItem(const HGChar* sn)
{
	assert(NULL != sn && 0 != *sn && NULL != m_sql);

	std::string title = "(sn, create_time, create_user, last_modify_time, last_modify_user)";
	std::string value = "('" + (std::string)sn + "', now(), '" + m_userName + "', now(), '" + m_userName + "')";
	std::string cmd = (std::string)"insert into main_test " + title + " values " + value + ";";
	int ret = mysql_query(m_sql, cmd.c_str());
	return (1062 == mysql_errno(m_sql)) ? 0 : ret;
}

int HGPdtToolDbUserMgrImpl::InitInspTestItem(const HGChar* tableName, const HGChar* sn)
{
	assert(NULL != tableName && 0 != *tableName);
	assert(NULL != sn && 0 != *sn && NULL != m_sql);

	char sqlCmd[1024];
	sprintf(sqlCmd, "insert into %s (sn) values ('%s');", tableName, sn);
	int ret = mysql_query(m_sql, sqlCmd);
	return (1062 == mysql_errno(m_sql)) ? 0 : ret;
}


HGPdtToolDbDeviceImpl::HGPdtToolDbDeviceImpl(class HGPdtToolDbUserMgrImpl* userMgr, const HGChar* sn)
{
	m_userMgr = userMgr;
	m_sn = sn;
}

HGPdtToolDbDeviceImpl::~HGPdtToolDbDeviceImpl()
{
	m_userMgr->RemoveDevice(this);
}

HGResult HGPdtToolDbDeviceImpl::GetCurrEntry(HGUInt* entryName)
{
	if (NULL == entryName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select current_entry from main_test where sn = '%s';", m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	assert(NULL != row[0]);
	*entryName = (HGUInt)atoll(row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::SetCurrEntry(HGUInt entryName)
{
	if (0 != entryName && 0xFFFFFFFF != entryName)
	{
		const HGChar* entryNameStr = GetEntryNameStr(entryName);
		if (NULL == entryNameStr)
		{
			return HGBASE_ERR_FAIL;
		}
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "update main_test set current_entry = %u, last_modify_time = now(), last_modify_user = '%s' where sn = '%s';", 
		entryName, m_userMgr->m_userName.c_str(), m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbDeviceImpl::GetEntryStatus(HGUInt entryName, HGUInt* entryStatus)
{
	if (NULL == entryStatus)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetTestTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from %s where sn = '%s';", entryNameStr, tableName, m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES *sqlRes = mysql_use_result(m_userMgr->m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	assert(NULL != row[0]);
	*entryStatus = (HGUInt)atoll(row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::SetEntryStatus(HGUInt entryName, HGUInt entryStatus)
{
	if (entryStatus > HGPDTTOOLDB_ENTRYSTATUS_PASS)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetTestTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };

	// 事务开始
	int ret = mysql_query(m_userMgr->m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update %s set %s = %u where sn = '%s';", tableName, entryNameStr, entryStatus, m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';", 
		m_userMgr->m_userName.c_str(), m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_userMgr->m_sql, "commit;");
	assert(0 == ret);

	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::GetEntryExcepDesc(HGUInt entryName, HGChar* excepDesc, HGUInt maxLen)
{
	if (NULL == excepDesc || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetDescTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from %s where sn = '%s';", entryNameStr, tableName, m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	if (NULL == row[0])
	{
		*excepDesc = '\0';
		mysql_free_result(sqlRes);
		return HGBASE_ERR_OK;
	}

	if (maxLen < strlen(row[0]) + 1)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	strcpy(excepDesc, row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::SetEntryExcepDesc(HGUInt entryName, const HGChar* excepDesc)
{
	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetDescTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };

	// 事务开始
	int ret = mysql_query(m_userMgr->m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update %s set %s = '%s' where sn = '%s';", 
		tableName, entryNameStr, (NULL != excepDesc) ? excepDesc : "", m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
		m_userMgr->m_userName.c_str(), m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_userMgr->m_sql, "commit;");
	assert(0 == ret);

	return HGBASE_ERR_OK;
}

const HGChar* HGPdtToolDbDeviceImpl::GetEntryNameStr(HGUInt entryName)
{
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return INITTIAL_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return PRESSURE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1];
	return NULL;
}

const HGChar* HGPdtToolDbDeviceImpl::GetTestTableName(HGUInt entryName)
{
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return "initial_inspection_test";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return "image_inspection_test";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return "pressure_inspection_test";
	return NULL;
}

const HGChar* HGPdtToolDbDeviceImpl::GetDescTableName(HGUInt entryName)
{
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return "initial_inspection_desc";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return "image_inspection_desc";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return "pressure_inspection_desc";
	return NULL;
}