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_Bl;
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 = new ElectLock_State[ElectLock_ComBase.Lock_MaxLineCount];
	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 = new ElectLock_Inf[ElectLock_ComBase.Lock_MaxLineCount];
	
	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;
	
	private int MaxLockCount;
	private int NowLockIdx = 0;		//当前读取状态的锁具索引
	
	private int ErrorCount = 0;		//连续错误计数,连接错误计数
	
	private ElectLock_Bl bl = null;
	
	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(); 
		
		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((mLock_param.getLockAddr()%255),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(mLock_param.getLock_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(mLock_param.getLock_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((mLock_param.getLockAddr()%255),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(mLock_param.getLock_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(mLock_param.getLock_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, mLock_param.getLock_id());
						}
					}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_REMOTE_ReStart) {
						mRtu_Tx.mkBusRtu((mLock_param.getLockAddr()%255),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(mLock_param.getLock_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(mLock_param.getLock_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((mLock_param.getLockAddr()%255),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(mLock_param.getLock_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(mLock_param.getLock_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((mLock_param.getLockAddr()%255),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(mLock_param.getLock_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(mLock_param.getLock_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);
						}
					}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_OpenBluetooth) {
						//开启蓝牙
						mRtu_Tx.mkBusRtu((mLock_param.getLockAddr()%255),MyModBusRtu.CMD_TYPE_WRITE_STD, ElectLock_ComBase.LOCK_SET_Bluetooth_ADDR, ElectLock_ComBase.RegCount_Sigle);
						//System.out.println("mLock_param.getId_card_set():"+mLock_param.getId_card_set());
						if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Lock_Bluetooth_Open))) {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_OpenBluetooth_Ack);
							//tmp_log = new ElectLock_Ctl_Log(mLock_param.getLock_id(), ElectLock_ComBase.CtlType_BluetoothOpen, 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(mLock_param.getLock_id(), ElectLock_ComBase.CtlType_BluetoothOpen, 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_CloseBluetooth) {
						//关闭蓝牙
						mRtu_Tx.mkBusRtu((mLock_param.getLockAddr()%255),MyModBusRtu.CMD_TYPE_WRITE_STD, ElectLock_ComBase.LOCK_SET_Bluetooth_ADDR, ElectLock_ComBase.RegCount_Sigle);
						if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Lock_Bluetooth_Close))) {
							mLock_param.setOp_cmd(ElectLock_ComBase.CMD_CloseBluetooth_Ack);
							//tmp_log = new ElectLock_Ctl_Log(mLock_param.getLock_id(), ElectLock_ComBase.CtlType_BluetoothClose, 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(mLock_param.getLock_id(), ElectLock_ComBase.CtlType_BluetoothClose, false,0,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%(17/MaxLockCount)) == 1) {
					//读取锁具的实时状态
					mRtu_Tx.mkBusRtu((mLock_State[NowLockIdx].getLockAddr()%255),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,ele_lock[NowLockIdx].getLock_id(),mLock_State[NowLockIdx]);

						Lock_Task_SQL.updateLock_Inf_Table(pool,ele_lock[NowLockIdx],mLock_State[NowLockIdx]);
						
						//更新锁具状态
						ele_lock[NowLockIdx].lockRecordState.setLockState(mLock_State[NowLockIdx]);
						
						if(mLock_State[NowLockIdx].isIDOpen()) {
//							String ctl_uname = Lock_Task_SQL.queryKeyInfByKeyNumberTable(pool,mLock_State[NowLockIdx].getLast_unlock_id());
							String ctl_uname = "";
							ElectLock_Ctl_Log tmp_log = new ElectLock_Ctl_Log(mLock_State[NowLockIdx].getLock_id(), ElectLock_ComBase.CtlType_IDCardOpen, true,mLock_State[NowLockIdx].getLast_unlock_id(),ctl_uname);
							Lock_Task_SQL.insertLock_Ctl_Log_Table(pool, tmp_log);
							mLock_State[NowLockIdx].setIDOpen(false);
							tmp_log = null;
						}
						
						plat_model =  Lock_Task_SQL.querySystemLockMode(pool);
						if(plat_model != ElectLock_ComBase.CMD_Fail) {
							if(plat_model != mLock_State[NowLockIdx].getWorkmodel()) {
								logger.info("LockID:"+mLock_State[NowLockIdx].getLock_id() + " Start change Model :");
								
								mRtu_Tx.mkBusRtu((mLock_State[NowLockIdx].getLockAddr()%255),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);
								}
							}
						}
					}
					
					//查询当前蓝牙开启计划
					bl = Lock_Task_SQL.queryBluetoothOpenPlan(pool, ele_lock[NowLockIdx].getLock_id());
					if(null != bl) {
						//有启用的计划，定时开启蓝牙
						if(mLock_State[NowLockIdx].getBluetooth_state() == ElectLock_ComBase.Lock_Bluetooth_Close) {
							mRtu_Tx.mkBusRtu((mLock_State[NowLockIdx].getLockAddr()%255),MyModBusRtu.CMD_TYPE_WRITE_STD, ElectLock_ComBase.LOCK_SET_Bluetooth_ADDR, ElectLock_ComBase.RegCount_Sigle);
							//System.out.println("mLock_param.getId_card_set():"+mLock_param.getId_card_set());
							if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Lock_Bluetooth_Open))){
								logger.info("定时开启蓝牙成功");
							}else {
								logger.info("定时开启蓝牙失败");
							}
						}
						bl = null;
					}
					//查询当前蓝牙关闭计划
					bl = Lock_Task_SQL.queryBluetoothClosePlan(pool, ele_lock[NowLockIdx].getLock_id());
					if(null != bl) {
						//有启用的计划，定时关闭蓝牙
						if(mLock_State[NowLockIdx].getBluetooth_state() == ElectLock_ComBase.Lock_Bluetooth_Open) {
							mRtu_Tx.mkBusRtu((mLock_State[NowLockIdx].getLockAddr()%255),MyModBusRtu.CMD_TYPE_WRITE_STD, ElectLock_ComBase.LOCK_SET_Bluetooth_ADDR, ElectLock_ComBase.RegCount_Sigle);
							//System.out.println("mLock_param.getId_card_set():"+mLock_param.getId_card_set());
							if(SocketComm(mRtu_Tx, ComBase.mkUInt16Buffer(ElectLock_ComBase.Lock_Bluetooth_Close))){
								logger.info("定时关闭蓝牙成功");
							}else {
								logger.info("定时关闭蓝牙失败");
							}
						}
						bl = null;
					}
					
					
					int cnt = mLock_State[NowLockIdx].getReadCount()%4;
					if(cnt == 0 || cnt == 1) {
						logger.error(mLock_State[NowLockIdx].getLock_id() + " ReadIDCardCount " + cnt);
						mRtu_Tx.mkBusRtu((mLock_State[NowLockIdx].getLockAddr()%255),MyModBusRtu.CMD_TYPE_READ_INPUT, (ElectLock_ComBase.LOCK_IDCard1_ADDR + cnt*100), ElectLock_State.Reg_Count_Card);
						if(SocketComm(mRtu_Tx, ByteBuffer.allocate(0))) {
							//更新当前锁具的ID卡
							Lock_Task_SQL.updateLock_IdCard_Table(pool, mLock_State[NowLockIdx]);
						}
					}
					
					NowLockIdx ++;
					if(NowLockIdx >= MaxLockCount) {
						NowLockIdx = 0;
					}
				}
				
