package com.szpg.plc.protocol.fins;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

import org.apache.log4j.Logger;

import com.szpg.db.dao.PgAcuRdcmdDao;
import com.szpg.db.dao.impl.PgAcuRdcmdDaoImpl;
import com.szpg.db.data.PgAcuRdcmd;
import com.szpg.plc.message.AppMessage;
import com.szpg.plc.message.AppMessageConstants;
import com.szpg.plc.message.UnKnownMessage;
import com.szpg.plc.message.command.LinkCommand;
import com.szpg.plc.message.command.ReadMemoryCommand;
import com.szpg.plc.message.response.LinkCommandResponse;
import com.szpg.plc.message.response.read.ReadCH4StatusCommandResponse;
import com.szpg.plc.message.response.read.ReadCH4ValueCommandResponse;
import com.szpg.plc.message.response.read.ReadCOStatusCommandResponse;
import com.szpg.plc.message.response.read.ReadCOValueCommandResponse;
import com.szpg.plc.message.response.read.ReadDSStatusCommandResponse;
import com.szpg.plc.message.response.read.ReadHSStatusCommandResponse;
import com.szpg.plc.message.response.read.ReadHSValueCommandResponse;
import com.szpg.plc.message.response.read.ReadO2StatusCommandResponse;
import com.szpg.plc.message.response.read.ReadO2ValueCommandResponse;
import com.szpg.plc.message.response.read.ReadWSStatusCommandResponse;
import com.szpg.plc.message.response.read.ReadWSValueCommandResponse;
import com.szpg.plc.message.response.read.ReadYWStatusCommandResponse;
import com.szpg.plc.protocol.DTProtocolInterface;
import com.szpg.plc.protocol.fins.frame.FINSByteFrame;
import com.szpg.plc.protocol.fins.frame.FINSByteFrameTool;
import com.szpg.plc.util.ByteUtil;
import com.szpg.plc.util.Bytes;

public class FINSDTProtocolImp implements DTProtocolInterface {

	private final Logger logger = Logger.getLogger(this.getClass().getName()); // 输出到message
	
