// transferServiceExe.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "transferServiceExe.h"
#include "json/json.h"

int _tmain(int argc, CHAR* argv[])
{
	printf("start transferServiceExe\n");
	if (argc <= 1) {
		printf("exit \n");
		return 1;
	}

	for (int i = 0; i < argc; i++){
		printf("%s ", argv[i]);
	}
	printf("\n");

	if (strcmp(argv[1], "readWeight") == 0){
		readWeight(argv[2], atoi(argv[3]), atoi(argv[4]), atoi(argv[5]), atoi(argv[6]));
	}
	else if (strcmp(argv[1], "manualTrigger") == 0) {
		manualTrigger(argv[2], atoi(argv[3]));
	}
	else if (strcmp(argv[1], "captureImageV2") == 0) {
		captureImageV2(argv[2], argv[3], atoi(argv[4]), argv[5], argv[6]);
	}
	else if (strcmp(argv[1], "displayInfoV2") == 0) {
		displayInfoV2(argv[2], atoi(argv[3]), argv[4], argv[5], argv[6], atoi(argv[7]));
	}
	else if (strcmp(argv[1], "openDoorV1") == 0){
		openDoorV1(argv[2], atoi(argv[3]), atoi(argv[4]));
	}
	else if (strcmp(argv[1], "playVoiceV3") == 0) {
		playVoiceV3(argv[2], argv[3], atoi(argv[4]),atoi(argv[5]));
	}

	return 0;
}

double readWeight(char * pPort, unsigned long BaudRate, unsigned char ByteSize, unsigned char Parity, unsigned char StopBits) {
	HANDLE hCom;
	BOOL bRet = FALSE;
	double dRet = 0.0;

	hCom = CreateFile(pPort,
		GENERIC_READ,
		0,
		NULL,
		OPEN_EXISTING,
		0,
		NULL);
	if (hCom == (HANDLE)-1)
	{
		printf("failure %s\n", pPort);
		return dRet;
	}

	printf("open %s\n", pPort);

	struct _DCB m_dcb;

	GetCommState(hCom, &m_dcb);

	m_dcb.BaudRate = BaudRate;
	m_dcb.ByteSize = ByteSize;
	m_dcb.Parity = Parity;
	m_dcb.StopBits = ONESTOPBIT;
	bRet = SetCommState(hCom, &m_dcb);

	COMMTIMEOUTS comTimeOut;

	comTimeOut.ReadIntervalTimeout = 10;
	comTimeOut.ReadTotalTimeoutMultiplier = 10;
	comTimeOut.ReadTotalTimeoutConstant = 8;
	comTimeOut.WriteTotalTimeoutMultiplier = 0;
	comTimeOut.WriteTotalTimeoutConstant = 0;
	SetCommTimeouts(hCom, &comTimeOut);

	char str[12] = { '\0' };
	unsigned long  wCount;
	int i = 0;
	int j = 0;
	int t = 0;
	int weight = 0;
	int w1 = 0;
	int w2 = 0;
	int w3 = 0;
	int w4 = 0;
	int w5 = 0;
	int w6 = 0;
	int w7 = 0;
	int decimalSize = 0;
	int lastWeitht = 0;

	bRet = false;

	Sleep(16);
	// i don't know why, without Sleep(16), PurgeComm function below
	// can't work. maybe it's a timing problem. and "16" is the minimum
	// value that make it works.

	// discards all characters in the input buffer
	if (!PurgeComm(hCom, PURGE_RXCLEAR))
	{
		printf("clear serial buffer error");
	}
	int k = 0;
	bool bFlag = false;

	while (true){
		if (j >= 100){
			break;
		}
		memset(str, 0, 12);
		bRet = ReadFile(hCom, str, 12, &wCount, NULL);

		if (wCount == 12){
			if (bFlag == false) {
				bFlag = true;
				j = 0;
			}
			//printf("i=%d,j=%d,port=%s\n", i, j, pPort);
			//for (int k = 0; k < 12; k++){
			//	printf("%02X", str[k]);
			//}
			//printf("\n");
			w1 = (str[2] - '0') * 100000;
			w2 = (str[3] - '0') * 10000;
			w3 = (str[4] - '0') * 1000;
			w4 = (str[5] - '0') * 100;
			w5 = (str[6] - '0') * 10;
			w6 = (str[7] - '0');
			w7 = (str[8] - '0');

			decimalSize = 1;
			for (int l = 0; l < w7; l++){
				decimalSize *= 10;
			}

			weight = w1 + w2 + w3 + w4 + w5 + w6;
			printf("weight=%d,lastWeitht=%d,i=%d,j=%d,port=%s\n", weight, lastWeitht, i,j,pPort);
			if (weight != lastWeitht){
				i = 0;
				if (weight > 0)
				{
					lastWeitht = weight;
				}
			}
			else{
				if (weight > 0)
				{
					i++;
				}
				if (i >= 20){
					break;
				}
			}

			//
			if (weight == 0){
				if (t >= 50){
					break;
				}
				t++;
			}

			if (decimalSize != 0){
				dRet = lastWeitht / decimalSize;
			}
			else{
				dRet = lastWeitht;
			}
		}
		SYSTEMTIME st;

		GetLocalTime(&st);

		printf("%d-%d-%d %d:%d:%d:%d,port=%s\n", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, pPort);
		Sleep(200);
		fflush(stdout);
		j++;
	}

	printf("weight:%lf\n", dRet);

	CloseHandle(hCom);

	return dRet;
}

