/**
 * ClassName: RuleArmory
 * Package: com.xiaomi.domain.battery.service.armory
 */
@Slf4j
@Service
public class RuleArmory implements IRuleArmory {
    @Resource
    IBatteryRepository batteryRepository;

    @Override
    public void assembleRules(){

        List<WarnRuleEntity> warnRuleEntities=batteryRepository.queryWarnRuleList();
        // 1. 按电池类型和告警代码分组
        Map<String, List<WarnRuleEntity>> groupedRules = warnRuleEntities.stream()
                .collect(Collectors.groupingBy(
                        rule -> String.format("%s_%d",
                                rule.getBatteryType(),
                                rule.getWarnId())
                ));

        int precision=1;
        float epsilon = 0.01f;
        // 2. 处理每组规则
        groupedRules.forEach((groupKey, ruleList) -> {
            // 初始化存储结构
            Map<String, String> redisHash = new HashMap<>();
            float groupMin = Float.MAX_VALUE;
            float groupMax = Float.MIN_VALUE;
            int maxWarnLevel = Integer.MIN_VALUE;
            // 3. 处理每条规则
            for (WarnRuleEntity rule : ruleList) {
                // 更新极值
                groupMin = Math.min(groupMin, rule.getMinVal());
                groupMax = Math.max(groupMax, rule.getMinVal());
                maxWarnLevel = Math.max(maxWarnLevel, rule.getWarnLevel());
                // 离散化区间
                if (rule.getMaxVal() == null) {
                    // 无限区间特殊处理
                    redisHash.put(String.valueOf(rule.getMinVal()),
                            String.valueOf(rule.getWarnLevel()));
                } else {
                    // 常规区间离散化
                    float step = (float) Math.pow(10, -precision);
                    for (float v = rule.getMinVal(); v < rule.getMaxVal()-epsilon; v += step) {
                        String key = String.format("%.1f", v); // 保留1位小数
                        redisHash.put(key, String.valueOf(rule.getWarnLevel()));
                    }
                }
            }
            batteryRepository.storeSearchRateTable(groupKey, redisHash);
            batteryRepository.setSearchMax(groupKey,groupMax);
            batteryRepository.setSearchMaxWarnLevel(groupKey,maxWarnLevel);
        });
    }


}

    @Override
    public void storeSearchRateTable(String key, Map<String, String> table){
        String hashKey = "rules:" + key;
        RMap<String, String> redisMap = redisService.getMap(hashKey);
        redisMap.clear();
        redisMap.putAll(table);
    }
    @Override
    public void setSearchMax(String key, float maxVal){
        // 存储极值
        redisService.setValue("rules:" + key + ":max", String.valueOf(maxVal));
    }

    @Override
    public Integer getWarnLevel(String batteryType, int warnCode, float value) {
        String key = String.format("%s_%d", batteryType, warnCode);
        // 格式化查询值
        BigDecimal bd = new BigDecimal(String.valueOf(value));
        String query=String.format("%.1f", bd.setScale(1, RoundingMode.DOWN).floatValue());
        Integer warnlevel=batteryRepository.getWarnLevel(key,query);
        if(warnlevel!=null) return warnlevel;
        if(value>batteryRepository.getMaxValue(key))return 0;
        return null;
    }

    @Override
    public void writeSignal(SignalWarnEntity signalWarnEntity) throws JsonProcessingException {
        VehicleLatestSignal vehicleLatestSignal = VehicleLatestSignal.builder()
                .carId(Integer.valueOf(signalWarnEntity.getCarId()))
                .warnLevel(signalWarnEntity.getWarnLevel())
                .batteryType(signalWarnEntity.getBatteryType())
                .warnCode(signalWarnEntity.getWarnId())
                .warnName(signalWarnEntity.getWarnName())
                .signalData(signalWarnEntity.getSignal())
                .build();


        SignalHistory signalHistory = SignalHistory.builder()
                .carId(Integer.valueOf(signalWarnEntity.getCarId()))
                .warnLevel(signalWarnEntity.getWarnLevel())
                .batteryType(signalWarnEntity.getBatteryType())
                .warnCode(signalWarnEntity.getWarnId())
                .warnName(signalWarnEntity.getWarnName())
                .signalData(signalWarnEntity.getSignal())
                .build();

        String carId = signalWarnEntity.getCarId();
        boolean locked = false;
        RLock lock = null;
        try {
            String lockKey = Constants.RedisKey.BATTERY_UPDATE_KEY + carId;
            // 1) 尝试获取分布式锁：等待最多3秒，锁5秒后自动释放
            lock = redisService.getLock(lockKey);
            locked = lock.tryLock(3, 5, TimeUnit.SECONDS);
            if (!locked) {
                // 拿锁失败：可重试、丢弃或者抛出异常
                log.warn("未能获取车辆 {} 的更新锁，放弃本次写入", carId);
                return;
            }

            // 2) 拿到锁以后，先路由，再打开事务
            // 以carId作为切分键，通过 doRouter 设定路由【这样就保证了下面的操作，都是同一个链接下，也就保证了事务的特性】
            dbRouter.doRouter(carId);
            transactionTemplate.execute(status -> {
                try {
                    // 写入全量历史表
                    signalHistoryDao.insert(signalHistory);
                    // 更新最新表
                    int count = vehicleLatestSignalDao.update(vehicleLatestSignal);
                    // 如果没更新到，则插入
                    if (count == 0) {
                        vehicleLatestSignalDao.insert(vehicleLatestSignal);
                    }
                    return 1;
                } catch (DuplicateKeyException e) {
                    // 若仍出现唯一索引冲突，回滚并抛出
                    status.setRollbackOnly();
                    log.error("写入最新表索引冲突 carId: {} ", carId, e);
                    throw new AppException(ResponseCode.INDEX_DUP.getCode(), ResponseCode.LOCK_INTERRUPTED.getInfo(),e);
                }
            });

        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
            throw new AppException(ResponseCode.LOCK_INTERRUPTED.getCode(), ResponseCode.LOCK_INTERRUPTED.getInfo(),ie);

        } finally {
            String carCache_key=Constants.RedisKey.BATTERY_KEY + carId;
            redisService.remove(carCache_key);
            // 3) 释放路由并解锁（仅当拿到锁时才解锁）
            dbRouter.clear();
            lock.unlock();
        }
    }