	/**
	 * 从重叠消息中提取规范消息
	 */
	@Override
	public List<byte[]> extractByteMessage(byte[] byteMessage) {
		List<byte[]> bytesList = new ArrayList<byte[]>();
		int count = 0;
		
		try {
			int i = 0;
			while (i < byteMessage.length) {
				if (byteMessage[i] == FINSByteFrame.HEADER[0] && 
					byteMessage[i + 1] == FINSByteFrame.HEADER[1] &&
					byteMessage[i + 2] == FINSByteFrame.HEADER[2] &&
					byteMessage[i + 3] == FINSByteFrame.HEADER[3]) {
					
					// 匹配上FINS帧头
					int length = ByteUtil.binToInt(new byte[]{byteMessage[i + 4], byteMessage[i + 5], byteMessage[i + 6], byteMessage[i + 7]});
					if (i + length + 8 <= byteMessage.length) {
						Bytes bytes = new Bytes();
						bytes.append(byteMessage[i]).append(byteMessage[i + 1]).append(byteMessage[i + 2]).append(byteMessage[i + 3]); //FINS帧头
						bytes.append(byteMessage[i + 4]).append(byteMessage[i + 5]).append(byteMessage[i + 6]).append(byteMessage[i + 7]); //FINS长度
						
						// FINS的数据区
						for (int j = 0; j < length; j++) {
							bytes.append(byteMessage[i + 8 + j]);
						}
						
						i = i + length + 8;
						bytesList.add(bytes.toBytes());
						count++;
					} else {
						i++;
					}
				} else {
					i++;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			bytesList.clear();
			bytesList.add(byteMessage);
			return bytesList;
		}
		
		if (count == 0) {
			bytesList.add(byteMessage);
		}
		
		return bytesList;
	}

	/**
	 * 将字节数组解析为收到的消息对象
	 * 
	 * @param byte[] byteMessage
	 * @return RecievedMessage
	 */
	public AppMessage bytesToMessage(byte[] byteMessage) {

		AppMessage received = null;

		FINSByteFrame finsFrame = new FINSByteFrame(byteMessage);
		if (!finsFrame.valid) {
			received = new UnKnownMessage(byteMessage);
			received.setTime(Calendar.getInstance());
			return received;
		}

		// 根据不同字节内容，解析为各类型应用消息
		String commandStr = FINSByteFrameTool.getCommandStr(byteMessage);
		
		// 握手消息的响应
		if (commandStr.equalsIgnoreCase("00000001")) {
			received = bytesToLinkCommandResponse(finsFrame);
		}
		
		// 读写命令的响应
		if (commandStr.equalsIgnoreCase("00000002")) {
			String commandCode = FINSByteFrameTool.getFinsCommandCode(byteMessage);
			String commandType = FINSByteFrameTool.getControlSID(byteMessage); //用SID字节来代表命令类型，与APPMessageConstants中的命令类型值保持一致
			if (commandCode.equalsIgnoreCase("0101")) {
				// 读内存命令响应的解析
				
				// 1首先解析出消息的PLC端地址(即响应消息的源地址)和返回的内存内容的字数
				String dest = FINSByteFrameTool.getControlSour(byteMessage); //命令的目标地址即响应消息的源地址
//				int count = FINSByteFrameTool.getDataWithoutEndCode(byteMessage).length / 2; //1WORD=2BYTE
				
				// 2查询数据中最近的有效的读内存命令，获取其读取的参数类型
				PgAcuRdcmdDao readCmdDao = new PgAcuRdcmdDaoImpl();
				PgAcuRdcmd readCmd = readCmdDao.findLatestCmdByDestAndType(dest, commandType);
				if (null != readCmd) {
					// 3根据参数类型调用相应的方法进行解析
					switch(commandType) {
						case AppMessageConstants.CMD_TYPE_READCH4VALUE:
							received = bytesToReadCH4ValueCommandResponse(finsFrame, readCmd);
							break;
						case AppMessageConstants.CMD_TYPE_READCH4STATUS:
							received = bytesToReadCH4StatusCommandResponse(finsFrame, readCmd);
							break;
							
						case AppMessageConstants.CMD_TYPE_READWSVALUE:
							received = bytesToReadWSValueCommandResponse(finsFrame, readCmd);
							break;
						case AppMessageConstants.CMD_TYPE_READWSSTATUS:
							received = bytesToReadWSStatusCommandResponse(finsFrame, readCmd);
							break;
							
						case AppMessageConstants.CMD_TYPE_READCOVALUE:
							received = bytesToReadCOValueCommandResponse(finsFrame, readCmd);
							break;
						case AppMessageConstants.CMD_TYPE_READCOSTATUS:
							received = bytesToReadCOStatusCommandResponse(finsFrame, readCmd);
							break;
							
						case AppMessageConstants.CMD_TYPE_READO2VALUE:
							received = bytesToReadO2ValueCommandResponse(finsFrame, readCmd);
							break;
						case AppMessageConstants.CMD_TYPE_READO2STATUS:
							received = bytesToReadO2StatusCommandResponse(finsFrame, readCmd);
							break;
							
						case AppMessageConstants.CMD_TYPE_READHSVALUE:
							received = bytesToReadHSValueCommandResponse(finsFrame, readCmd);
							break;
						case AppMessageConstants.CMD_TYPE_READHSSTATUS:
							received = bytesToReadHSStatusCommandResponse(finsFrame, readCmd);
							break;
							
						case AppMessageConstants.CMD_TYPE_READYWSTATUS:
							received = bytesToReadYWStatusCommandResponse(finsFrame, readCmd);
							break;
							
						case AppMessageConstants.CMD_TYPE_READDSSTATUS:
							received = bytesToReadDSStatusCommandResponse(finsFrame, readCmd);
							break;
					}
					
					// 4将已响应的命令删除
					readCmdDao.deleteCmdRecord(readCmd.getId());
					
				}
			} else if (commandCode.equalsIgnoreCase("0102")) {
				// 写内存命令响应
			}
		}
		
//		
//		
//
//		default:
//			received = new UnKnownMessage(byteMessage);
//			received.setTime(Calendar.getInstance());
//		}

		return received;
	}

	

	/**
	 * 将握手响应字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToLinkCommandResponse(FINSByteFrame finsFrame) {
		LinkCommandResponse lcr = new LinkCommandResponse();

		byte[] data = finsFrame.TEXT_DATA_BODY;
		if (data.length == 8) {
			String sour = ByteUtil.binToHexString(data, 8, 16); //握手响应消息的源地址，实际上是PLC地址
			String dest = ByteUtil.binToHexString(data, 0, 8); //握手响应消息的目标地址，实际上是本机地址
		
			lcr.setMessageProducerId(sour);
			lcr.setDestinationId(dest);
			lcr.setTime(Calendar.getInstance());
			lcr.setValid(true);
		} else {
			lcr.setValid(false);
			logger.debug("握手命令响应消息数据域长度不符");
		}
		
		return lcr;
	}

	/**
	 * 将查询甲烷参数响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadCH4ValueCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadCH4ValueCommandResponse rcpcr = new ReadCH4ValueCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rcpcr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int chct = cmd.getCount_sensor(); //甲烷监测点的数量
			for (int i = 0; i < chct; i++) {
				byte[] valueByte = new byte[] { data[i*8 + 2], data[i*8 + 3], data[i*8], data[i*8 + 1] };
				byte[] thresholdByte = new byte[] { data[i*8 + 6], data[i*8 + 7], data[i*8 + 4], data[i*8 + 5] };
				
				float value = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(valueByte), 16)); //甲烷浓度值
				float threshold = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(thresholdByte), 16)); //甲烷报警阈值
				
				rcpcr.getJwnd().add(value);
				rcpcr.getJwldbjz().add(threshold);
			}
		}

		return rcpcr;
	}
	
	
	/**
	 * 将查询甲烷报警状态响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadCH4StatusCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadCH4StatusCommandResponse rcscr = new ReadCH4StatusCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rcscr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int chct = cmd.getCount_sensor(); //甲烷监测点的数量
			int bitct = cmd.getCount_bit(); //读取的位的数量，用于计算字节数
			int bytect = (bitct % 16 == 0 ? bitct / 16 : bitct / 16 + 1) * 2;
			String dataStr = "";
			for (int i = 0; i < bytect - 1; i = i + 2) {
				dataStr = ByteUtil.binToBinString(new byte[] { data[i], data[i + 1] }) + dataStr; //D15-D0顺序
			}
			
			for (int i = 0; i < chct; i++) {
				char ldBit = dataStr.charAt(dataStr.length() - 2 * i - 1);
				char bjBit = dataStr.charAt(dataStr.length() - 2 * i - 2);
				
				rcscr.getJwbj().add(bjBit == '1' ? true : false);
				rcscr.getJwldbj().add(ldBit == '1' ? true : false);
			}
		}
	
		return rcscr;
	}

	/**
	 * 将读取温湿度监测值响应字节数组转换为消息对象
	 * 
	 * @param finsFrame
	 * @return
	 */
	private AppMessage bytesToReadWSValueCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadWSValueCommandResponse rwvcr = new ReadWSValueCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rwvcr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int wsct = cmd.getCount_sensor(); //获取传感器数量
			
			int offset = cmd.getOffset(); //获取湿度变量的内存地址偏移量
			offset = offset + wsct * 2 * 2 * 2;
			
			// 解析并存储温度值
			for (int i = 0; i < wsct; i++) {
				byte[] tempValueByte = new byte[] { data[i*8 + 2], data[i*8 + 3], data[i*8], data[i*8 + 1] };
				byte[] tempThresholdByte = new byte[] { data[i*8 + 6], data[i*8 + 7], data[i*8 + 4], data[i*8 + 5] };
				
				float tempValue = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(tempValueByte), 16)); //温度监测值
				float tempThreshold = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(tempThresholdByte), 16)); //温度报警阈值
				
				rwvcr.getWd().add(tempValue);
				rwvcr.getWdbjz().add(tempThreshold);
			}
			
			// 解析并存储湿度值
			for (int i = 0; i < wsct; i++) {
				byte[] humValueByte = new byte[] { data[i*8 + 2 + offset], data[i*8 + 3 + offset], data[i*8 + offset], data[i*8 + 1 + offset] };
				byte[] humThresholdByte = new byte[] { data[i*8 + 6 + offset], data[i*8 + 7 + offset], data[i*8 + 4 + offset], data[i*8 + 5 + offset] };
				
				float humValue = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(humValueByte), 16)); //湿度监测值
				float humThreshold = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(humThresholdByte), 16)); //湿度报警阈值
				
				rwvcr.getSd().add(humValue);
				rwvcr.getSdbjz().add(humThreshold);
			}
		}

		return rwvcr;
	}
	
	
	private AppMessage bytesToReadWSStatusCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadWSStatusCommandResponse rwsscr = new ReadWSStatusCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rwsscr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int wsct = cmd.getCount_sensor(); //温湿度监测点的数量
			
			// 处理温度状态
			String tempDataStr = ByteUtil.binToBinString(new byte[] { data[0], data[1] }); //D15-D0顺序
			for (int i = 0; i < wsct; i++) {
				char ldBit = tempDataStr.charAt(tempDataStr.length() - 2 * i - 1);
				char bjBit = tempDataStr.charAt(tempDataStr.length() - 2 * i - 2);
				
				rwsscr.getWdbj().add(bjBit == '1' ? true : false);
				rwsscr.getWdldbj().add(ldBit == '1' ? true : false);
			}
			
			// 处理湿度状态
			String humDataStr = ByteUtil.binToBinString(new byte[] { data[4], data[5] }); //D15-D0顺序
			for (int i = 0; i < wsct; i++) {
				char ldBit = humDataStr.charAt(humDataStr.length() - 2 * i - 1);
				char bjBit = humDataStr.charAt(humDataStr.length() - 2 * i - 2);
				
				rwsscr.getSdbj().add(bjBit == '1' ? true : false);
				rwsscr.getSdldbj().add(ldBit == '1' ? true : false);
			}
		}
	
		return rwsscr;
	}
	
	
	/**
	 * 将查询一氧化碳参数响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadCOValueCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadCOValueCommandResponse rcovc = new ReadCOValueCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rcovc.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int chct = cmd.getCount_sensor(); //一氧化碳监测点的数量
			for (int i = 0; i < chct; i++) {
				byte[] valueByte = new byte[] { data[i*8 + 2], data[i*8 + 3], data[i*8], data[i*8 + 1] };
				byte[] thresholdByte = new byte[] { data[i*8 + 6], data[i*8 + 7], data[i*8 + 4], data[i*8 + 5] };
				
				float value = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(valueByte), 16)); //一氧化碳浓度值
				float threshold = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(thresholdByte), 16)); //一氧化碳报警阈值
				
				rcovc.getCond().add(value);
				rcovc.getColdbjz().add(threshold);
			}
		}

		return rcovc;
	}
	
	
	/**
	 * 将查询一氧化碳报警状态响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadCOStatusCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadCOStatusCommandResponse rcscr = new ReadCOStatusCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rcscr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int chct = cmd.getCount_sensor(); //一氧化碳监测点的数量
			int bitct = cmd.getCount_bit(); //读取的位的数量，用于计算字节数
			int bytect = (bitct % 16 == 0 ? bitct / 16 : bitct / 16 + 1) * 2;
			String dataStr = "";
			for (int i = 0; i < bytect - 1; i = i + 2) {
				dataStr = ByteUtil.binToBinString(new byte[] { data[i], data[i + 1] }) + dataStr; //D15-D0顺序
			}
			
			for (int i = 0; i < chct; i++) {
				char ldBit = dataStr.charAt(dataStr.length() - 2 * i - 1);
				char bjBit = dataStr.charAt(dataStr.length() - 2 * i - 2);
				
				rcscr.getCobj().add(bjBit == '1' ? true : false);
				rcscr.getColdbj().add(ldBit == '1' ? true : false);
			}
		}
	
		return rcscr;
	}
	
	
	/**
	 * 将查询氧气参数响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadO2ValueCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadO2ValueCommandResponse rovcr = new ReadO2ValueCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rovcr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int o2ct = cmd.getCount_sensor(); //氧气监测点的数量
			for (int i = 0; i < o2ct; i++) {
				byte[] valueByte = new byte[] { data[i*8 + 2], data[i*8 + 3], data[i*8], data[i*8 + 1] };
				byte[] thresholdByte = new byte[] { data[i*8 + 6], data[i*8 + 7], data[i*8 + 4], data[i*8 + 5] };
				
				float value = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(valueByte), 16)); //氧气浓度值
				float threshold = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(thresholdByte), 16)); //氧气报警阈值
				
				rovcr.getO2nd().add(value);
				rovcr.getO2ldbjz().add(threshold);
			}
		}

		return rovcr;
	}
	
	
	/**
	 * 将查询氧气报警状态响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadO2StatusCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadO2StatusCommandResponse roscr = new ReadO2StatusCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		roscr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int o2ct = cmd.getCount_sensor(); //氧气监测点的数量
			int bitct = cmd.getCount_bit(); //读取的位的数量，用于计算字节数
			int bytect = (bitct % 16 == 0 ? bitct / 16 : bitct / 16 + 1) * 2;
			String dataStr = "";
			for (int i = 0; i < bytect - 1; i = i + 2) {
				dataStr = ByteUtil.binToBinString(new byte[] { data[i], data[i + 1] }) + dataStr; //D15-D0顺序
			}
			
			for (int i = 0; i < o2ct; i++) {
				char ldBit = dataStr.charAt(dataStr.length() - 2 * i - 1);
				char bjBit = dataStr.charAt(dataStr.length() - 2 * i - 2);
				
				roscr.getO2bj().add(bjBit == '1' ? true : false);
				roscr.getO2ldbj().add(ldBit == '1' ? true : false);
			}
		}
	
		return roscr;
	}

	
	/**
	 * 将查询硫化氢参数响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadHSValueCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadHSValueCommandResponse rhvcr = new ReadHSValueCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rhvcr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int hsct = cmd.getCount_sensor(); //硫化氢监测点的数量
			for (int i = 0; i < hsct; i++) {
				byte[] valueByte = new byte[] { data[i*8 + 2], data[i*8 + 3], data[i*8], data[i*8 + 1] };
				byte[] thresholdByte = new byte[] { data[i*8 + 6], data[i*8 + 7], data[i*8 + 4], data[i*8 + 5] };
				
				float value = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(valueByte), 16)); //氧气浓度值
				float threshold = Float.intBitsToFloat(Integer.parseInt(ByteUtil.binToHexString(thresholdByte), 16)); //氧气报警阈值
				
				rhvcr.getHsnd().add(value);
				rhvcr.getHsldbjz().add(threshold);
			}
		}

		return rhvcr;
	}
	
	
	/**
	 * 将查询硫化氢报警状态响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadHSStatusCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadHSStatusCommandResponse rhscr = new ReadHSStatusCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rhscr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int hsct = cmd.getCount_sensor(); //硫化氢监测点的数量
			int bitct = cmd.getCount_bit(); //读取的位的数量，用于计算字节数
			int bytect = (bitct % 16 == 0 ? bitct / 16 : bitct / 16 + 1) * 2;
			String dataStr = "";
			for (int i = 0; i < bytect - 1; i = i + 2) {
				dataStr = ByteUtil.binToBinString(new byte[] { data[i], data[i + 1] }) + dataStr; //D15-D0顺序
			}
			for (int i = 0; i < hsct; i++) {
				char ldBit = dataStr.charAt(dataStr.length() - 2 * i - 1);
				char bjBit = dataStr.charAt(dataStr.length() - 2 * i - 2);
				
				rhscr.getHsbj().add(bjBit == '1' ? true : false);
				rhscr.getHsldbj().add(ldBit == '1' ? true : false);
			}
		}
	
		return rhscr;
	}
	
	/**
	 * 将查询爆管液位报警状态响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadYWStatusCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadYWStatusCommandResponse ryscr = new ReadYWStatusCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		ryscr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int ysct = cmd.getCount_sensor(); //爆管液位监测点的数量
			int bitct = cmd.getCount_bit(); //读取的位的数量，用于计算字节数
			int bytect = (bitct % 16 == 0 ? bitct / 16 : bitct / 16 + 1) * 2;
			String dataStr = "";
			for (int i = 0; i < bytect - 1; i = i + 2) {
				dataStr = ByteUtil.binToBinString(new byte[] { data[i], data[i + 1] }) + dataStr; //D15-D0顺序
			}
			for (int i = 0; i < ysct; i++) {
				char bjBit = dataStr.charAt(dataStr.length() - i - 1);
				
				ryscr.getYwbj().add(bjBit == '1' ? true : false);
			}
		}
	
		return ryscr;
	}
	
	/**
	 * 将查询对射报警状态响应消息字节数组转换为消息对象
	 * 
	 * @param byteMessage
	 * @return
	 */
	private AppMessage bytesToReadDSStatusCommandResponse(FINSByteFrame finsFrame, PgAcuRdcmd cmd) {
		ReadDSStatusCommandResponse rdscr = new ReadDSStatusCommandResponse();
		
		byte[] body = finsFrame.TEXT_DATA_BODY;
		rdscr.setMessageProducerId(FINSByteFrameTool.getControlDest(finsFrame));
		if (body[2] == 0x00 && body[3] == 0x00) {
			// 正常返回
			byte[] data = FINSByteFrameTool.getDataWithoutEndCode(finsFrame); //获取返回的内存
			int dsct = cmd.getCount_sensor(); //对射监测点的数量
			int bitct = cmd.getCount_bit(); //读取的位的数量，用于计算字节数
			int bytect = (bitct % 16 == 0 ? bitct / 16 : bitct / 16 + 1) * 2;
			String dataStr = "";
			for (int i = 0; i < bytect - 1; i = i + 2) {
				dataStr = ByteUtil.binToBinString(new byte[] { data[i], data[i + 1] }) + dataStr; //D15-D0顺序
			}
			
			for (int i = 0; i < dsct; i++) {
				char bjBit = dataStr.charAt(dataStr.length() - i * 3 - 1);
				
				rdscr.getDsbj().add(bjBit == '1' ? true : false);
			}
		}
	
		return rdscr;
	}

	/**
	 * 将消息对象解析为字节数组
	 * 
	 * @param SentMessage message
	 * @return byte[]
	 */
	public byte[] messageToBytes(AppMessage message) {
		byte[] frame = null;

		// 握手命令
		if (message instanceof LinkCommand) {
			frame = LinkCommandToBytes((LinkCommand) message);
		}
		
//		// 读取甲烷参数内存命令
//		if (message instanceof ReadCH4ValueCommand) {
//			frame = ReadCH4ValueCommandToBytes((ReadCH4ValueCommand) message);
//		} else if (message instanceof ReadCH4StatusCommand) {
//			frame = ReadCH4StatusCommandToBytes((ReadCH4StatusCommand) message);
//		}
//		
//		// 读取温湿度命令
//		else if (message instanceof ReadWSValueCommand) {
//			frame = ReadWSValueCommandToBytes((ReadWSValueCommand) message);
//		} else if (message instanceof ReadWSStatusCommand) {
//			frame = ReadWSStatusCommandToBytes((ReadWSStatusCommand) message);
//		}
		
		// 读内存命令
		if (message instanceof ReadMemoryCommand) {
			frame = readMemoryCommandToBytes((ReadMemoryCommand) message);
		}
//		
//		// 写内存命令
//		if (message instanceof QueryRealTimeValueCommand) {
//			frame = queryRealTimeValueCommandToBytes((QueryRealTimeValueCommand) message);
//		}
		
		return frame;
	}



	/**
	 * 将握手命令转换为字节数组
	 * 
	 * @param hmr
	 * @return
	 */
	private byte[] LinkCommandToBytes(LinkCommand link) {
		FINSByteFrame finsFrame = new FINSByteFrame(link.getMessageProducerId());

		return finsFrame.toBytes();
	}
	
	/**
	 * 将读取PLC内存命令转换为字节数组
	 * 
	 * @param message
	 * @return
	 */
	private byte[] readMemoryCommandToBytes(ReadMemoryCommand message) {
		byte[] start = ByteUtil.hexStringToBytes(message.getStartAddress(), 3);
		
		FINSByteFrame finsFrame = new FINSByteFrame(message.getDestinationId(), 
													message.getMessageProducerId(), 
													message.getCommandType(),
													message.getMemoryArea(), 
													start, 
													message.getCountWord());
		
		return finsFrame.toBytes();
	}
	
	/**
	 * 将读取甲烷监测值命令转换为字节数组
	 * @param message
	 * @return
	 */
