//package com.ruoyi.iot.service.impl;
//
//import com.ruoyi.common.core.redis.RedisLock;
//import com.ruoyi.common.core.redis.enums.RedisLockKey;
//import com.ruoyi.common.utils.NumberUtils;
//import com.ruoyi.common.utils.ServiceUtil;
//import com.ruoyi.common.utils.collection.CollectionUtils;
//import com.ruoyi.iot.constants.ReceiveConstants;
//import com.ruoyi.iot.domain.Datapoint;
//import com.ruoyi.iot.domain.HistoryDatastream;
//import com.ruoyi.iot.domain.HistoryDeviceData;
//import com.ruoyi.iot.domain.ReceiveMsg;
//import com.ruoyi.iot.domain.response.CommandResponse;
//import com.ruoyi.iot.enums.ReceiveType;
//import com.ruoyi.iot.service.IotReceiveService;
//import com.ruoyi.iot.service.IotService;
//import com.ruoyi.bst.device.domain.DeviceVO;
//import com.ruoyi.bst.device.service.DeviceService;
//import com.ruoyi.ss.transactionBill.service.TransactionAssembler;
//import com.ruoyi.ss.transactionBill.service.TransactionBillService;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.support.TransactionTemplate;
//
//import java.math.BigDecimal;
//import java.time.LocalDateTime;
//
///**
// * @author wjh
// * 2024/5/6
// */
//@Service
//@Slf4j
//public class IotReceiveServiceImpl implements IotReceiveService {
//
//    @Autowired
//    private DeviceService deviceService;
//
//    @Autowired
//    private TransactionBillService transactionBillService;
//
//    @Autowired
//    private TransactionAssembler transactionAssembler;
//
//    @Autowired
//    private IotService iotService;
//
//    @Autowired
//    private RedisLock redisLock;
//
//    @Autowired
//    private TransactionTemplate transactionTemplate;
//
//    @Override
//    public void handleReceive(ReceiveMsg msg) {
//        if (msg == null) {
//            return;
//        }
//        // 数据点推送
//        if (ReceiveType.DATA_POINT.getType().equals(msg.getType())) {
////            log.info("收到推送数据点：{},{},{}", msg.getAt(), msg.getDsId(), msg.getValue());
//            // 若推送数据点:CSQ
//            if (ReceiveConstants.DS_CSQ.equals(msg.getDsId())) {
//                // 恢复余额
//                this.recoverBalance(msg);
//                // 恢复总用电量
//                this.recoverTotalEle(msg);
//            }
//            // 开关状态
//            else if (ReceiveConstants.DS_S.equals(msg.getDsId())) {
//                // 同步订单状态 已经改为轮询，无需再做
////                this.syncOrderStatus(msg);
//            }
//        }
//        // 生命周期
//        else if (ReceiveType.DEVICE_STATUS.getType().equals(msg.getType())) {
//        }
//    }
//
//    /**
//     * 当开关状态为关闭，则同步订单状态
//     */
//    private void syncOrderStatus(ReceiveMsg msg) {
////        if (msg == null || StringUtils.isBlank(msg.getDevName())) {
////           return;
////        }
////        // 开关不是断电状态，则忽略
////        if (!DevicePowerStatus.OFF.getStatus().equals(msg.getValue())) {
////            return;
////        }
////        log.info("{} 开关状态为 {}", msg.getDevName(), msg.getValue());
////
////        DeviceVO device = deviceService.selectByAnyMac(msg.getDevName());
////        if (device == null) {
////            log.error("设备：{} 不存在", msg.getDevName());
////            return;
////        }
////        // 拉取一下设备信息
////        deviceService.pullDeviceInfo(device, IotConstants.ONLINE_TYPE_COMMAND);
//
//        // 查询
//    }
//
//    /**
//     * 恢复异常的总用电量
//     * @param msg
//     */
//    private void recoverTotalEle(ReceiveMsg msg) {
//        // 查询设备
//        DeviceVO device = deviceService.selectByAnyMac(msg.getDevName());
//        if (device == null) {
//            log.error("设备：{} 不存在", msg.getDevName());
//            return;
//        }
//
//        // 查询历史数据点
//        HistoryDeviceData historyDataPoint = iotService.getHistoryDataPoint(msg.getDevName(), device.getDeviceProductId());
//        if (historyDataPoint == null || CollectionUtils.isEmptyElement(historyDataPoint.getDatastreams()) ) {
//            log.info("设备：{} 没有历史数据点", msg.getDevName());
//            return;
//        }
//
//        // 获取总用电量数据点
//        HistoryDatastream pointW = historyDataPoint.getDatastreams()
//                .stream().filter(item -> item.getId().equals(ReceiveConstants.DS_W))
//                .findFirst().orElse(null);
//        if (pointW == null || CollectionUtils.isEmptyElement(pointW.getDatapoints())) {
//            log.info("设备：{} 没有数据点：{}", msg.getDevName(), ReceiveConstants.DS_W);
//            return;
//        }
//
//        // 遍历数据点，查找异常数据并恢复
//        Datapoint lastPoint = null;
//        for (Datapoint dp : pointW.getDatapoints()) {
//            // 若当前数据点值大于上次数据点值，则视为异常数据，进行恢复
//            if (lastPoint != null && dp != null) {
//                BigDecimal lastEle = NumberUtils.nonNullDecimal(lastPoint.getValue().toString());
//                BigDecimal currEle = NumberUtils.nonNullDecimal(dp.getValue().toString());
//
//                if (currEle.compareTo(lastEle) > 0) {
//                    log.info("设备：{} 数据点异常，恢复总电量：{} 瓦时, lastPoint = {}, dp = {}", msg.getDevName(), currEle, lastPoint, dp);
//                    String reason = "接收数据推送时，恢复设备总用电量，异常值：" + lastPoint + "，正常值：" + currEle;
//                    iotService.setTotalEle(device, currEle, reason);
//                    break;
//                }
//            }
//            lastPoint = dp;
//        }
//    }
//
//    // 恢复设备的余额
//    private void recoverBalance(ReceiveMsg msg) {
//        String lockKey = msg.getDevName();
//        if (!redisLock.lock(RedisLockKey.RECOVER_DEVICE_BALANCE, lockKey)){
//            return;
//        }
//        try {
//            // 查询设备
//            DeviceVO device = deviceService.selectByAnyMac(msg.getDevName());
//            if (device == null) {
//                log.info("设备：{} 不存在", msg.getDevName());
//                return;
//            }
//
//            // 判断上次恢复余额的时间和本次恢复余额的时间是否相同，若相同则视为重复推送，则忽略
//            if (device.getLastRecoverTime() != null && msg.getAt().equals(device.getLastRecoverTime())) {
//                log.info("设备：{} 重复推送余额恢复，上次恢复时间：{}", msg.getDevName(), device.getLastRecoverTime());
//                return;
//            }
//
//            // 待恢复的时长（秒）
//            LocalDateTime expireTime = device.getExpireTime();
//
//            // 待恢复的电量（度）
//            BigDecimal ele = BigDecimal.ZERO;
//
//            // 若有需要恢复余额的设备，则进行操作
//            if (expireTime != null || ele.compareTo(BigDecimal.ZERO) > 0) {
//                transactionTemplate.execute(status -> {
//                    // 记录上次恢复余额的时间
//                    int update = deviceService.updateLastRecoverTime(device.getDeviceId(), msg.getAt());
//                    ServiceUtil.assertion(update != 1, "更新设备信息失败");
//
//                    log.info("设备：{} 恢复余额，过期时间：{}，剩余电量：{}", device.getMac(), expireTime, ele);
//                    if (expireTime != null ) {
//                        int setTime = deviceService.setTime(device, expireTime, 3, "恢复设备时长余额");
//                        ServiceUtil.assertion(setTime != 1, "恢复设备时长失败");
//                    }
//                    if (ele.compareTo(BigDecimal.ZERO) > 0) {
//                        CommandResponse res = iotService.trySetEle(device, ele, 3, "恢复设备电量余额");
//                        ServiceUtil.assertion(!res.isSuccess(), "设备电量恢复失败:%s", res.getMsg());
//                    }
//
//                    return update;
//                });
//            }
//        } finally {
//            redisLock.unlock(RedisLockKey.RECOVER_DEVICE_BALANCE, lockKey);
//        }
//    }
//}
