huimv-farm-env-input/huimv-env-input-water/src/main/java/com/huimv/env/input/server/EnvInputServerHandler.java

package com.huimv.env.input.server;

import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.huimv.env.common.entity.EnvElectricity;
import com.huimv.env.common.entity.EnvWarning;
import com.huimv.env.common.entity.EnvWater;
import com.huimv.env.common.service.IEnvElectricityService;
import com.huimv.env.common.service.IEnvWaterService;
import com.huimv.env.input.utils.ModBusUtils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;

import io.netty.channel.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.math.BigDecimal;
import java.nio.charset.Charset;
import java.text.ParseException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static com.huimv.env.input.utils.ModBusUtils.hexStr2Bytes;

/**
 * @Project : huimv.shiwan
 * @Package : com.huimv.biosafety.uface.controller
 * @Description : TODO
 * @Version : 1.0
 * @Author : ZhuoNing
 * @Create : 2020-12-25
 **/
@ChannelHandler.Sharable
@Component
@Slf4j
public class EnvInputServerHandler extends ChannelInboundHandlerAdapter {
    private StringBuilder askTextSb = null;
    @Autowired
    private IEnvWaterService envWaterService;

    @Autowired
    private IEnvElectricityService envElectricityService;
    //
    public void appendClientAsk(String text) {
        if (this.askTextSb == null) {
            askTextSb = new StringBuilder();
        }
        askTextSb.append(text);
    }


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Channel channel = ctx.channel();
        ByteBuf byteBuf = (ByteBuf) msg;

        byte[] bytes = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(bytes);
        String str = ModBusUtils.bytes2HexString(bytes);
        System.out.println("收到的数据："+str);
        String cmd = saveWaterAndEle(str);
        Thread.sleep(5*60*1000);
        System.out.println(cmd);
        channel.writeAndFlush(Unpooled.copiedBuffer(hexStr2Bytes(cmd)));
        super.channelRead(ctx, msg);
    }

    private String saveWaterAndEle(String str) {
        String[] s = str.split(" ");

        //读水表
        String cmd ="1D 03 00 00 00 02 C6 57";
        //读电表
//        String cmd ="1C 04 01 00 00 02 73 BA";
        if (s.length>10 || s.length<7){
            return cmd;
        }
        String val = s[3]+s[4]+s[5]+s[6];
        System.out.println("val=" +val);
        Date now = new Date();
        //水表
        if (str.startsWith("1D 03")){
            System.out.println("水表");
            int waterOrigValue = Integer.parseInt(val, 16);
            BigDecimal bigDecimal = new BigDecimal(waterOrigValue);
            EnvWater oldEnvWater = envWaterService.getOne(new QueryWrapper<EnvWater>().orderByDesc("id").last("limit 1"));
            BigDecimal originalValue = oldEnvWater.getOriginalValue();
            EnvWater envWater = new EnvWater();
            envWater.setOriginalValue(bigDecimal);
            int i = bigDecimal.compareTo(originalValue);
            if (ObjectUtil.isNotEmpty(oldEnvWater) && i>0){
                envWater.setHandleValue(bigDecimal.subtract(oldEnvWater.getOriginalValue()).divide(new BigDecimal(100)));
            }
            envWater.setUpdateTime(now);
            envWater.setFarmId(27);
            envWaterService.save(envWater);
            cmd = "1C 04 01 00 00 02 73 BA";
        }
        //电表
        if (str.startsWith("1C 04")){
            try {
                    System.out.println("电表");
                    int eleOrigValue = Integer.parseInt(val, 16);
                    Float f =  Float.intBitsToFloat(eleOrigValue);
                    BigDecimal bigDecimal = new BigDecimal(f);
                    EnvElectricity oldEnvWater = envElectricityService.getOne(new QueryWrapper<EnvElectricity>().orderByDesc("id").last("limit 1"));
                    BigDecimal originalValue = oldEnvWater.getOriginalValue();
                    EnvElectricity envElectricity = new EnvElectricity();
                    envElectricity.setOriginalValue(bigDecimal);
                    int i = bigDecimal.compareTo(originalValue);
                    if (ObjectUtil.isNotEmpty(oldEnvWater) && i>0){
                        envElectricity.setHandleValue(bigDecimal.subtract(oldEnvWater.getOriginalValue()));
                    }
                    envElectricity.setUpdateTime(now);
                    envElectricity.setFarmId(27);
                    envElectricityService.save(envElectricity);
                }catch (Exception e){
                    System.out.println(e);
                }
        }
        return cmd;
    }




    private Integer countWeight(String[] s) {
        int count = 48;
        return (Integer.parseInt(s[8], 16) -count)
                 +((Integer.parseInt(s[9], 16) -count) * 16)
                 +((Integer.parseInt(s[10], 16) -count) * 256)
                 +((Integer.parseInt(s[11], 16) -count) * 4096)
                 +((Integer.parseInt(s[12], 16) -count) * 6556);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

//        if (true){
//            ctx.writeAndFlush(Unpooled.copiedBuffer(new byte[]{1, 2, 3}));
//        }

//        if (askTextSb.toString().indexOf("end") != -1) {
//            // {处理客户端消息}


//            handleClientAskCmd(askTextSb.toString(), ctx);
//            //清空重置;
//            askTextSb.delete(0, askTextSb.length());
//        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        if (cause.getMessage().indexOf("Connection reset") != -1) {
            log.info("相关采集器设备正在重启:" + cause.toString());
        }
