package com.dev.lock.comm;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Date;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.base.ComBase;
import com.base.ComFn;
import com.base.Crc16;
import com.config.AppConfig;
import com.dev.lock.data.ElectLock_Array;
import com.dev.lock.data.ElectLock_AuthIdcard;
import com.dev.lock.data.ElectLock_ComBase;
import com.dev.lock.data.ElectLock_Inf;
import com.dev.lock.data.ElectLock_State;
import com.dev.lock.data.ElectLock_Ctl_Log;
import com.dev.modbus.MyModBusRtu;
import com.sql.MysqlConnPool;

public class Lock_SocketClient_Thread extends Thread{
	private MysqlConnPool pool;
	private Socket tmp_socket;
	private Logger logger;
	private AppConfig config;
	
	private ElectLock_State mLock_State;
	
	private ElectLock_State mLock_param;
	
	private String client_ip;			//客户端IP地址
	private int client_id;				//客户端ID-锁具ID
	
	private MyModBusRtu mRtu_Tx;		//发送数据
	private MyModBusRtu mRtu_Rx;		//返回数据
	
	private ElectLock_Inf ele_lock = null;
	
	private ElectLock_Array GB_Lock_Array;
	
	private ByteBuffer bytebuffer_for_socket_RX = ByteBuffer.allocate(15000);
	
	private boolean S_thread_run_flag = true;
	
	private int plat_model;
	
	public Lock_SocketClient_Thread(MysqlConnPool pool,ElectLock_Array GB_Lock_Array ,AppConfig config,Socket tmp_socket) {
		this.pool = pool;
		this.config = config;
		this.tmp_socket = tmp_socket;
		this.GB_Lock_Array = GB_Lock_Array;
		this.client_ip = this.tmp_socket.getInetAddress().getHostAddress();
		
		this.logger = LogManager.getLogger(this);
		this.mRtu_Tx = new MyModBusRtu();
		this.mRtu_Rx = new MyModBusRtu(); 
		this.mLock_State = new ElectLock_State();
		this.mLock_param = new ElectLock_State();
	}
	