@DBRouterStrategy(splitTable=true)
@Mapper
public interface SignalHistoryDao {
    @DBRouter(key="carId")
    int insert(SignalHistory history);
}

 @Scheduled(cron = "0/20 * * * * ?") // 每20秒扫描一次
    public void exec() {
        List<VehicleLatestSignalEntity> list = batteryRepository.findAllSignals(); // 查全表或分页查
        for (VehicleLatestSignalEntity signalEntity : list) {
            try {
                String payload = new ObjectMapper().writeValueAsString(signalEntity);
                // 1. 发 MQ 消息
                rocketMQTemplate.convertAndSend("battery-warn-topic", payload);
                // 2. 写入补偿表（可异步插入）
                BatteryWarnMessageLog batteryWarnMessageLog = BatteryWarnMessageLog.builder()
                        .carId(signalEntity.getCarId())
                        .payload(payload)
                        .status(0)
                        .build();
                messageLogDao.insert(batteryWarnMessageLog);

                log.info("发送电池预警信号 MQ 成功，carId={}", signalEntity.getCarId());
            } catch (Exception e) {
                log.error("发送电池预警失败，carId={}", signalEntity.getCarId(), e);
            }
        }
    }



    @Scheduled(cron = "0/3 * * * * ?") // 每5秒重试一次
    public void compensate() {
        List<BatteryWarnMessageLog> logs = messageLogDao.findPendingLogs(10);
        for (BatteryWarnMessageLog logItems : logs) {
            try {
                rocketMQTemplate.convertAndSend("battery-warn-topic", logItems.getPayload());
                // 更新重试信息
                messageLogDao.increaseRetryCount(logItems.getId());
                log.info("补偿重发 MQ 成功，carId={}", logItems.getCarId());
            } catch (Exception e) {
                log.error("补偿发送失败，carId={}, msgId={}", logItems.getCarId(), logItems.getId(), e);
            }
        }
    }

    @Override
    public void onMessage(String message) {
        try {
            VehicleLatestSignalEntity signalEntity = new ObjectMapper().readValue(message, VehicleLatestSignalEntity.class);
            // 更新补偿表为成功
            messageLogDao.markSuccessByCarId(String.valueOf(signalEntity.getCarId()));

            log.info("车辆={}，电池类型={}，警告名称={}，警告级别={}", signalEntity.getCarId(),signalEntity.getBatteryType(),signalEntity.getWarnName(),signalEntity.getWarnLevel());

        } catch (Exception e) {
            log.error("电池预警失败，消息={}，异常={}", message, e.getMessage(), e);
        }
    }

  @Override
    public List<VehicleLatestSignalEntity> queryBatterySignal(Integer carId) {
        String cacheKey = Constants.RedisKey.BATTERY_KEY + carId;
        // 1. 尝试从缓存读
        List<VehicleLatestSignal> signals = redisService.getValue(cacheKey);
        if (signals != null) {
            return buildVehicleLatestSignalEntity(signals);
        }
        // 2. 缓存未命中，竞争分布式锁由一个线程去加载
        String lockKey = Constants.RedisKey.BATTERY_LOCK_KEY + carId;
        RLock lock = redisService.getLock(lockKey);
        boolean locked = false;
        try {
            // 最多等待 3 秒去拿锁，拿到锁后 5 秒自动释放
            locked = lock.tryLock(3, 5, TimeUnit.SECONDS);
            if (locked) {
                // 获得锁后，再次 double-check 缓存
                signals = redisService.getValue(cacheKey);
                if (signals != null) {
                    return buildVehicleLatestSignalEntity(signals);
                }
                // 真正去 DB 读
                signals = vehicleLatestSignalDao.selectByCarId(String.valueOf(carId));
                if (signals != null) {
                    // 回填缓存，过期时间按业务场景定（示例：5 秒）
                    redisService.setValue(cacheKey, signals, 50000);
                }
                return buildVehicleLatestSignalEntity(signals);
            } else {
                // 没拿到锁的线程：在短时间内轮询缓存，等第一个线程回填
                long start = System.currentTimeMillis();
                while (System.currentTimeMillis() - start < 5000) {
                    signals = redisService.getValue(cacheKey);
                    if (signals != null) {
                        return buildVehicleLatestSignalEntity(signals);
                    }
                    Thread.sleep(50);
                }
                // 超时后仍无缓存，则直接降级查库
                return buildVehicleLatestSignalEntity(vehicleLatestSignalDao.selectByCarId(String.valueOf(carId)));
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            // 被打断也降级查库
            return buildVehicleLatestSignalEntity(vehicleLatestSignalDao.selectByCarId(String.valueOf(carId)));
        } finally {
            if (locked && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }