#pragma once
#include "line4c3.h"
#include "Line4C3client.h"

#define APPID_INTERVAL	(1296000*2/3-2)		//(15 days,10d)
#define	TOKEN_INTERVAL	(3600/2-2)		//(1 hours,0.5h)
int timeout_RegAppid;
int timeout_token;
unsigned long GetTimeStamp()
{
	unsigned long stampNow = 0;
	time_t timer;
	timer = time(NULL);
	stampNow = timer;

	return stampNow;
}

UINT rxprocess(LPVOID rxptr)
{
	CLine5C3* rtxpPara = NULL;
	rtxpPara = (CLine5C3*)rxptr;
	sint32 rtuno = rtxpPara->Get_rtuno();
	while (!rtxpPara->rxflag)
	{	
	  if(rtxpPara->cmd_flag){//no cmd
		string authName = rtxpPara->Get_authName();
		int userNum = rtxpPara->Get_userNum();
		int appid_nowtime = GetTimeStamp();
		if (((appid_nowtime - rtxpPara->appid_lasttime) > timeout_RegAppid) || ((appid_nowtime - rtxpPara->appid_lasttime)<0) || (rtxpPara->appid_flag == true))
		{
			rtxpPara->postappid(authName, userNum);
			//rtxpPara->appid_flag = false;
			if (!rtxpPara->appid_flag)
			{
				rtxpPara->appid_lasttime = appid_nowtime;
			}
		}
		int token_nowtime = GetTimeStamp();
		if (!rtxpPara->appid_flag && (((token_nowtime - rtxpPara->token_lasttime) > timeout_token) || ((token_nowtime - rtxpPara->token_lasttime) <0) || (rtxpPara->token_flag == true)))
		{
			string appid = rtxpPara->Get_appid();
			rtxpPara->posttokenid(appid, token_nowtime);
			if (!rtxpPara->token_flag)
			{
				rtxpPara->token_lasttime = token_nowtime;
			}
		}
		int zone_nowtime = GetTimeStamp();
		if ((((zone_nowtime - rtxpPara->zone_lasttime) > 8) || ((zone_nowtime - rtxpPara->zone_lasttime) < 0)) && rtxpPara->zone_flag && !(rtxpPara->appid_flag) && !(rtxpPara->token_flag))
		{
			rtxpPara->getcall_stations();	//Get user_id 
			rtxpPara->getsubsystems();
//			//rtxpPara->getall_broadcast_lines(rtuno);
//			rtxpPara->getall_zones();
			rtxpPara->getzones();
			rtxpPara->zone_lasttime = zone_nowtime;
		}
	  }
	  Sleep(100);
	}
	return 0;
}

UINT txprocess(LPVOID txptr)
{
	//////Test///////////////////////////////
//	int userid[8] = {5051,5052,5053,5054,0,0,0,0};

	CLine5C3* rtxpPara = NULL;

	rtxpPara = (CLine5C3*)txptr;
	sint32 rtuno = rtxpPara->Get_rtuno();
	int i=0;
	while (!rtxpPara->txflag)
	{
		S_RAWCMD rawcmd;
		while (rtxpPara->Get_CmdNum() > 0)
		{
			if (rtxpPara->Get_ACmd(rtuno, &rawcmd) == 0)
				break;

			if (rawcmd.type == DC_K_CMD_PAOPRATE)
			{
				CSI_D_PA_CMD* PaCmd;
				PaCmd = (CSI_D_PA_CMD*)rawcmd.data;

				switch (PaCmd->Func)
				{
				case PA_FUNC_MIKE:
				{	rtxpPara->cmd_flag=false;
					uint16 zone = PaCmd->Zone;
					int m_nAreaNum = rtxpPara->Get_AreaNum();
					
					vector<uint16> zones_tmp;
					for (i = 0; i < m_nAreaNum; ++i)
					{
						int j = (0xFFFF) & (zone & 1);
						if (j == 1)
						{
							zones_tmp.push_back(i + 1);
						}
						zone >>= 1;
					}

					uint32 station = PaCmd->Station;
					int m_nStationNum = rtxpPara->Get_StationNum();
					vector<uint32> subsystems_tmp;
					for (i = 0; i < m_nStationNum; ++i)
					{
						int j = (0xFFFFFFFF) & (station & 1);
						if (j == 1)
						{
							
//							subsystems_tmp.push_back(i + 1);
							subsystems_tmp.push_back(i);
						}
						station >>= 1;
					}
					vector<uint32> match = rtxpPara->stationid(subsystems_tmp);

					uint8 user = PaCmd->User;
					int call_station_id = rtxpPara->callstationid(user-1);//user=1-8
//					if (call_station_id < 1)call_station_id = userid[user-1];//Test Init

					rtxpPara->post_startmic(call_station_id, match, zones_tmp);
					rtxpPara->Put_AYx(rtuno, YX_MIC, rtxpPara->startmic_flag);
				}
				break;
				case PA_FUNC_CLOSE:
				{	rtxpPara->cmd_flag=false;
					switch (PaCmd->Val)
					{
					case PA_CLOSE_MIKE:
						{
						uint8 user = PaCmd->User;
						int call_station_id = rtxpPara->callstationid(user-1);//user=1-8
//						if (call_station_id < 1)call_station_id = userid[user-1];//Test Init
						rtxpPara->post_stopmic(call_station_id);
						rtxpPara->Put_AYx(rtuno, YX_MIC, rtxpPara->stopmic_flag);
						}
					break;
					default:
						break;
					}
				}
				break;				
				default:
					break;
				}
			}
			rtxpPara->Del_ACmd(rtuno);
		}
		Sleep(100);
	}
	return 0;
}

void CLine5C3::Put_AYx(uint16 Rtuno, uint16 YxNo, uint8 YxValue)
{
	PRawCtrl->PutAYx(Rtuno, YxNo, YxValue);
}

sint32 CLine5C3::Get_rtuno()
{
	return (pLink->GetRtuNo());
}

sint32 CLine5C3::Get_CmdNum()
{
	sint32 rtuno = pLink->GetRtuNo();
	return (pCmdMem->GetCmdNum(rtuno));
}

sint32 CLine5C3::Get_ACmd(sint32 rtuno, S_RAWCMD* cmd)
{
	return pCmdMem->GetACmd(rtuno, cmd);
}

sint32 CLine5C3::Del_ACmd(sint32 rtuno)
{
	return pCmdMem->DelACmd(rtuno);
}

int CLine5C3::Get_AreaNum()
{
	return AreaNum;
}

int CLine5C3::Get_StationNum()
{
	return StationNum;
}

string CLine5C3::Get_authName()
{
	return authName;
}

int CLine5C3::Get_userNum()
{
	return userNum;
}

string CLine5C3::Get_appid()
{
	return app_id;
}

string CLine5C3::Get_tokenid()
{
	return token_id;
}

int CLine5C3::callstationid(uint8 user)
{
	return map_user[user];
}

vector<uint32> CLine5C3::stationid(vector<uint32> sta)
{	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	uint32 staID[32] = { 1519, 1523, 1527, 1531, 1534, 1537, 1540, 1544, 1547, 1550, 1553, 1561, 1564, 1568, 1572, 1575, 1578, 1581, 1584, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	vector<uint32> res;
	int i = 0,staNum=0;
	staNum=map_station.size();
/*	if(map_station.size()<1){
		staNum=32;
		for (i = 0; i < 32; ++i)
			map_station[i] = staID[i];//Test Init
	}
	*/
	for (i = 0; i < sta.size(); ++i)
	{
		if(i<staNum)
			res.push_back(map_station[sta[i]]);
		else
			break;
	}
	return res;
}

void CLine5C3::Init(S_PROTOCOLCFG* pcfg)
{
	PRawCtrl = pcfg->PRawCtrl;
	pCmdMem = pcfg->pCmdMem;
	pRtu = pcfg->pRtu;
	pLink = pcfg->pLink;
	timeout_RegAppid=pLink->GetKwhScanInterval();//ACC-COUNT电度召唤周期秒
	if(timeout_RegAppid<120)timeout_RegAppid=1296000;
	timeout_token=pLink->GetAllDataScanInterval();//ALL-DATA全数据扫描间隔秒
	if(timeout_token<30)timeout_token=3600;
	
	AreaNum = 16;
	StationNum = 32;

	rxflag = true;
	txflag = true;

	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	cmd_flag=true;
	appid_lasttime = 0;
	token_lasttime = 0;
	zone_lasttime = 0;

	startmic_flag = 0;
	stopmic_flag = 0;

	//authName = "sios";
	//userNum = 1234;
	ReadIni();
	PrintLog(LOG_WARNING, "RTU[%d] ReadIni [SEROOT/cfg/Pa5line.ini]!",Get_rtuno());
	if (rxflag)
	{
		sint32 rxthread = SE_CreateThread((PTHREAD_FUNC_DEF)rxprocess, this, 100);
		rxflag=false;
	PrintLog(LOG_WARNING, "RTU[%d] Create [rxprocess] thread OK! rxflag=false!",Get_rtuno());
	}
	if (txflag)
	{
		sint32 txthread = SE_CreateThread((PTHREAD_FUNC_DEF)txprocess, this, 100);
		txflag=false;
	PrintLog(LOG_WARNING, "RTU[%d] Create [txprocess] thread OK! txflag=false!",Get_rtuno());
	}	
}

int CLine5C3::postappid(string authName, int userNum)
{
	int status = 0;
	sint32 rtuno = Get_rtuno();
	string urls = server_urls + "/auth/regappid";
	string appid_header = "Content-Type:application/json\r\n";
	string appid_body;
	string appid_callback;
	Json::Value bodysender;
	if (authName.size() > 0)
	{
		bodysender["authName"] = authName;
	}
	else
	{
		PrintLog(LOG_ERROR, "authName is NULL!");
	}
	if (userNum >= 0)
	{
		bodysender["userNum"] = userNum;
	}
	else
	{
		PrintLog(LOG_ERROR, "userNum < 0!");
	}
	Json::FastWriter bodywrite;
	appid_body = bodywrite.write(bodysender);	
	status = Fclient::Sendreq(urls, appid_header, appid_body, appid_callback);	
	if (status == 1){
		Put_AYx(rtuno, STATUS, 1);
	appid_flag = false;
	token_flag = true;
	}
	else{
		Put_AYx(rtuno, STATUS, 0);	
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	}
	/*
	//json包解析测试
	Json::Value appidback;
	appidback["success"] = true;
	appidback["code"] = 200;
	appidback["message"] = "";
	appidback["regappid"] = "ef08e274512c41d885a755edc7870e9d";
	Json::FastWriter appidwrite;
	appid_callback = appidwrite.write(appidback);
	PrintLog(LOG_INFORMATION, "appid_callback is setting!");
	*/
	if (appid_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "appid_callback is NULL!");
		return 0;
	}
	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_appid;
	if (reader.parse(appid_callback, parse_appid))
	{
		bool success = parse_appid["success"].asBool();
		int code = parse_appid["code"].asInt();
		string message = parse_appid["message"].asString();
		string regappid = parse_appid["regappid"].asString();

		if (success == true)
		{
			appid_flag = false; 
			token_flag = true;
			app_id = regappid;
			PrintLog(LOG_INFORMATION, "regappid success, regappid：%s", regappid.c_str());
		}
		else
		{
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
			PrintLog(LOG_INFORMATION, "RTU[%d] regappid occured error, 失败理由：%s, 代码：%d", rtuno,message.c_str(), code);
		}
	}
	return 1;
}


int CLine5C3::posttokenid(string appid, int timeKey)
{
	int status = 0;
	sint32 rtuno = Get_rtuno();
	string urls = server_urls + "/auth/gettoken";
	string token_header = "Content-Type:application/json\r\n";
	string token_body;
	string token_callback;
	Json::Value bodysender;
	if (app_id.size() > 0)
	{
		bodysender["appid"] = app_id;
	}
	else
	{
		PrintLog(LOG_ERROR, "app_id is NULL!");
	}
	//int timeKey = GetTimeStamp();
	if (timeKey >= 0)
	{
		bodysender["timeKey"] = timeKey;
//		bodysender["timeKey"] = 1678929319;
	}
	else
	{
		PrintLog(LOG_ERROR, "timeKey < 0!");
	}

	Json::FastWriter bodywrite;
	token_body = bodywrite.write(bodysender);
	status = Fclient::Sendreq(urls, token_header, token_body, token_callback);
	if (status == 1){
		Put_AYx(rtuno, STATUS, 1);
		token_flag = false;
	}
	else{
		Put_AYx(rtuno, STATUS, 0);
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	}
	/*
	//json包解析测试
	Json::Value tokenback;
	tokenback["success"] = true;
	tokenback["code"] = 200;
	tokenback["message"] = "";
	tokenback["token"] = "ThirdBearer xxx.xxx.xxx";
	Json::FastWriter tokenwrite;
	token_callback = tokenwrite.write(tokenback);
	PrintLog(LOG_INFORMATION, "token_callback is setting!");
	*/

	if (token_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "token_callback is NULL!");
		return 0;
	}

	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_token;
	if (reader.parse(token_callback, parse_token))
	{
		bool success = parse_token["success"].asBool();
		int code = parse_token["code"].asInt();
		string message = parse_token["message"].asString();
		string token = parse_token["token"].asString();
		if (success == true)
		{
			token_flag = false;
			token_id = token;
			PrintLog(LOG_INFORMATION, "success_tokenid：%s", token.c_str());
		}
		else
		{
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
			PrintLog(LOG_INFORMATION, "RTU[%d] gettoken occured error, 失败理由：%s, 代码：%d", rtuno,message.c_str(), code);
		}
	}

	return 1;
}