//	private byte[] ReadCH4ValueCommandToBytes(ReadCH4ValueCommand message) {
//		byte[] start = ByteUtil.hexStringToBytes(message.getStartAddress(), 3);
//		
//		FINSByteFrame finsFrame = new FINSByteFrame(message.getDestinationId(), 
//													message.getMessageProducerId(), 
//													message.getMemoryArea(), 
//													start, 
//													message.getCountWord());
//		
//		return finsFrame.toBytes();
//	}

	/**
	 * 将读取甲烷报警状态命令转换为字节数组
	 * @param message
	 * @return
	 */
//	private byte[] ReadCH4StatusCommandToBytes(ReadCH4StatusCommand message) {
//		byte[] start = ByteUtil.hexStringToBytes(message.getStartAddress(), 3);
//		
//		FINSByteFrame finsFrame = new FINSByteFrame(message.getDestinationId(), 
//													message.getMessageProducerId(), 
//													message.getMemoryArea(), 
//													start, 
//													message.getCountWord());
//
//		return finsFrame.toBytes();
//	}
	
	/**
	 * 将读取温湿度监测值命令转换为字节数组
	 * 
	 * @param message
	 * @return
	 */
//	private byte[] ReadWSValueCommandToBytes(ReadWSValueCommand message) {
//		byte[] start = ByteUtil.hexStringToBytes(message.getStartAddress(), 3);
//		
//		FINSByteFrame finsFrame = new FINSByteFrame(message.getDestinationId(), 
//													message.getMessageProducerId(), 
//													message.getMemoryArea(), 
//													start, 
//													message.getCountWord());
//		
//		return finsFrame.toBytes();
//	}
	
	/**
	 * 将读取温湿度报警状态命令转换为字节数组
	 * 
	 * @param message
	 * @return
	 */
//	private byte[] ReadWSStatusCommandToBytes(ReadWSStatusCommand message) {
//		byte[] start = ByteUtil.hexStringToBytes(message.getStartAddress(), 3);
//		
//		FINSByteFrame finsFrame = new FINSByteFrame(message.getDestinationId(), 
//													message.getMessageProducerId(), 
//													message.getMemoryArea(), 
//													start, 
//													message.getCountWord());
//
//		return finsFrame.toBytes();
//	}

}