//void initIntegrated(char * ip) {
//#ifdef _QI_LI
//	printf("openDoorV4 start\n");
//
//	E_ReturnCode eCode = DC_NO_ERROR;
//	Net_Init();
//
//	DCHANDLE handle = Net_AddCamera(ip);
//
//	if (handle == -1) {
//		printf("init camera error\n");
//
//		return;
//	}
//	eCode = Net_ConnCamera(handle, 30000, 5);
//	int nConn = 0;
//	if (eCode != DC_NO_ERROR) {
//		printf("connect camera error,error code %d\n", eCode);
//		while (nConn < 3) {
//
//		}
//		Net_DelCamera(handle);
//		Net_UNinit();
//
//		return;
//	}
//
//	T_ControlGate ControlGate;
//	memset(&ControlGate, 0, sizeof(ControlGate));
//	ControlGate.ucState = 1;
//
//	eCode = Net_GateSetup(handle, &ControlGate);
//	if (eCode != DC_NO_ERROR) {
//		for (int i = 0; i < 3; i++) {
//
//		}
//		printf("open door error,error code %d\n", eCode);
//	}
//
//	Net_DisConnCamera(handle);
//	Net_DelCamera(handle);
//
//	Net_UNinit();
//
//	printf("openDoorV4 end\n");
//#endif
//}

//海康摄像机
bool captureImageV2(char *ip, char *fileName, unsigned short pPort, char *userName, char *password) {	
#ifdef _HK_CAMERA
	NET_DVR_Init();          //Init SDK
	//NET_DVR_SetLogToFile(3, "d:\\capture", 0);
	DWORD err = GetLastError();

	NET_DVR_DEVICEINFO_V30 DeviceInfoTmp;
	memset(&DeviceInfoTmp, 0, sizeof(NET_DVR_DEVICEINFO_V30));

	LONG lLoginID = NET_DVR_Login_V30(ip, pPort, userName, password, &DeviceInfoTmp);
	printf("%s,%d,%s,%s\n", ip, pPort, userName, password);

	if (lLoginID == -1)
	{
		err = GetLastError();
		printf("NET_DVR_Login_V30 error %d,%s\n", err, ip);
		return false;
	}
	else{
		printf("%s\n", ip);
	}
	NET_DVR_CLIENTINFO ClientInfo;
	ClientInfo.hPlayWnd = NULL;
	ClientInfo.lChannel = 1;
	ClientInfo.lLinkMode = 0;
	ClientInfo.sMultiCastIP = NULL;
	//TRACE("Channel number:%d\n", ClientInfo.lChannel);
	long m_lPlayHandle = NET_DVR_RealPlay_V30(lLoginID, &ClientInfo, NULL, NULL, TRUE);
	if (-1 == m_lPlayHandle)
	{
		DWORD err = NET_DVR_GetLastError();
		//CString m_csErr;
		//MessageBox(m_csErr);
		printf("NET_DVR_RealPlay_V30 error %d\n", err);

		return false;
	}

	NET_DVR_JPEGPARA JpgPara = { 0 };
	JpgPara.wPicSize = 0xff;
	JpgPara.wPicQuality = 0;

	LONG iCurChan = 1;

	if (!NET_DVR_CaptureJPEGPicture(lLoginID, iCurChan, &JpgPara, fileName))
	{
		DWORD err = NET_DVR_GetLastError();
		printf("NET_DVR_CaptureJPEGPicture error %d,%s\n", err, ip);
		return false;
	}

	NET_DVR_StopRealPlay(lLoginID);
	NET_DVR_Logout_V30(lLoginID);
	NET_DVR_Cleanup();
	printf("captureImage:success");
#endif
	return true;
}