//        cause.printStackTrace();
        ctx.close();
    }

    /**
     * @Method : handleClientAskCmd
     * @Description : 处理请求小心
     * @Params : [clientAskText, ctx]
     * @Return : void
     * @Author : ZhuoNing
     * @Date : 2022/3/28
     * @Time : 17:36
     */
    private void handleClientAskCmd(String clientAskText, ChannelHandlerContext ctx) throws ParseException, IOException {
        clientAskText = clientAskText.replaceAll("\r", "").replaceAll("\n", "");
        //{处理非正常命令}
//        int countPlus = regexUtil.countPlus(clientAskText);
//        if (countPlus < 4) {
//            System.out.println("当前数据为不完整数据，故丢弃.>>" + clientAskText);
//        } else {
        //--处理客户端请求数据
        //{拆分粘包数据}
        JSONArray askJa = parseAskCmdPackage(clientAskText);
        for (int a = 0; a < askJa.size(); a++) {
            String askText = askJa.getString(a);
            //{处理请求命令}
            askCmdActuator(askText, ctx);
        }
//        }
    }

    /**
     * @Method : askCmdActuator
     * @Description :
     * @Params : [askText, ctx]
     * @Return : void
     * @Author : ZhuoNing
     * @Date : 2022/3/23
     * @Time : 18:08
     */
    private void askCmdActuator(String askText, ChannelHandlerContext ctx) throws ParseException, IOException {
        System.out.println("======>接收设备请求:" + askText);
        String[] dataArray = askText.split("\\+");
        String cmdHeader = dataArray[0];
        if (!cmdHeader.trim().equalsIgnoreCase("hm")) {
            log.info("当前命令是非hm命令[" + askText + "]");
            return;
        }
        //芯片id/设备编码
        String idCode = dataArray[1];
        String cmd = dataArray[2];
        Map map = new HashMap();
        map.put("askText", askText);
        switch (cmd) {
            case "1":
                //获取远程设备编码
                getDeviceCode(askText, idCode, ctx);
                break;
            case "2":
                //同步时间
                getServerTime(askText, idCode, ctx);
                break;
            default:
                System.out.println("==>未知命令");
                log.error(">>当前数据为非法数据-未知命令>>" + askText);
        }
    }



    //时间同步请求
    private void getServerTime(String askText, String deviceCode, ChannelHandlerContext ctx) throws ParseException {
        System.out.println("==>时间同步请求:" + askText);
//        if (!cmdProService.isEffectiveDevice(deviceCode)) {
//            System.out.println("##时间同步请求-未注册设备 idCode=" + deviceCode);
//            return;
//        }
        String answerText = "hm+2+"  + "+0+4+end";
//        log.info(">>时间同步请求-应答数据>>" + answerText);
        answerCmd(answerText, ctx);
    }

    //获取远程设备编码
    private void getDeviceCode(String askText, String idCode, ChannelHandlerContext ctx) {
        System.out.println("==>获取远程设备编码请求:" + askText.trim());
        //{读取设备编码}
//        String deviceCode = cmdProService.getDeviceCodeByChipId(idCode);
//        log.info("获取远程设备编码请求,芯片id>>" + idCode + " ,deviceCode>>" + deviceCode);
//        if (deviceCode == null) {
//            log.error("该设备未注册,已舍弃请求.");
//            return;
//        }
//        String answerText = "hm+1+0+" + deviceCode + "+123+8+end";
//        log.info("<<获取远程设备编码请求-应答数据:" + answerText);
        //{应答指令}
//        answerCmd(answerText, ctx);
    }

    //应答
    public void answerCmd(String answerText, ChannelHandlerContext ctx) {
        ctx.writeAndFlush(Unpooled.copiedBuffer(answerText.getBytes()));
    }

    //检查无效耳标
    public boolean checkValidEarmark(String earmark) {
        if (earmark.trim().equalsIgnoreCase("ffffffffffffffff") || earmark.trim().equalsIgnoreCase("0000000000000000")) {
            return true;
        } else {
            return false;
        }
    }

    //拆分粘包数据
    public JSONArray parseAskCmdPackage(String text) {
        String key = "end";
        Pattern pattern = Pattern.compile(key);
        Matcher matcher = pattern.matcher(text);
        int count = 0;
        while (matcher.find()) {
            count++;
        }
        JSONArray dataJa = new JSONArray();
        if (count == 1) {
            dataJa.add(text);
        } else {
            for (int a = 0; a < count; a++) {
                int p1 = text.indexOf("end");
                dataJa.add(text.substring(0, p1 + 3));
                text = text.substring(p1 + 3, text.length());
            }
        }
        return dataJa;
    }
}