int CLine5C3::getcall_stations()
{
	int status = 0,i=0;
	sint32 rtuno = Get_rtuno();

	char tmp_header[128] = { 0 };
	sprintf(tmp_header, "Content-Type:application/json\r\nAccessTokenThird:%s\r\n", token_id.c_str());
	token_header = tmp_header;
	string urls = server_urls + "/manual/api/pa/call_stations";
	string call_stations_data = "";
	string call_stations_callback;
	status = Fclient::Sendreq(urls, token_header, call_stations_data, call_stations_callback);
	if (status == 1)
	{
		Put_AYx(rtuno, STATUS, 1);
//		zone_flag=false;
	}
	else
	{
		Put_AYx(rtuno, STATUS, 0);
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	}
	/*
	//json包解析测试
	Json::Value callstationback;
	callstationback[0]["id"] = 5051;
	callstationback[0]["name"] = "行调1";
	callstationback[0]["status"] = "on";
	callstationback[1]["id"] = 5052;
	callstationback[1]["name"] = "行调2";
	callstationback[1]["status"] = "on";
	callstationback[2]["id"] = 5053;
	callstationback[2]["name"] = "行调3";
	callstationback[2]["status"] = "on";
	Json::FastWriter callstationwrite;
	call_stations_callback = callstationwrite.write(callstationback);
	PrintLog(LOG_INFORMATION, "call_stations_callback is setting!");
	*/

	if (call_stations_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "call_stations_callback is NULL!");
		return 0;
	}
	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_call_station_callback;
	if (reader.parse(call_stations_callback, parse_call_station_callback))
	{
		bool success = parse_call_station_callback["success"].asBool();
		if (!success) {
			appid_flag = true;
			token_flag = true;
			zone_flag = true;
		}
		int size = 0;
		if (parse_call_station_callback["result"].isArray())
		{
			size = parse_call_station_callback["result"].size();
		}
		else
			return 0;
		PrintLog(LOG_INFORMATION, "Num of call_stations is %d", size);
		vector<cstation>().swap(call_stations);
		for (i = 0; i < size; ++i)
		{
			int id = parse_call_station_callback["result"][i]["id"].asInt();
			string name = parse_call_station_callback["result"][i]["name"].asString();
			string status = parse_call_station_callback["result"][i]["status"].asString();

			cstation cstation_tmp;
			cstation_tmp.id = id;
			cstation_tmp.name = name;
			cstation_tmp.status = status;
			call_stations.push_back(cstation_tmp);
		}
		for (i = 0; i < 8; ++i)
		{
			if (call_stations.size() <= i)
				break;

			map_user[i] = call_stations[i].id;
			
		}
	}
	return 1;
}