//先科网络音柱
void playVoiceV3(char * ip, char *json, int port,int maxVol) {
	CNetSocket socket;
	string strBody;

	char *buffer = new char [MAX_CMD_SIZE];
	int size = strlen(json);

	size = base64_decode_gbk((uint8*)json, size, buffer);
	buffer[size] = 0;
	printf("%s\n", buffer);

	char *ipVoiceBoxParam = new char[MAX_CMD_SIZE];

	//弘盛发专用
	//sprintf(ipVoiceBoxParam,"{\"loop\":{\"gap\":2,\"times\":2},\"prompt\":false,\"queue\":false,\"rcn\":\"0\",\"rdn\":\"0\",\"reg\":0,\"speed\":50,\"sync\":false,\"text\":\"%s\",\"vcn\":\"xiaoyan\",\"volume\":100}", json);
	sprintf(ipVoiceBoxParam, "{\"loop\":{\"gap\":2,\"times\":2},\"prompt\":false,\"queue\":false,\"rcn\":\"0\",\"rdn\":\"0\",\"reg\":0,\"speed\":50,\"sync\":false,\"text\":\"%s\",\"vcn\":\"xiaoyan\",\"volume\":%d}", buffer, maxVol);

	//printf("json=%s\n", json);
	//string decodeJson = json;
	string decodeJson((char *)ipVoiceBoxParam);

	//printf("%s", decodeJson.c_str());
	socket.PostJson(ip, port, "/v1/speech", decodeJson, strBody);
	printf("voice dev return %s\n", strBody.c_str());
	delete[] ipVoiceBoxParam;
	delete[] buffer;
}

void manualTrigger(char * ip, int port){
	CNetSocket socket;
	string retData;
	char cmd[] = "{\n" \
		"\"cmd\":\"trigger\"\n" \
		"}";

	socket.sendCmd(ip, port, cmd, retData);
	printf("manual trigger dev return %s\n", retData.c_str());
}

