package com.casic.methane.service;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.casic.common.CasicFrame;
import com.casic.common.CasicFrameBuildFactory;
import com.casic.common.CasicProtocol;
import com.casic.common.general.ConfigFrame;
import com.casic.common.general.DataFrame;
import com.casic.common.general.ReplyFrame;
import com.casic.dao.model.DataGas;
import com.casic.dao.model.DataGasliquidGas;
import com.casic.dao.model.DeviceWellView;
import com.casic.dao.service.IDataGasService;
import com.casic.dao.service.IDataGasliquidGasService;
import com.casic.dao.service.IDeviceWellViewService;
import com.casic.util.DataPushConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;


@Service
@Slf4j
public class MethaneFrameServiceImpl implements IMethaneFrameService {

    @Resource
    private CasicProtocol protocol;

    @Resource
    IDataGasService dataService;

    @Resource
    IDataGasliquidGasService lgDataService;

    @Resource
    IDeviceWellViewService deviceService;

    @Resource
    DataPushConfig pushConfig;

    public CasicFrame dataParse(String frame) {
        // 1. 判断帧结构
        boolean frameValid = protocol.checkFrame(frame);
        if (frameValid) {
            // 2. 获取帧结构中的关键字段信息
            String deviceId = protocol.getDeviceId(frame);
            String deviceType = protocol.getDeviceType(frame);
            String messageType = protocol.getMessageType(frame);
            String messageBody = protocol.getMessageBody(frame).toUpperCase();
            String sequence = protocol.getMessageSequence(frame);
            String uptime = protocol.getUptime(frame);

            String manufacturerCode = protocol.getManufacturerCode(frame);
            CasicFrame gasFrame = CasicFrameBuildFactory.buildCasicFrame(messageType, manufacturerCode, deviceType);

            if (gasFrame != null) {
                gasFrame.setDeviceCode(deviceId);
                gasFrame.setUptime(uptime);
                gasFrame.setMessageType(messageType);
                gasFrame.setDeviceType(deviceType);
                gasFrame.setSequence(sequence);

                // 心跳类的消息不解析MessageBody
                if (!gasFrame.getMessageType().equals("00")) {
                    gasFrame.setMessageBody(protocol.parseMessageBody(messageBody));
                    gasFrame.parseMessageBody();
                }

                log.info("收到设备消息：{}", gasFrame);
                return gasFrame;
            }
        } else {
            log.error("消息帧解析异常");
        }

        return null;
    }

    public String replyMessage(String deviceCode, String sequence) {
        CasicFrame reply = new ReplyFrame();
        reply.setDeviceType(deviceCode.substring(0, 2)); // 设备类型为 设备编号前2位
        reply.setDeviceCode(deviceCode);
        reply.setSequence(sequence);
        reply.setUptime(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))); // 当前时刻

        return protocol.buildReplyFrameStr(reply);
    }

    @Override
    public String doBuildCommand(CasicFrame cmd) {
        return protocol.buildFrameStr(cmd);
    }

    @Override
    public String doBuildCommand(String deviceCode, String cmdList) {
        CasicFrame cmdFrame = new ConfigFrame();
        cmdFrame.setDeviceType(deviceCode.substring(0, 2)); // 设备类型为 燃气监测桩（防第三方破坏）
        cmdFrame.setDeviceCode(deviceCode);
        cmdFrame.setSequence("01");
        cmdFrame.setUptime(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))); // 当前时刻

        JSONObject messageBody = new JSONObject();
        messageBody.put("datas", JSONArray.parseArray(cmdList));
        cmdFrame.setMessageBody(messageBody);

        return protocol.buildFrameStr(cmdFrame);
    }

    @Override
    public void afterAction(CasicFrame frame) {
        // 数据消息帧 进行存库操作
        if (frame instanceof DataFrame) {
            DeviceWellView devWellView = deviceService.getDeviceWellViewByDevCode(frame.getDeviceCode());
            String wellCode = "";
            if (devWellView != null) {
                wellCode = devWellView.getWellCode();
            }
            List<Serializable> dataList = ((DataFrame) frame).toDataModelList();
            if (dataList != null) {
                for (Serializable item : dataList) {
                    if (item.getClass().getSimpleName().equalsIgnoreCase("DataGas0")) {
                        DataGas data = (DataGas) item;
                        data.setWellCode(wellCode);
                        dataService.save(data);
                    } else if (item.getClass().getSimpleName().equalsIgnoreCase("DataGasliquidGas")) {
                        DataGasliquidGas data = (DataGasliquidGas) item;
                        data.setWellCode(wellCode);
                        lgDataService.save(data);
                    }
                }
            }
        }
    }

    @Override
    public void pushToApi(CasicFrame frame) {
        HttpRequest request = HttpUtil.createPost(pushConfig.getUrl());
        request.contentType("application/json");
        request.body(frame.toJSON().toJSONString());
        request.timeout(5 * 1000);

        try (HttpResponse response = request.execute()) {
            log.info("向接口推送数据[url={}][{}]", pushConfig.getUrl(), response.getStatus());
        } catch (Exception ex) {
            log.info("向接口推送数据失败[url={}]: {}", pushConfig.getUrl(), ex.getMessage());
        }
    }
}