	@Override
	public void run() {
		S_thread_run_flag = checkDevceType();
		
		int runCount = 0;
		try {
			if(S_thread_run_flag) {
				mLock_State.setLock_online(1);
				Lock_Task_SQL.insertLock_Rt_Table(pool, client_id, mLock_State);
			}
			while(S_thread_run_flag) {
				
				Lock_Task_SQL.queryElectLockControlCmd(pool,client_id,mLock_param);
				
				if(checkControl(mLock_param.getOp_cmd())) {
					ElectLock_Ctl_Log tmp_log = null;
					
					if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_ClearIdCard) {
						mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_YC, ElectLock_ComBase.LOCK_CLEAR_AUTH_ADDR, ElectLock_ComBase.RegCount_Sigle);
						if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Control_Value))) {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_ClearIdCard_Ack);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_ClearIdCard, true,0,mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						} else {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_Fail);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_ClearIdCard, false,0,mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						}
					}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_REMOTE_OPEN_Lock) {
						mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_YC, ElectLock_ComBase.LOCK_REMOTE_OPEN_ADDR, ElectLock_ComBase.RegCount_Sigle);
						if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Control_Value))) {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_REMOTE_OPEN_Lock_Ack);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_REMOTE_OPEN_Lock, true,0,mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						} else {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_Fail);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_REMOTE_OPEN_Lock, false,0,mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
							
							//远程开锁失败时，记录一笔开锁失败告警
							Lock_Task_SQL.insertRemoteOpenFailAlarm(pool, client_id);
						}
					}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_REMOTE_ReStart) {
						mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_YC, ElectLock_ComBase.LOCK_RESTART_ADDR, ElectLock_ComBase.RegCount_Sigle);
						if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Control_Value))) {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_REMOTE_ReStart_Ack);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_REMOTE_ReStart, true,0,mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						} else {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_Fail);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_REMOTE_ReStart, false,0,mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						}
					}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_SetLockAddr) {
//						mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_STD, ElectLock_ComBase.LOCK_SET_ADDR_ADDR, ElectLock_ComBase.RegCount_Sigle);
//						if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(mLock_param.getLock_addr_set()))) {
//							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_SetLockAddr_Ack);
//							
//							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_SetLockAddr, true,mLock_param.getLock_addr_set(),mLock_param.getCtl_uname());
//							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
//						} else {
//							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_Fail);
//							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_SetLockAddr, false,mLock_param.getLock_addr_set(),mLock_param.getCtl_uname());
//							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
//						}
					}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_AddIdCard) {
						//添加ID卡授权
						mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_MULTY, ElectLock_ComBase.LOCK_Add_ID_AUTH_ADDR, ElectLock_ComBase.RegCount_Double);
						System.out.println("mLock_param.getId_card_set():"+mLock_param.getId_card_set());
						if(SocketComm(mRtu_Tx, ComBase.mkInt32Buffer(mLock_param.getId_card_set()))) {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_AddIdCard_Ack);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_AddIdCard, true,mLock_param.getId_card_set(),mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						} else {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_Fail);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_AddIdCard, false,mLock_param.getId_card_set(),mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						}
					}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_RemoveIdCard) {
						//取消ID卡授权
						mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_MULTY, ElectLock_ComBase.LOCK_Clear_ID_AUTH_ADDR, ElectLock_ComBase.RegCount_Double);
						if(SocketComm(mRtu_Tx, ComBase.mkInt32Buffer(mLock_param.getId_card_set()))) {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_RemoveIdCard_Ack);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_RemoveIdCard, true,mLock_param.getId_card_set(),mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						} else {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_Fail);
							tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_RemoveIdCard, false,mLock_param.getId_card_set(),mLock_param.getCtl_uname());
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
						}
					}
					
					Lock_Task_SQL.updateElectLockControlCmd(pool,client_id,mLock_param);
					tmp_log = null;
				}
				
				
				if((runCount%16) == 0) {
					//读取锁具的实时状态
					mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_READ_INPUT, ElectLock_ComBase.LOCK_REAL_ADDR, ElectLock_State.Reg_Count_Real);
					if(SocketComm(mRtu_Tx, ByteBuffer.allocate(0))) {
						Lock_Task_SQL.updateLock_Rt_Table(pool,client_id,mLock_State);

						Lock_Task_SQL.updateLock_Inf_Table(pool,ele_lock,mLock_State);
						
						//更新锁具状态
						ele_lock.lockRecordState.setLockState(mLock_State);
						
						if(mLock_State.isIDOpen()) {
							String ctl_uname = Lock_Task_SQL.queryKeyInfByKeyNumberTable(pool,mLock_State.getLast_unlock_id());
							ElectLock_Ctl_Log tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_IDCardOpen, true,mLock_State.getLast_unlock_id(),ctl_uname);
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
							mLock_State.setIDOpen(false);
							tmp_log = null;
						}
						
						plat_model =  Lock_Task_SQL.querySystemLockMode(pool);
						if(plat_model != ElectLock_ComBase.CMD_Fail) {
							if(plat_model != mLock_State.getWorkmodel()) {
								logger.info("LockID:"+client_id + " Start change Model :");
								
								mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_STD, ElectLock_ComBase.LOCK_SET_Model_ADDR, ElectLock_ComBase.RegCount_Sigle);
								if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(plat_model))) {
									//远程设置锁具在离线模式后最多重启设备3次
									for(int k = 0 ;k < 3;k++) {
										mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_YC, ElectLock_ComBase.LOCK_RESTART_ADDR, ElectLock_ComBase.RegCount_Sigle);
										if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Control_Value))) {
											//重启锁具成功
											break;
										}	
									}
									Thread.sleep(1000);
								}
							}
						}
					}
				}
				
				List<ElectLock_AuthIdcard> batch_auth = Lock_Task_SQL.queryAuth_Idcard_Table(pool,client_id);
				if(batch_auth.size() > 0) {
					logger.info("开始批量授权ID卡,ID数量：" + batch_auth.size());
					for(int k = 0; k < batch_auth.size() ; k++) {
						ElectLock_AuthIdcard tmp_auth = batch_auth.get(k);
						ElectLock_Ctl_Log tmp_log = null;
						try {
							int keyNumber = Integer.parseInt(tmp_auth.key_number.trim());
							if(tmp_auth.state == ElectLock_AuthIdcard.AuthType_ReMove) {
								//取消ID卡授权
								mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_MULTY, ElectLock_ComBase.LOCK_Clear_ID_AUTH_ADDR, ElectLock_ComBase.RegCount_Double);
								if(SocketComm(mRtu_Tx, ComBase.mkInt32Buffer(keyNumber))) {
									tmp_auth.auth_result = ElectLock_ComBase.Auth_Success;
									tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_RemoveIdCard, true,keyNumber,tmp_auth.ctl_uname);
									Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
								} else {
									tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_RemoveIdCard, false,keyNumber,tmp_auth.ctl_uname);
									Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
								}
							}else if(tmp_auth.state == ElectLock_AuthIdcard.AuthType_Add) {
								//添加授权
								mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_WRITE_MULTY, ElectLock_ComBase.LOCK_Add_ID_AUTH_ADDR, ElectLock_ComBase.RegCount_Double);
								if(SocketComm(mRtu_Tx, ComBase.mkInt32Buffer(keyNumber))) {
									tmp_auth.auth_result = ElectLock_ComBase.Auth_Success;
									tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_AddIdCard, true,keyNumber,tmp_auth.ctl_uname);
									Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
								} else {
									tmp_log = new ElectLock_Ctl_Log(client_id, ElectLock_ComBase.CtlType_AddIdCard, false,keyNumber,tmp_auth.ctl_uname);
									Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
								}
							}
						} catch (Exception e) {
							tmp_auth.auth_result = ElectLock_ComBase.Auth_Fail;
						} finally {
							tmp_log = null;
						}
						Lock_Task_SQL.moveAuth_Idcard_Table(pool, tmp_auth);
					}
					
				}
				batch_auth = null;
				
				runCount ++;
				if(runCount > 99999900) {
					runCount = 0;
				}
				Thread.sleep(200);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			logger.info("设备断开连接：DevIp:" + client_ip + " DevId:" + mLock_State.getLockDevId());
			mLock_State.setLock_online(0);
			//重置mac地址会影响app开始，待定逻辑
			//mLock_State.resetLockMacAddr();
			Lock_Task_SQL.updateLock_Inf_Table(pool,ele_lock,mLock_State);
		}

		if(null != tmp_socket) {
			try {
				tmp_socket.close();
			} catch (IOException e) {
				logger.error(e.toString(),e);
			}
		}
	}
	
	
	
	
	
	private boolean checkControl(int op_cmd) {
		boolean isCheckOk = false;
		switch(op_cmd) {
			case ElectLock_ComBase.CMD_ClearIdCard:;				//清空所有授权卡
			case ElectLock_ComBase.CMD_REMOTE_OPEN_Lock:			//远程开锁
			case ElectLock_ComBase.CMD_REMOTE_ReStart:				//远程重启
			case ElectLock_ComBase.CMD_SetLockAddr:					//设置锁具地址
			case ElectLock_ComBase.CMD_AddIdCard:					//添加授权卡ID
			case ElectLock_ComBase.CMD_RemoveIdCard:				//移除授权卡ID
				isCheckOk = true;break;
			default :
				isCheckOk = false;break;
		}
		return isCheckOk;
	}

	/**
	 * 	检测当前设备是否合法
	 * @return
	 */
	private boolean checkDevceType() {
		boolean isCheckOk = false;
		logger.info("DevIp: " + client_ip + " Check Lock Type:" + config.getCommType());
		for(int k = 0 ;k < 3;k++) {
			try {
				if(config.getCommType().toUpperCase().equals("IP")) {
					//通过IP地址识别锁具
					for(int m = 0; m < GB_Lock_Array.getIteamCount();m++) {
						ElectLock_Inf tmp_lock = GB_Lock_Array.getIteam(m);
						if(tmp_lock.getLock_ip().equals(client_ip)) {
							ele_lock = tmp_lock;
							mLock_State = ele_lock.lockState;
							client_id = ele_lock.getLock_id();
							mLock_State.setClient_ip(client_ip);
							isCheckOk = true;
						}
					}
				}else {
					//通过ID号识别锁具
					mRtu_Tx.mkBusRtu(MyModBusRtu.CMD_TYPE_READ_INPUT, ElectLock_ComBase.LOCK_REAL_ADDR, ElectLock_State.Reg_Count_Real);
					if(SocketComm(mRtu_Tx, ByteBuffer.allocate(0))){
						//System.err.println(mLock_State);
						//System.out.println("mLock_State.getLockDevId():"+mLock_State.getLockDevId());
						
						for(int m = 0; m < GB_Lock_Array.getIteamCount();m++) {
							ElectLock_Inf tmp_lock = GB_Lock_Array.getIteam(m);
							if(tmp_lock.getLock_id() == mLock_State.getLockDevId()) {
								
								ele_lock = tmp_lock;
								mLock_State = ele_lock.lockState;
								client_id = ele_lock.getLock_id();
								mLock_State.setClient_ip(client_ip);
								isCheckOk = true;
							}
						}
					}
				}
				if(isCheckOk) {
					break;
				}
				
				Thread.sleep(20);
			} catch (InterruptedException e) {
				logger.error(e.toString(),e);
			}
		}
		if(isCheckOk) {
			logger.info("DevIp: " + client_ip + "识别成功；LockId:" + client_id);
		}else {
			logger.info("DevIp: " + client_ip + "识别失败 ！！！");
		}
		
		return isCheckOk;
	}

	/**
     *	 向指定的socket通道发送数据，以及接收数据
     * @return
     */
    public boolean SocketComm(MyModBusRtu rtu,ByteBuffer byteBuffer)
    {
        boolean res_t = false;
        InputStream in = null;
        OutputStream out = null;
        try
        {
            if(null != this.tmp_socket && !this.tmp_socket.isClosed())
            {
                in = this.tmp_socket.getInputStream();
                out = this.tmp_socket.getOutputStream();
                //----------------- clear rx buff for tcp resend packet ----------------//
                byte[] rx_buf_t = new byte[1024];

                //----------------------------------------------------------------------//
                bytebuffer_for_socket_RX.order(ByteOrder.LITTLE_ENDIAN);
                bytebuffer_for_socket_RX.clear();
                //--------------------- socket write -----------------------------------//
                //--------------------- socket write -----------------------------------//
                /**
                 * 	发送命令前清空数据流中的之前存在的数据保证数据传输
                 */
                int buf_clr_read_count = 0;
                while(in.available() > 0) {
		        	int len = in.read(rx_buf_t);
		        	if(++buf_clr_read_count >= 10) {
		        		res_t = false;
		        		return res_t;
		        	}
		        	try {
						sleep(50);
					} catch (Exception e) {
						logger.error(e.toString(), e);
					}
		        }
                
                byte[] plain_tx_t = makeCommBuf(rtu, byteBuffer);
                Date d1 = new Date();
                int rx_read_time_out = 0;
                //int rx_len = 0;
                logger.debug("数据长度" + plain_tx_t.length + "\t发送数据:" + ComFn.bytesToHexString(plain_tx_t, plain_tx_t.length));
                out.write(plain_tx_t);
                out.flush();
               
                while(true) {
                    if(in.available() > 0) {
                        rx_read_time_out = 0;
                        int rx_len_t = in.read(rx_buf_t);
                        if((bytebuffer_for_socket_RX.position()+rx_len_t)
                                < (bytebuffer_for_socket_RX.capacity()-1)) {
                            bytebuffer_for_socket_RX.put(rx_buf_t, 0, rx_len_t);
                        }
                        //bytebuffer_for_socket_RX.put((byte)in.read());
                    } else {
                        rx_read_time_out++;
                        if(/*(bytebuffer_for_socket_RX.position() >= 20) && */(rx_read_time_out>100)){
                            //	res = true;
                            break;
                        }
                        if(rx_read_time_out > 800) {
                            break;
                        }
                    }
                    Thread.sleep(10);
                }

                bytebuffer_for_socket_RX.flip();

                Date d2 = new Date();
                /*long comm_tms = (d2.getTime() - d1.getTime());
                if(comm_tms < 200) {
                    Thread.sleep(200 - comm_tms);
                }*/
		        /*
		        System.out.println(this.getName()
		        					+ "  dev_id: " + m_StatAndParam.dev_id
		        					+ "  d2-d1:" + (comm_tms)+"ms"
		        					+ "  rx_len:" + bytebuffer_for_socket_RX.limit()
		        					+ "  tx_count:" + m_FBS_VCData.m_SysState.CommCount
		        					+ "  rx_err_sum:" + m_FBS_VCData.m_SysState.ErrCommCount
		        					+ "  rx_err_count:" + rx_errcount_for_live_of_thread
		        					+ Com.getNowTimeWithAt());
		        */
                byte[] cipher_buf = new byte[bytebuffer_for_socket_RX.limit()];
                bytebuffer_for_socket_RX.get(cipher_buf);
                
                
                logger.debug("数据长度"+cipher_buf.length+"\t返回数据："+ ComFn.bytesToHexString(cipher_buf, cipher_buf.length));
                //Log.e(TAG, "SocketComm: "+ComFn.bytesToHexString(plain_buf, plain_buf.length));
                if(cipher_buf.length > MyModBusRtu.BYTE_LEN && true == getDataFromCommBuf(cipher_buf,rtu)) {
                	res_t = true; 
                	
                	mLock_State.addCommCount();
                	mLock_State.clearErrorCount();
                } else {
                	//System.err.println("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD");
                	
                	res_t = false;
                	
                	mLock_State.addErrorCount();
                }
            } else {
                //System.out.println(this.getName() + "-------socket  异常关闭-------" + Com.getNowTimeWithAt());
            	S_thread_run_flag = false;
            }
        } catch (IOException | InterruptedException e) {
        	this.mLock_State.addErrorCount();
        } finally {
        	if(this.mLock_State.getErr_count() > 4) {
        		logger.info("设备：DevIp:" + client_ip + " DevId:" + client_id + "通信超时即将断开连接...");
        		S_thread_run_flag = false;
        	}
        }
        return res_t;
    }
    
    

	private boolean getDataFromCommBuf(byte[] bbf_rx, MyModBusRtu rtu) {
		boolean isSuccess = false;
		ByteBuffer buff = ByteBuffer.allocate(bbf_rx.length);
		buff.order(ByteOrder.BIG_ENDIAN);
		buff.put(bbf_rx);
		buff.flip();
		mRtu_Rx.putByteBuffer(buff);
		if(MyModBusRtu.CMD_TYPE_READ_INPUT == mRtu_Rx.Cmd) {
			if(ElectLock_ComBase.LOCK_REAL_ADDR == rtu.reg_addr) {
				//读取实时数据
				if(mLock_State.putByteBuffer(buff)) {
					isSuccess = true;					
				}
			}
		}else if(MyModBusRtu.CMD_TYPE_WRITE_YC == mRtu_Rx.Cmd) {
			if(ElectLock_ComBase.LOCK_CLEAR_AUTH_ADDR == mRtu_Rx.reg_addr) {
				//清空所有授权卡
				if(ElectLock_ComBase.Control_Value == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + client_id + " LockIp:"+client_ip + "清空所有授权卡成功");
				}
			}else if(ElectLock_ComBase.LOCK_REMOTE_OPEN_ADDR == mRtu_Rx.reg_addr) {
				//远程开锁
				if(ElectLock_ComBase.Control_Value == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + client_id + " LockIp:"+client_ip + " 远程开锁成功");
				}
			}else if(ElectLock_ComBase.LOCK_RESTART_ADDR == mRtu_Rx.reg_addr) {
				//远程重启
				if(ElectLock_ComBase.Control_Value == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + client_id + " LockIp:"+client_ip + " 远程重启锁具成功");
				}
			}
		}else if(MyModBusRtu.CMD_TYPE_WRITE_STD == mRtu_Rx.Cmd) {
			if(ElectLock_ComBase.LOCK_SET_ADDR_ADDR == mRtu_Rx.reg_addr) {
				//设置锁具地址
				if(mLock_param.getLock_addr_set() == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + client_id + " LockIp:"+client_ip + " 设置锁具地址：" + mLock_param.getLock_addr_set() + "成功");
				}
			}else if(ElectLock_ComBase.LOCK_SET_Model_ADDR == mRtu_Rx.reg_addr) {
				//设置锁具工作模式
				if(plat_model == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + client_id + " LockIp:"+client_ip + " 设置锁具模式：" + plat_model + "成功");
				}
			}
			
			
		}else if(MyModBusRtu.CMD_TYPE_WRITE_MULTY == mRtu_Rx.Cmd) {
			if(ElectLock_ComBase.LOCK_Add_ID_AUTH_ADDR == mRtu_Rx.reg_addr) {
				//添加授权ID卡
				if(ElectLock_ComBase.RegCount_Double == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + client_id + " LockIp:"+client_ip + " 添加授权ID卡：" + mLock_param.getId_card_set() + "成功");
				}
			}else if(ElectLock_ComBase.LOCK_Clear_ID_AUTH_ADDR == mRtu_Rx.reg_addr) {
				//取消授权ID卡
				if(ElectLock_ComBase.RegCount_Double == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + client_id + " LockIp:"+client_ip + " 取消授权ID卡：" + mLock_param.getId_card_set() + "成功");
				}
			}
		}
		return isSuccess;
	}

	private static byte[] makeCommBuf(MyModBusRtu rtu, ByteBuffer byteBuffer) {
		//
		ByteBuffer bf = rtu.mkByteBuffer();
		ByteBuffer buffer = ByteBuffer.allocate(bf.limit() + byteBuffer.limit() + 2);
		buffer.order(ByteOrder.BIG_ENDIAN);
		buffer.position(0);
		buffer.put(bf);
		buffer.put(byteBuffer);
		int crc = Crc16.CalCRC16(buffer, buffer.position()) & 0xFFFF;
		buffer.putShort((short) crc);		
		buffer.flip();
		return buffer.array();
	}
}