//多奥通设备
void resetDevTimeV2(char * ip, int port,int rs485Port){
	CNetSocket socket;
	string retData;
	char *cmd = new char[MAX_CMD_SIZE];
	char *szTime = new char[MAX_CMD_SIZE];
	SYSTEMTIME st;

	//set display time
	createDateTimeData(cmd, rs485Port);
	socket.sendCmd(ip, port, cmd, retData);	

	GetLocalTime(&st);

	sprintf(szTime, "%d-%d-%d %d:%d:%d", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
	//set All-in-one machine time
	ZeroMemory(cmd, MAX_CMD_SIZE);
	sprintf(cmd, "{\n" \
		"\"cmd\" : \"set_time\",\n" \
		"\"id\" : \"132156\",\n" \
		"\"timestring\" : \"%s\"\n" \
		"}", szTime);

	retData = "";
	socket.sendCmd(ip, port, cmd, retData);

	sprintf(cmd, "{\n" \
		"\"cmd\": \"get_device_timestamp\",\n" \
		"\"id\" : \"999999\"\n" \
		"}");
	retData = "";
	socket.sendCmd(ip, port, cmd, retData);

	delete[] szTime;
	delete[] cmd;
}

//多奥通设备
void openDoorV1(char * ip, int port,int ioPort){	
	CNetSocket socket;
	string retData;
	char *cmd = new char[MAX_CMD_SIZE];
	sprintf(cmd, "{" \
		"\"cmd\" : \"ioctl_resp\"," \
		"\"id\" : \"1111\"," \
		"\"io\" : %d," \
		"\"value\" : 2," \
		"\"delay\" : 1500" \
		"}",ioPort);
	socket.sendCmd(ip, port, cmd, retData);	
	printf("dev return %s\n", retData.c_str());
	delete[] cmd;
}

//多奥通设备
void displayInfoV2(char * ip, int port, char * szCarPlate, char * szWeight, char * szAmount, int rs485Port) {
	CNetSocket socket;
	string retData;
	int nCarPlate = 0;
	int nWeight = 0;
	int nAmount = 0;
	char *cmd = new char[MAX_CMD_SIZE];

	printf("displayInfo start\n");
	if (szCarPlate != NULL) {
		nCarPlate = strlen(szCarPlate);
		//printf("nCarPlate is %d\n", nCarPlate);
	}

	if (szWeight != NULL) {
		nWeight = strlen(szWeight);
		//printf("nWeight is %d\n", nWeight);
	}

	if (szAmount != NULL) {
		nAmount = strlen(szAmount);
		//printf("nAmount is %d\n", nAmount);
	}

	//printf("create displayInfo info\n");
	//
	char buff[256] = { 0 };
	if (nCarPlate > 0) {
		createDisplayData(szCarPlate, nCarPlate, 1, cmd, rs485Port);
		//printf("cmd is %s\n", cmd);
		socket.sendCmd(ip, port, cmd, retData);
	}

	//
	if (nWeight > 0) {
		createDisplayData(szWeight, nWeight, 2, cmd, rs485Port);
		//printf("cmd is %s\n", cmd);
		socket.sendCmd(ip, port, cmd, retData);
	}

	//
	if (nAmount > 0) {
		createDisplayData(szAmount, nAmount, 3, cmd, rs485Port);
		//printf("cmd is %s\n", cmd);
		socket.sendCmd(ip, port, cmd, retData);
	}
	printf("display dev return %s\n", retData.c_str());

	delete[]cmd;
}

void createDisplayData(char * text, int textLen, int line,char * cmd, int rs485Port){
	char* packet = NULL;
	try {
		byte header[] = { 0xA5, 0x01, 0x01, 0x3D, 0x3D, 0, 0, 0x3A };
		byte data[] = { 0x00, 0x01, 0x00, 0x30, 0x40, 0x40, 0x0F, 0x64, 0x03, 0x0A, 0x01, 0x02, 0x02, 0x00 };
		int headerLen = sizeof(header);
		int dataLen = sizeof(data);

		memset(cmd, MAX_BUF_SIZE, 0);
		uint8_t* packet = new uint8_t[headerLen + dataLen + textLen + 2];
		data[0] = (byte)line;
		switch (line){
		case 1:
			data[2] = 0x00;
			data[3] = 0x30;
			data[4] = 0x40;
			data[5] = 0x40;
			break;
		case 2:
			data[2] = 0x00;
			data[3] = 0x20;
			data[4] = 0x40;
			data[5] = 0x30;
			break;
		case 3:
			data[2] = 0x00;
			data[3] = 0x10;
			data[4] = 0x40;
			data[5] = 0x20;
			break;
		}
	
		header[5] = (byte)(dataLen + 2 + textLen);
		header[6] = (byte)(dataLen + 2 + textLen);
	
		data[1] = (byte)line;
	
		byte len = 4;
	
		for (int i = 0; i < headerLen; i++) {
			packet[i] = header[i];
		}
	
		for (int i = 0; i < dataLen; i++) {
			packet[headerLen + i] = data[i];
		}
	
		packet[headerLen + dataLen] = (byte)textLen;
	
		for (int i = 0; i < textLen; i++) {
			packet[headerLen + dataLen + i + 1] = text[i];
		}

		packet[headerLen + dataLen + textLen + 1] = (byte)0xC1;
	
		string strBase64 = "";
		uint8 buffer[1024] = {0};
		base64Encode(packet, headerLen + dataLen + textLen + 2,buffer);
	
		memset(cmd, 0, MAX_CMD_SIZE);
		sprintf(cmd, "{\n" \
			"\"cmd\":\"ttransmission\",\n" \
			"\"id\":\"100001\",\n" \
			"\"subcmd\":\"send\",\n" \
			"\"datalen\":%d,\n" \
			"\"data\":\"%s\",\n" \
			"\"comm\":\"rs485-%d\"\n" \
			"}", (headerLen + dataLen + textLen + 2), buffer, rs485Port);
	
		if (packet != NULL){
			delete[]packet;
		}
	}
	catch(...){
		if (packet != NULL){
			delete[]packet;
		}
		//e.printStackTrace();
	}
}

void createVoiceData(char * text, int textLen, char * cmd,int rs485Port) {
	printf("text is %s\n", text);
	printf("textLen is %d\n", textLen);

	char* packet = NULL;
	try {
		byte header[] = { 0xA5, 0x01, 0x01, 0x3D, 0x3D, 0, 0, 0x30 ,0x01 };
		int headerLen = sizeof(header);

		memset(cmd, MAX_BUF_SIZE, 0);
		uint8_t* packet = new uint8_t[headerLen + textLen + 2];
		byte len = 4;

		header[5] = (byte)(4 + textLen);
		header[6] = (byte)(4 + textLen);

		for (int i = 0; i < headerLen; i++) {
			packet[i] = header[i];
		}

		packet[headerLen] = (byte)textLen;

		for (int i = 0; i < textLen; i++) {
			packet[headerLen + i + 1] = text[i];
		}

		packet[headerLen + textLen + 1] = (byte)0xC1;

		for (int i = 0; i < headerLen + textLen + 2;i++) {
			printf("%02X", packet[i]);
		}
		printf("\n");
		string strBase64 = "";
		uint8 buffer[1024] = { 0 };
		int size = base64_encode(packet, headerLen + textLen + 2, buffer);

		memset(cmd, 0, MAX_CMD_SIZE);
		sprintf(cmd, "{\n" \
			"\"cmd\":\"ttransmission\",\n" \
			"\"id\":\"100001\",\n" \
			"\"subcmd\":\"send\",\n" \
			"\"datalen\":%d,\n" \
			"\"data\":\"%s\",\n" \
			"\"comm\":\"rs485-%d\"\n" \
			"}", (headerLen + textLen + 2), buffer, rs485Port);

		if (packet != NULL) {
			delete[]packet;
		}
	}
	catch (...) {
		if (packet != NULL) {
			delete[]packet;
		}
		//e.printStackTrace();
	}
}

void createDateTimeData(char * cmd,int rs485Port) {
	try {
		byte header[] = { 0xA5, 0x01, 0x01, 0x3D, 0x3D, 0, 0, 0x05 };
		byte data[] = { 0x00, 0x01, 0x00, 0x30, 0x40, 0x40, 0x0F, 0x64 };
		int headerLen = sizeof(header);
		int dataLen = sizeof(data);
		uint8_t* packet = new uint8_t[headerLen + dataLen + 1];

		time_t t = time(NULL);
		struct tm *local_time = localtime(&t);

		int nYear = local_time->tm_year + 1900;
		uint8_t * bYear = new uint8_t[2];

		for (int i = 0; i < 2; i++) {
			bYear[2 - i - 1] = (byte)((nYear >> 8 * i) & 0xff);
		}

		int nMonth = local_time->tm_mon + 1;
		byte bMonth = (byte)nMonth;

		int nDay = local_time->tm_mday;
		byte bDay = (byte)nDay;

		int nHour = local_time->tm_hour;
		byte bHour = (byte)nHour;

		int nMinute = local_time->tm_min;
		byte bMinute = (byte)nMinute;

		int nSecond = local_time->tm_sec;
		byte bSecond = (byte)nSecond;

		byte bWeek = local_time->tm_wday;

		data[0] = bYear[1];
		data[1] = bYear[0];
		data[2] = bMonth;
		data[3] = bDay;
		data[4] = bHour;
		data[5] = bMinute;
		data[6] = bSecond;
		data[7] = bWeek;

		header[5] = (byte)(dataLen + 2);
		header[6] = (byte)(dataLen + 2);

		for (int i = 0; i < headerLen; i++) {
			packet[i] = header[i];
		}

		for (int i = 0; i < dataLen; i++) {
			packet[headerLen + i] = data[i];
		}

		packet[headerLen + dataLen] = (byte)0xC1;

		uint8 *buffer = new uint8[MAX_CMD_SIZE];
		int size = base64_encode(packet, headerLen + dataLen + 1, buffer);

		for (int i = 0; i < headerLen + dataLen; i++) {
			printf("%02X", packet[i]);
		}

		printf("\n");

		sprintf(cmd, "{\n" \
			"\"cmd\":\"ttransmission\",\n" \
			"\"id\":\"100001\",\n" \
			"\"subcmd\":\"send\",\n" \
			"\"datalen\":%d,\n" \
			"\"data\":\"%s\",\n" \
			"\"comm\":\"rs485-%d\"\n" \
			"}", (headerLen + dataLen + 2), buffer, rs485Port);
		delete[]buffer;
		delete[]bYear;
		delete[]packet;
	}
	catch (...) {

	}
}

void saveBase64ToFile(char * fileName,string retData) {
	FILE *fp = fopen(fileName, "wb");
	if (fp == NULL) {
		printf("Error! Could not open file\n");
		return;
	}
	uint8 *buffer = new uint8[10 * MAX_CMD_SIZE * MAX_CMD_SIZE];
	int size = strlen(retData.c_str());
	printf("size is %d\n", size);
	int newsize = base64_decode((uint8*)retData.c_str(), size, buffer);

	printf("size is %d\n", newsize);
	fwrite(buffer, newsize, 1, fp);

	// 关闭文件
	fclose(fp);
	delete[]buffer;
}