package com.casic.tube.service;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.casic.common.CasicFrame;
import com.casic.common.CasicFrameBuildFactory;
import com.casic.common.CasicProtocol;
import com.casic.common.general.DataFrame;
import com.casic.dao.model.DataTubeOther;
import com.casic.dao.model.DeviceWellView;
import com.casic.dao.service.IDataTubeOtherService;
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.util.List;


@Service
@Slf4j
public class TubeFrameServiceImpl implements ITubeFrameService {

    @Resource
    private CasicProtocol tubeProtocol;

    @Resource
    IDataTubeOtherService tubeDataService;

    @Resource
    IDeviceWellViewService deviceService;

    @Resource
    DataPushConfig pushConfig;

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

            String manufacturerCode = tubeProtocol.getManufacturerCode(frame);
            CasicFrame tubeFrame = CasicFrameBuildFactory.buildCasicFrame(messageType, manufacturerCode, deviceType);

            if (tubeFrame != null) {
                tubeFrame.setDeviceCode(deviceId);
                tubeFrame.setUptime(uptime);
                tubeFrame.setMessageType(messageType);

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

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

        return null;
    }

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

    @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) {
                    DataTubeOther data = (DataTubeOther) item;
                    data.setWellCode(wellCode);
                    tubeDataService.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());
        }
    }
}