package com.muyu.event.service.impl;

import cn.hutool.core.date.DateTime;
import com.alibaba.fastjson.JSON;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.muyu.demos.model.Result;
import com.muyu.event.common.Fault;
import com.muyu.event.common.VehicleEvent;
import com.muyu.event.mapper.EventMapper;
import com.muyu.event.service.EventService;
import com.muyu.mqtt.dao.MessageData;
import com.rabbitmq.client.ConnectionFactory;
import lombok.extern.log4j.Log4j2;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * EventServiceImpl
 *
 * @author Yangle
 * Date 2024/6/17 19:57
 */
@Service
@Log4j2
public class EventServiceImpl implements EventService {
    @Autowired
    private EventMapper eventMapper;

    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Override
    public List<VehicleEvent> getCarEventList(VehicleEvent vehicleEvent) {
        return eventMapper.getCarEventList(vehicleEvent);
    }

    @Override
    public Result<MessageData> selectEvent(VehicleEvent vehicleEvent) {

            if (vehicleEvent.getEvent() != null) {

                if (vehicleEvent.getEvent().contains("1")) {
                    KafkaConsumer<String, String> consumer = getStringStringKafkaConsumer();
                    // 订阅主题
                    consumer.subscribe(Collections.singletonList("test1"));
                    // 创建新线程来处理消息
                    new Thread(() -> {
                        while (true) {
                            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                            for (ConsumerRecord<String, String> record : records) {
                                // 处理消息
                                String message = record.value();
                                MessageData messageData = JSON.parseObject(message, MessageData.class);
                                // 将毫秒级时间戳转换为LocalDateTime
                                LocalDateTime dateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(Long.parseLong(messageData.getTimestamp())), ZoneId.systemDefault());

                                // 格式化输出日期时间
                                String formattedTime = dateTime.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒"));

                                    //判断车辆状态
                                vehicleStatus(messageData, formattedTime);

                                    //判断充电状态
                                chargeStatus(messageData, formattedTime);

//                                //判断运行状态
//                                runStatus(messageData, formattedTime);
//
//                                //判断SOC
//                                soc(messageData, formattedTime);
//
//                                //判断充电工作状态
//                                chargeWorkStatus(messageData, formattedTime);
//
//                                //判断驱动电机状态
//                                driveMotorStatus(messageData, formattedTime);
//
//                                //判断位置
//                                location(messageData, formattedTime);
//
//                                //判断EAS
//                                eas(messageData, formattedTime);
//
//                                //判断PTC
//                                ptc(messageData, formattedTime);
//
//                                //判断EPS
//                                eps(messageData, formattedTime);
//                                //判断ABS
//                                abs(messageData, formattedTime);
//                                //判断MCU
//                                mcu(messageData, formattedTime);
//                                //判断动力电池加热
//                                powerBatteryHeating(messageData, formattedTime);
//                                //判断动力电池电流
//                                powerBatteryCurrentStatus(messageData, formattedTime);
//                                //判断动力电池保温
//                                powerBatteryHeat(messageData, formattedTime);
//                                //判断DCDC
//                                dcdc(messageData, formattedTime);
//                                //判断CHG
//                                chg(messageData, formattedTime);

                            }
//                                else {
//                                    // 假设您有一个方法来从缓存中获取当前的故障列表
//                                    List<Fault> currentFaults = JSON.parseArray(localCache.getIfPresent(messageData.getVin()), Fault.class);
//
//                                    // 创建一个新的故障列表，用于存储更新后的故障信息
//                                    List<Fault> updatedFaults = new ArrayList<>(currentFaults);
//
//                                    // 检查和更新故障状态
//                                    boolean vehicleFault = messageData.getVehicleStatus().equals("0");
//                                    boolean chargeFault = messageData.getChargeStatus().equals("0");
//
//                                    if (vehicleFault) {
//                                        // 如果车辆状态为故障，确保GZ001在故障列表中
//                                        updatedFaults.add(Fault.builder()
//                                                .vin(messageData.getVin())
//                                                .faultName("GZ001")
//                                                .faultTime(formattedTime)
//                                                .build());
//                                    } else {
//                                        // 如果车辆状态不再是故障，从列表中移除GZ001
//                                        updatedFaults.removeIf(fault -> "GZ001".equals(fault.getFaultName()));
//                                    }
//
//                                    if (chargeFault) {
//                                        // 如果充电状态为故障，确保GZ002在故障列表中
//                                        updatedFaults.add(Fault.builder()
//                                                .vin(messageData.getVin())
//                                                .faultName("GZ002")
//                                                .faultTime(formattedTime)
//                                                .build());
//                                    } else {
//                                        // 如果充电状态不再是故障，从列表中移除GZ002
//                                        updatedFaults.removeIf(fault -> "GZ002".equals(fault.getFaultName()));
//                                    }
//
//                                    // 序列化更新后的故障列表
//                                    String updatedFaultsJson = JSON.toJSONString(updatedFaults);
//
//                                    // 存储更新后的故障信息到Redis和本地缓存
//                                    if (!updatedFaults.isEmpty()) {
//                                        redisTemplate.opsForValue().set(messageData.getVin(), updatedFaultsJson, 10, TimeUnit.MINUTES);
//                                        localCache.put(messageData.getVin(), updatedFaultsJson);
//                                        log.info("更新车辆故障信息存储到Redis和本地缓存中");
//                                    } else {
//                                        // 如果没有故障，从缓存中删除记录
//                                        redisTemplate.delete(messageData.getVin());
//                                        localCache.invalidate(messageData.getVin());
//                                        log.info("该车故障已修复，相关信息从缓存中删除");
//                                    }
//                                }
                            }
                    }).start();
                }
                if (vehicleEvent.getEvent().contains("2")) {
                    if(vehicleEvent.getStates()){
                        if (redisTemplate.hasKey(vehicleEvent.getVin())){
                            KafkaConsumer<String, String> consumer = getStringStringKafkaConsumer();
                            // 订阅主题
                            consumer.subscribe(Collections.singletonList("test1"));
                            // 创建新线程来处理消息
                            new Thread(() -> {
                                while (true) {
                                    // 发送拉取请求
                                    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100)); // 设置拉取超时时间为100毫秒
                                    // 处理消息
                                    for (ConsumerRecord<String, String> record : records) {
                                        redisTemplate.opsForValue().set(vehicleEvent.getVin(),record.value());
                                        System.out.println("Received message: " + record.value());
                                        // 在这里添加消息处理逻辑
                                    }
                                }
                            }).start();
                        }

                    }
                    return Result.success();
                }
                if (vehicleEvent.getEvent().contains("3")) {

                }
            }


            return Result.error("车辆没有绑定事件");
    }


    /**
     * 本地缓存
     */
    Cache<String, String> localCache = Caffeine.newBuilder()
            .initialCapacity(5)
            .maximumSize(10)
            //过期时间3秒钟
            .expireAfterWrite(5, TimeUnit.SECONDS)
            .build();
    /**
     * kafka消费者
     * @return
     */
    private static KafkaConsumer<String, String> getStringStringKafkaConsumer() {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092"); // Kafka服务器地址
        props.put("group.id", "Partitions"); // 消费者组ID
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); // 键反序列化器
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); // 值反序列化器
        // 创建Kafka消费者实例
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        return consumer;
    }

    @Override
    public void eventAddRedis(VehicleEvent vehicleEvent) {
        redisTemplate.opsForValue().set(vehicleEvent.getVin(),"");
    }

    @Override
    public Result getMaximumCoordinate(String vin) {
       //获取本地缓存
        String ifPresent = localCache.getIfPresent(vin);
        return Result.error(ifPresent);
    }

    @Override
    public List<VehicleEvent> selectVehicleEvent() {
        return  eventMapper.selectVehicleEvent();
    }