int CLine5C3::getsubsystems()
{
	int status = 0,i=0;
	sint32 rtuno = Get_rtuno();
	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Content-Type:application/json\r\nAccessTokenThird:%s\r\n", token_id.c_str());
	token_header = tmp_header;
	string urls = server_urls + "/manual/api/pa/subsystems";
	string subsystems_data = "";
	string subsystems_callback;
	status = Fclient::Sendreq(urls, token_header, subsystems_data, subsystems_callback);
	if (status == 1)
	{
		Put_AYx(rtuno, STATUS, 1);
//		zone_flag=false;
	}
	else
	{
		Put_AYx(rtuno, STATUS, 0);
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	}
	if (subsystems_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "subsystems_callback is NULL!");
		return 0;
	}
	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_subsystems_callback;
	if (reader.parse(subsystems_callback, parse_subsystems_callback))
	{
		bool success = parse_subsystems_callback["success"].asBool();
		if (!success) {
			appid_flag = true;
			token_flag = true;
			zone_flag = true;
		}
		int size = 0;
		if (parse_subsystems_callback["result"].isArray())
		{
			size = parse_subsystems_callback["result"].size();
		}
		else
			return 0;
		PrintLog(LOG_INFORMATION, "Num of subsystems is %d", size);
		vector<subsystem>().swap(subsystems);
		for (i = 0; i < size; ++i)
		{
			int id = parse_subsystems_callback["result"][i]["id"].asInt();
			string name = parse_subsystems_callback["result"][i]["name"].asString();

			subsystem subsystem_tmp;
			subsystem_tmp.id = id;
			subsystem_tmp.name = name;
			subsystems.push_back(subsystem_tmp);
		}
		for (i = 0; i < StationNum; ++i)
		{
			if (subsystems.size() <= i)
				break;
			map_station[i] = subsystems[i].id;
		}
	}
	return 1;
}


int CLine5C3::getzones()
{
	int status = 0;
	sint32 rtuno = Get_rtuno();
	appid_flag = false;

	char tmp_header[128] = { 0 };
	sprintf(tmp_header, "Content-Type:application/json\r\nAccessTokenThird:%s\r\n", token_id.c_str());
	token_header = tmp_header;

	string urls = server_urls + "/manual/api/pa/zones";
	string zones_data = "";
	string zones_callback;

	status = Fclient::Sendreq(urls, token_header, zones_data, zones_callback);
	if (status == 1){
		Put_AYx(rtuno, STATUS, 1);
//		zone_flag=false;
	}
	else {
		Put_AYx(rtuno, STATUS, 0);
		appid_flag = true;
//appid_flag = true;
		token_flag = true;
		zone_flag = true;
	}
	/*
	//json包解析测试
	Json::Value callstationback;
	callstationback["result"][0]["id"] = 1;
	callstationback["result"][0]["name_en"] = "up";
	callstationback["result"][0]["name_zh"] = "上行站台";
	callstationback["result"][1]["id"] = 2;
	callstationback["result"][1]["name_en"] = "down";
	callstationback["result"][1]["name_zh"] = "下行站台";
	callstationback["result"][2]["id"] = 3;
	callstationback["result"][2]["name_en"] = "hall";
	callstationback["result"][2]["name_zh"] = "站厅";
	callstationback["result"][3]["id"] = 4;
	callstationback["result"][3]["name_en"] = "office";
	callstationback["result"][3]["name_zh"] = "设备办公区";
	callstationback["result"][4]["id"] = 5;
	callstationback["result"][4]["name_en"] = "exit";
	callstationback["result"][4]["name_zh"] = "车站出入口";
	callstationback["result"][5]["id"] = 6;
	callstationback["result"][5]["name_en"] = "transfer";
	callstationback["result"][5]["name_zh"] = "换乘通道";
	Json::FastWriter callstationwrite;
	zones_callback = callstationwrite.write(callstationback);
	PrintLog(LOG_INFORMATION, "call_stations_callback is setting!");
	*/

	if (zones_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "zones_callback is NULL!");
		return 0;
	}

	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_zones_callback;
	if (reader.parse(zones_callback, parse_zones_callback))
	{
		bool success = parse_zones_callback["success"].asBool();
		if (!success) {
			appid_flag = true;
			token_flag = true;
			zone_flag = true;
		}
		int size = 0;
		if (parse_zones_callback["result"].isArray())
		{
			size = parse_zones_callback["result"].size();
		}
		else
			return 0;

		PrintLog(LOG_INFORMATION, "Num of zones id %d", size);

		for (int i = 0; i < size; ++i)
		{
			int id = parse_zones_callback["result"][i]["id"].asInt();
			string name_en = parse_zones_callback["result"][i]["name_en"].asString();
			string name_zh = parse_zones_callback["result"][i]["name_zh"].asString();

			zone zone_tmp;
			zone_tmp.id = id;
			zone_tmp.name_en = name_en;
			zone_tmp.name_zh = name_zh;

			zones.push_back(zone_tmp);
		}
	}

	return 1;
}