//				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(100);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			logger.info("设备断开连接：DevIp:" + client_ip + " DevId:" + client_id/10000 + "XXXX");
			//重置mac地址会影响app开始，待定逻辑
			//mLock_State.resetLockMacAddr();
			Lock_Task_SQL.updateLock_OffLineTable(pool,client_id);
		}

		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
			case ElectLock_ComBase.CMD_OpenBluetooth:				//开启蓝牙
			case ElectLock_ComBase.CMD_CloseBluetooth:				//关闭蓝牙
				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());
		MaxLockCount = 0 ;			//连接锁具数量
		try {
			//通过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)) {
					if(client_id == 0) {
						client_id = tmp_lock.getLock_id();
						isCheckOk = true;
					}else {
						if((client_id/10000) != (tmp_lock.getLock_id()/10000)) {
							continue;
						}
					}					
					ele_lock[MaxLockCount] = tmp_lock;
					mLock_State[MaxLockCount] = ele_lock[MaxLockCount].lockState;
					mLock_State[MaxLockCount].setClient_ip(client_ip);
					MaxLockCount ++;
				}
			}
			
		} catch (Exception e) {
			logger.error(e.toString(),e);
		}
		if(isCheckOk) {
			logger.info("DevIp: " + client_ip + "识别成功；LockId:" + client_id + "\t 锁具数量：" + MaxLockCount);
			if(MaxLockCount == 0) {
				isCheckOk = false;
			}
		}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() >= 8) && (rx_read_time_out>10)){
                            //	res = true;
                            break;
                        }
                        if(rx_read_time_out > 80) {
                            break;
                        }
                    }
                    Thread.sleep(10);
                }

                bytebuffer_for_socket_RX.flip();

                Date d2 = new Date();
                
                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[NowLockIdx].addCommCount();
                	mLock_State[NowLockIdx].clearErrorCount();
                	clearErrorCount();
                } else {
                	//System.err.println("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD");
                	
                	res_t = false;
                	
                	mLock_State[NowLockIdx].addErrorCount();
                	addErrorCount();
                }
            } else {
                //System.out.println(this.getName() + "-------socket  异常关闭-------" + Com.getNowTimeWithAt());
            	S_thread_run_flag = false;
            }
        } catch (IOException | InterruptedException e) {
        	this.mLock_State[NowLockIdx].addErrorCount();
        	addErrorCount();
        } finally {
        	if(getErrorCount() > 10) {
        		logger.info("设备：DevIp:" + client_ip + " DevId:" + client_id/10000 + "XXXX 通信超时即将断开连接...");
        		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[NowLockIdx].putByteBuffer(buff)) {
					isSuccess = true;					
				}
			}else if(ElectLock_ComBase.LOCK_IDCard1_ADDR == rtu.reg_addr) {
				//读取前50个ID卡号
				if(mLock_State[NowLockIdx].putCardByteBuffer(buff,0)) {
					isSuccess = true;					
				}
			}else if(ElectLock_ComBase.LOCK_IDCard2_ADDR == rtu.reg_addr) {
				//读取后50个ID卡号
				if(mLock_State[NowLockIdx].putCardByteBuffer(buff,50)) {
					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:" + mLock_param.getLock_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:" + mLock_param.getLock_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:" + mLock_param.getLock_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:" + mLock_param.getLock_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:" + mLock_param.getLock_id() + " LockIp:"+client_ip + " 设置锁具模式：" + plat_model + "成功");
				}
			}else if(ElectLock_ComBase.LOCK_SET_Model_ADDR == mRtu_Rx.reg_addr) {
				//设置锁具工作模式
				if(plat_model == mRtu_Rx.result) {
					isSuccess = true;
					logger.info("LockId:" + mLock_param.getLock_id() + " LockIp:"+client_ip + " 设置锁具模式：" + plat_model + "成功");
				}
			}else if(ElectLock_ComBase.LOCK_SET_Bluetooth_ADDR == mRtu_Rx.reg_addr) {
				//设置锁具蓝牙状态
				if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_OpenBluetooth) {
					if(mRtu_Rx.result == ElectLock_ComBase.Lock_Bluetooth_Open) {
						isSuccess = true;
						logger.info("LockId:" + mLock_param.getLock_id() + " LockIp:"+client_ip + " 设置开启锁具蓝牙成功");
					}
				}else if(mLock_param.getOp_cmd() == ElectLock_ComBase.CMD_CloseBluetooth) {
					if(mRtu_Rx.result == ElectLock_ComBase.Lock_Bluetooth_Close) {
						isSuccess = true;
						logger.info("LockId:" + mLock_param.getLock_id() + " LockIp:"+client_ip + " 设置锁具关闭蓝牙成功");
					}
				}else if(null != bl) {
					if(mRtu_Rx.result == ElectLock_ComBase.Lock_Bluetooth_Close || mRtu_Rx.result == ElectLock_ComBase.Lock_Bluetooth_Open) {
						isSuccess = true;
						logger.info("LockId:" + mLock_param.getLock_id() + " LockIp:"+client_ip + " 设置锁具关闭蓝牙成功");
					}
				}
				
				
			}
			
			
		}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();
	}
	
	/**
	 * 	累加错误计数
	 */
	public void addErrorCount() {
		ErrorCount ++;
	}
	
	public void clearErrorCount() {
		ErrorCount = 0;
	}
	
	public int getErrorCount() {
		return ErrorCount;
	}
	
	public static void main(String[] args) {
		for(int k = 1;k<1000;k++) {
			System.out.println(k%(16/k));
		}
	}
	
}