//    //创建分区
//    NewTopic newTopic = new NewTopic(topic, 8, (short) 1);
//        kafkaAdmin.createOrModifyTopics(newTopic);
//    ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, main.getVin(), JSON.toJSONString(main));
//    // 发送消息
//        kafkaTemplate.send(producerRecord);


    //判断车辆状态
    public  void vehicleStatus(MessageData  messageData, String formattedTime){
        if (messageData.getVehicleStatus().equals("0")) {

            if (messageData.getVehicleStatus().equals("0") && !redisTemplate.hasKey(messageData.getVin() + "-" + "GZ001")) {
                // 车辆状态异常，第一次发生

                // 创建故障对象
                Fault gz001 = Fault.builder()
                        .vin(messageData.getVin())
                        .faultName("GZ001")
                        .faultTime(formattedTime)
                        .build();
                String gz001Json = JSON.toJSONString(gz001);

                // 存储故障信息到本地缓存和Redis
                localCache.put(messageData.getVin() + "-" + "GZ001", gz001Json);
                redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ001", gz001Json, 10, TimeUnit.SECONDS);

                // 发送消息到RabbitMQ
                sendToRabbitMQ(gz001);

               log.info("该车故障GZ001信息首次存储到本地缓存和Redis中，并发送到RabbitMQ");
            } else if (messageData.getVehicleStatus().equals("0")) {

                // 刷新Redis中的故障信息过期时间
                redisTemplate.expire(messageData.getVin() + "-" + "GZ001", 10, TimeUnit.SECONDS);
                log.info("该车故障GZ001信息在Redis中的过期时间被刷新，不发送到RabbitMQ");
            }
        }
    }

    //判断充电状态
    private void chargeStatus(MessageData messageData, String formattedTime) {
        if (messageData.getChargeStatus().equals("0")) {

            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ002")==null) {
                Fault gz002 = Fault.builder()
                        .vin(messageData.getVin())
                        .faultName("GZ002")
                        .faultTime(formattedTime)
                        .build();
                localCache.put(messageData.getVin() + "-" + "GZ002", JSON.toJSONString(gz002));
                log.info("该车故障GZ002信息存储到本地缓存中");
                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ002")) {
                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ002", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
                    log.info("该车故障GZ002信息存储到Redis中");
                }
            }

        }else {
            redisTemplate.delete(messageData.getVin()+"-"+"GZ002");
            localCache.invalidate(messageData.getVin()+"-"+"GZ002");
            log.info("删除该车故障GZ002信息存储到本地缓存中");
            log.info("删除该车故障GZ002信息存储到Redis中");
        }
    }