/*
int CLine5C3::getall_zones()
{
	int status = 0;
	sint32 rtuno = Get_rtuno();
	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Content-Type:application/json\r\nAccessTokenThird:%s\r\n", token_id.c_str());
	token_header = tmp_header;
	string urls = server_urls + "/api/pa/all_zones";
	string all_zones_data = "";
	string all_zones_callback;
	status = Fclient::Sendreq(urls, token_header, all_zones_data, all_zones_callback);
	if (status == 1){
		Put_AYx(rtuno, STATUS, 1);
		zone_flag=false;
	}
	else
	{
		Put_AYx(rtuno, STATUS, 0);
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	}
	if (all_zones_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "all_zones_callback is NULL!");
		return 0;
	}
	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_all_zones_callback;
	if (reader.parse(all_zones_callback, parse_all_zones_callback))
	{
		int size = 0;
		if (parse_all_zones_callback["result"].isArray())
		{
			size = parse_all_zones_callback["result"].size();
		}
		else
			return 0;

		for (int i = 0; i < size; ++i)
		{
			int zones_size = parse_all_zones_callback["result"][i]["zones"].size();
			int j = 0;

			while (j < zones_size)
			{
				string status = parse_all_zones_callback["result"][i]["zones"][j]["status"].asString();
				
				if (status == "free")
					Put_AYx(rtuno, 16 * i + j + 1, 1);
				else
					Put_AYx(rtuno, 16 * i + j + 1, 0);
				++j;
			}
		}
	}
	return 1;
}

 */

int CLine5C3::post_startmic(int userid, vector<uint32> stations, vector<uint16> zones)
{
	int status = 0;
	sint32 rtuno = Get_rtuno();
	startmic_flag = 0;
	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Content-Type:application/json\r\nAccessTokenThird:%s\r\n", token_id.c_str());
	string startmic_header = tmp_header;
	string urls = server_urls + "/manual/api/pa/start_mic";
	string startmic_body;
	string startmic_callback;
	Json::Value bodysender;
	if (userid > 0)
	{
//		bodysender["call_station_id"] = 5051;
		bodysender["call_station_id"] = userid;
	}
	else
	{
		PrintLog(LOG_WARNING, "call_station_id <= 0");
	}
	if (stations.size() > 0)
	{
//		bodysender["subsystem_ids"].append(1523);//1539
		for (int i = 0; i < stations.size(); ++i)
		{
			bodysender["subsystem_ids"].append(stations[i]);
		}
	}
	else
	{
		PrintLog(LOG_ERROR, "subsystems_ids is NULL!");
	}
	if (zones.size() > 0)
	{
		for (int i = 0; i < zones.size(); ++i)
		{
			bodysender["zone_ids"].append(zones[i]);
		}
	}
	else
	{
		PrintLog(LOG_ERROR, "zone_ids is NULL!");
	}
	Json::FastWriter bodywrite;
	startmic_body = bodywrite.write(bodysender);
	status = Fclient::Sendreq(urls, startmic_header, startmic_body, startmic_callback);
	cmd_flag=true;
	if (status == 1){
		Put_AYx(rtuno, STATUS, 1);
	}
	else
	{
		Put_AYx(rtuno, STATUS, 0);
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	}
	if (startmic_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "startmic_callback is NULL!");
		return 0;
	}
	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_startmic;
	if (reader.parse(startmic_callback, parse_startmic))
	{

		bool success = parse_startmic["success"].asBool();
		int codeVal = parse_startmic["code"].asInt();
		string msg=parse_startmic["message"].asString();
//		string reason = parse_startmic["result"][0]["reason"].asString();
//		string result = parse_startmic["result"][0]["result"].asString();
		if (success == true)
		{
			startmic_flag = 1;
			PrintLog(LOG_INFORMATION, "RTU[%d] Rx startmic Answer success!",rtuno);
		}
		else
		{
			startmic_flag = 0;
			PrintLog(LOG_ERROR, "RTU[%d] Rx startmic Answer failure!",rtuno);
		}
		int size = 0;
		if (parse_startmic["result"].isArray())
		{
			size = parse_startmic["result"].size();
		}
		else
			return 0;
		PrintLog(LOG_INFORMATION, "Num of startmic_callback_information is %d", size);
		for (int i = 0; i < size; ++i)
		{
			int id = parse_startmic["result"][i]["id"].asInt();
			bool result = parse_startmic["result"][i]["result"].asBool();
			string reason = parse_startmic["result"][i]["reason"].asString();

			if (result)
			{
				startmic_flag = 1;
			}
		}
		
	}
	return 1;
}