//    //判断运行状态
//    private void runStatus(MessageData messageData, String formattedTime) {
//        if (messageData.getRunStatus().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ003")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ003")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ003", JSON.toJSONString(gz002));
//                log.info("该车故障GZ003信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ003")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ003", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ003信息存储到Redis中");
//                }
//            }
//
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ003");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ003");
//            log.info("删除该车故障GZ003信息存储到本地缓存中");
//            log.info("删除该车故障GZ003信息存储到Redis中");
//        }
//    }
//    //判断SOC
//    private void soc(MessageData messageData, String formattedTime) {
//        if (messageData.getChargeStatus().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ004")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ004")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ004", JSON.toJSONString(gz002));
//                log.info("该车故障GZ004信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ004")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ004", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ004信息存储到Redis中");
//                }
//            }
//
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ004");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ004");
//            log.info("删除该车故障GZ004信息存储到本地缓存中");
//            log.info("删除该车故障GZ004信息存储到Redis中");
//        }
//    }
//
//
//    // 判断充电工作状态
//    private void chargeWorkStatus(MessageData messageData, String formattedTime) {
//        if (messageData.getChargeStatus().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ002")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ005")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ005", JSON.toJSONString(gz002));
//                log.info("该车故障GZ005信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ005")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ005", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ005信息存储到Redis中");
//                }
//            }
//
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ005");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ005");
//            log.info("删除该车故障GZ005信息存储到本地缓存中");
//            log.info("删除该车故障GZ005信息存储到Redis中");
//        }
//    }
//
//    //判断驱动电机状态
//    private  void  driveMotorStatus(MessageData messageData,String formattedTime){
//        if (messageData.getDriveMotorStatus().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ002")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ006")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ006", JSON.toJSONString(gz002));
//                log.info("该车故障GZ006信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ006")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ006", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ006信息存储到Redis中");
//                }
//            }
//
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ006");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ006");
//            log.info("删除该车故障GZ006信息存储到本地缓存中");
//            log.info("删除该车故障GZ006信息存储到Redis中");
//        }
//    }
//    //判断定位
//    private  void  location(MessageData messageData,String formattedTime){
//        if (messageData.getChargeStatus().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ007")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ007")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ007", JSON.toJSONString(gz002));
//                log.info("该车故障GZ007信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ007")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ007", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ007信息存储到Redis中");
//                }
//            }
//
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ007");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ007");
//            log.info("删除该车故障GZ007信息存储到本地缓存中");
//            log.info("删除该车故障GZ007信息存储到Redis中");
//        }
//    }
//    //判断EAS
//    private  void  eas(MessageData messageData,String formattedTime){
//        if (messageData.getEas().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ008")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ008")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ008", JSON.toJSONString(gz002));
//                log.info("该车故障GZ008信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ008")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ008", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ008信息存储到Redis中");
//                }
//            }
//
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ008");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ008");
//            log.info("删除该车故障GZ008信息存储到本地缓存中");
//            log.info("删除该车故障GZ008信息存储到Redis中");
//        }
//    }
//    //判断EPS
//    private  void  ptc(MessageData messageData,String formattedTime){
//        if (messageData.getPtc().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ009")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ009")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ009", JSON.toJSONString(gz002));
//                log.info("该车故障GZ009信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ009")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ009", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ009信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ009");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ009");
//            log.info("删除该车故障GZ009信息存储到本地缓存中");
//            log.info("删除该车故障GZ009信息存储到Redis中");
//        }
//    }
//    //判断EPS
//    private void eps(MessageData messageData,String formattedTime){
//        if (messageData.getEas().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ010")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ010")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ010", JSON.toJSONString(gz002));
//                log.info("该车故障GZ010信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ010")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ010", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ010信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ010");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ010");
//            log.info("删除该车故障GZ010信息存储到本地缓存中");
//            log.info("删除该车故障GZ010信息存储到Redis中");
//        }
//    }
//    //判断ABS
//    private void abs(MessageData messageData,String formattedTime){
//        if (messageData.getAbs().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ010")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ011")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ011", JSON.toJSONString(gz002));
//                log.info("该车故障GZ011信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ011")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ011", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ011信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ011");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ011");
//            log.info("删除该车故障GZ011信息存储到本地缓存中");
//            log.info("删除该车故障GZ011信息存储到Redis中");
//        }
//    }
//
//    //判断MCU
//    private void mcu(MessageData messageData,String formattedTime){
//        if (messageData.getMcu().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ012")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ012")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ012", JSON.toJSONString(gz002));
//                log.info("该车故障GZ012信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ012")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ012", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ012信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ012");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ012");
//            log.info("删除该车故障GZ012信息存储到本地缓存中");
//            log.info("删除该车故障GZ012信息存储到Redis中");
//        }
//    }
//    //判断动力电池加热
//    private void powerBatteryHeating(MessageData messageData,String formattedTime){
//        if (messageData.getPowerBattery().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ013")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ013")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ013", JSON.toJSONString(gz002));
//                log.info("该车故障GZ013信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ013")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ013", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ013信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ013");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ013");
//            log.info("删除该车故障GZ013信息存储到本地缓存中");
//            log.info("删除该车故障GZ013信息存储到Redis中");
//        }
//    }
//    //判断动力电池电流
//    private void powerBatteryCurrentStatus(MessageData messageData,String formattedTime){
//        if (messageData.getEas().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ014")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ014")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ014", JSON.toJSONString(gz002));
//                log.info("该车故障GZ014信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ014")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ014", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ014信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ014");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ014");
//            log.info("删除该车故障GZ014信息存储到本地缓存中");
//            log.info("删除该车故障GZ014信息存储到Redis中");
//        }
//    }
//    //判断动力电池保温
//    private void powerBatteryHeat(MessageData messageData,String formattedTime){
//        if (messageData.getEas().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ015")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ015")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ015", JSON.toJSONString(gz002));
//                log.info("该车故障GZ015信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ015")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ015", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ015信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ015");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ015");
//            log.info("删除该车故障GZ015信息存储到本地缓存中");
//            log.info("删除该车故障GZ015信息存储到Redis中");
//        }
//    }
//    //判断DCDC
//    private void dcdc(MessageData messageData,String formattedTime){
//        if (messageData.getEas().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ016")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ016")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ016", JSON.toJSONString(gz002));
//                log.info("该车故障GZ016信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ016")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ016", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ016信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ016");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ016");
//            log.info("删除该车故障GZ016信息存储到本地缓存中");
//            log.info("删除该车故障GZ016信息存储到Redis中");
//        }
//    }
//    //判断CHG
//    private void chg(MessageData messageData,String formattedTime){
//        if (messageData.getEas().equals("0")) {
//
//            if (localCache.getIfPresent(messageData.getVin()+"-"+"GZ017")==null) {
//                Fault gz002 = Fault.builder()
//                        .vin(messageData.getVin())
//                        .faultName("GZ017")
//                        .faultTime(formattedTime)
//                        .build();
//                localCache.put(messageData.getVin() + "-" + "GZ017", JSON.toJSONString(gz002));
//                log.info("该车故障GZ017信息存储到本地缓存中");
//                if (!redisTemplate.hasKey(messageData.getVin() + "-" + "GZ017")) {
//                    redisTemplate.opsForValue().set(messageData.getVin() + "-" + "GZ017", JSON.toJSONString(gz002),10,TimeUnit.SECONDS);
//                    log.info("该车故障GZ017信息存储到Redis中");
//                }
//            }
//        }else {
//            redisTemplate.delete(messageData.getVin()+"-"+"GZ017");
//            localCache.invalidate(messageData.getVin()+"-"+"GZ017");
//            log.info("删除该车故障GZ017信息存储到本地缓存中");
//            log.info("删除该车故障GZ017信息存储到Redis中");
//        }
//    }


    public void sendToRabbitMQ(Fault gz001){
//        rabbitTemplate.convertAndSend("exchange_breakdown", "with", gz001.toString());

        rabbitTemplate.convertAndSend("exchange_breakdown","with",JSON.toJSONString(gz001));
         log.info("故障信息发送到RabbitMQ");
    }

}