int CLine5C3::post_stopmic(int userid)
{
	int status = 0;
	sint32 rtuno = Get_rtuno();
	stopmic_flag = 0;
	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Content-Type:application/json\r\nAccessTokenThird:%s\r\n", token_id.c_str());
	string stopmic_header = tmp_header;
	string urls = server_urls + "/manual/api/pa/stop_mic";
	string stopmic_body;
	string stopmic_callback;
	Json::Value bodysender;
	if (userid > 0)
	{
		//bodysender["call_station_id"] = 5051;
		bodysender["call_station_id"] = userid;
	}
	else
	{
		PrintLog(LOG_WARNING, "call_station_id <= 0");
	}
	Json::FastWriter bodywrite;
	stopmic_body = bodywrite.write(bodysender);
	status = Fclient::Sendreq(urls, stopmic_header, stopmic_body, stopmic_callback);
	cmd_flag=true;
	if (status == 1){
		Put_AYx(rtuno, STATUS, 1);
	}
	else
	{
		Put_AYx(rtuno, STATUS, 0);
	appid_flag = true;
	token_flag = true;
	zone_flag = true;
	}
	if (stopmic_callback.size() <= 0)
	{
		PrintLog(LOG_ERROR, "stopmic_callback is NULL!");
		return 0;
	}
	Json::Reader reader(Json::Features::strictMode());
	Json::Value parse_stopmic;
	if (reader.parse(stopmic_callback, parse_stopmic))
	{
		bool success = parse_stopmic["success"].asBool();
		int codeVal = parse_stopmic["code"].asInt();
		string msg=parse_stopmic["message"].asString();
//		string reason = parse_stopmic["result"][0]["reason"].asString();
//		string result = parse_stopmic["result"][0]["result"].asString();
		if (success == true)
		{
			stopmic_flag = 1;
			PrintLog(LOG_INFORMATION, "RTU[%d] Rx stopmic  Answer success!",rtuno);
		}
		else
		{
			stopmic_flag = 0;
			PrintLog(LOG_ERROR, "RTU[%d] Rx stopmic  Answer failure!",rtuno);
		}
		int size = 0;
		if (parse_stopmic["result"].isArray())
		{
			size = parse_stopmic["result"].size();
		}
		else
			return 0;
		PrintLog(LOG_INFORMATION, "stop_mic");
		for (int i = 0; i < size; ++i)
		{
			bool result = parse_stopmic["result"][i]["result"].asBool();
			string reason = parse_stopmic["result"][i]["reason"].asString();
			if (result)
			{
				stopmic_flag = 1;
			}
		}	
	}
	return 1;
}

void CLine5C3::ReadIni()
{
	char filename[512];
	CReadConf readconf;
	char* pWorkPath = getenv("FEPROOT");
	if (pWorkPath != NULL)
		sprintf(filename, "%s%s", pWorkPath, "/cfg/Pa4line.ini");	
	char urls_tmp[128];
	char auth_tmp[128];
	char user_tmp[128];
	string head_tmp = "http://";
	readconf.ReadString("LoginInfo", "server_urls", urls_tmp, filename, "10.5.0.92:8086");
	readconf.ReadString("LoginInfo", "authName", auth_tmp, filename, "sios");
	readconf.ReadString("LoginInfo", "userNum", user_tmp, filename, "1234");
	server_urls  = head_tmp + urls_tmp;
	//strcat(server_urls, urls_tmp);
	authName = auth_tmp;
	userNum = atoi(user_tmp);
}

sint32 CLine5C3:: TxProc()
{
	return 1;
}

sint32 CLine5C3::RxProc()
{
	return 1;
}

#if defined(WIN32)
extern "C" __declspec(dllexport)
#else 
extern "C"
#endif
CProtocol	*CreateProtocol(char *defpara)
{
	return (CProtocol*)(new CLine5C3());
}
/*
#ifdef __unix
extern "C" CProtocol* CreateProtocol(char *defpara)
#else
extern "C" __declspec(dllexport)  CProtocol* CreateProtocol(char *defpara)
#endif
{
	CProtocol *pEpv = new CLine5C3;
	return pEpv;
}
*/