package com.iot.scheduler.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.util.UriComponentsBuilder;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;

import org.springframework.scheduling.annotation.Scheduled;

@Slf4j
@Service
public class DevicePullService {


    @Value("${device.token.url}")
    private String deviceTokenUrl;
    @Value("${device.token.userName}")
    private String deviceUserName;
    @Value("${device.token.password}")
    private String devicePassword;
    @Value("${device.info.url}")
    private String deviceInfoUrl;
    @Value("${device.detail.url}")
    private String deviceDetailUrl;
    @Value("${device.snRate.url}")
    private String deviceSnRateUrl;
    @Value("${device.energyInfo.url}")
    private String energyInfoUrl;
    @Value("${device.db.corpCode}")
    private String deviceCorpCode;
    @Value("${device.db.tableName}")
    private String deviceTableName;
    @Value("${device.db.devUtilTableName}")
    private String devUtilTableName;
    @Value("${device.db.oeeTableName}")
    private String oeeTableName;
    @Value("${device.lamp.url}")
    private String deviceLampUrl;

    @Resource
    private RedisTemplate<String, String> redisTemplate;
    @Resource
    private JdbcTemplate jdbcTemplate;

    final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public void pullDeviceAndPushToIot() throws ParseException {
        String deviceResult = getDeviceInfo();
        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {
        });

        JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
        for (Object o : deviceInfoList) {
            JSONObject deviceInfoJson = (JSONObject) o;

            String projectState = deviceInfoJson.getString("projectState");
            String projectType = deviceInfoJson.getString("projectType");
            String deviceName = deviceInfoJson.getString("deviceName");
            String dtuId = deviceInfoJson.getString("dtuId");
            String deviceId = deviceInfoJson.getString("deviceId");
            String dtuSn = deviceInfoJson.getString("dtuSn");

            String deviceInfoDetails = getDeviceInfoDetail(dtuSn);
            if (StringUtils.isBlank(deviceInfoDetails)) {
                return;
            }

            Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetails, new TypeReference<>() {
            });

            JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
            if (CollectionUtils.isEmpty(deviceInfoDetailList)) {
                return;
            }

            JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);

            String lampState = deviceInfoDetailJson.getString("lampState");
            String startTime = deviceInfoDetailJson.getString("startTime");

            long startTimestamp = 0;
            if (StringUtils.isNotBlank(startTime)) {
                startTimestamp = dateFormat.parse(startTime).getTime();
            }

            long currentTimestamp = System.currentTimeMillis();
            long diffMillis = currentTimestamp - startTimestamp;
            long hours = diffMillis / (1000 * 60 * 60);
            long minutes = (diffMillis % (1000 * 60 * 60)) / (1000 * 60);
            long seconds = (diffMillis % (1000 * 60)) / 1000;
            StringBuilder durationBuilder = new StringBuilder();
            if (hours > 0) {
                durationBuilder.append(hours).append("时");
            }

            if (minutes > 0) {
                durationBuilder.append(minutes).append("分");
            }

            durationBuilder.append(seconds).append("秒");
            String duration = durationBuilder.toString();

            // 获取稼动率
            String utilizationRate = getUtilizationRate(dtuSn);

            log.info("设备数据汇总 - projectState:{}, projectType:{}, deviceName:{}, dtuId:{}, deviceId:{}, dtuSn:{}, " +
                            "lampState:{}, duration:{}, utilizationRate:{}",
                    projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                    lampState, duration, utilizationRate);

            // 保存或更新数据库
            saveOrUpdateDevice(projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                    lampState, startTime, duration, utilizationRate);
        }


    }

    public String getDeviceInfoDetail(String dtuSn) {
        String accessToken = getAccessToken();
        Map<String, String> dtuSnOb = new HashMap<>(1);
        dtuSnOb.put("dtuSn", dtuSn);
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);
        String deviceInfoDetail = sendRequestGet(deviceDetailUrl, dtuSnOb, headerMap);
        if (StringUtils.isBlank(deviceInfoDetail)) {
            return null;
        }

        Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetail,
                new TypeReference<>() {
                });
        Integer deviceInfoDetailCode = (Integer) deviceInfoDetailMap.get("code");
        if (deviceInfoDetailCode != 200) {
            return null;
        }

        JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
        if (CollectionUtils.isEmpty(deviceInfoDetailList)) {
            return null;
        }

        JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);
        //灯详情数据
        //灯状态(0:灭灯，1：红，2：黄，3：绿，4：蓝)
        Integer lampState = deviceInfoDetailJson.getInteger("lampState");
        if (lampState == null) {
            return null;
        }

        return deviceInfoDetail;
    }

    public String getDtuSnRateOfAction(String dtuSn, String startDate, String endDate) {
        String accessToken = getAccessToken();
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);

        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("startDate", startDate);
        paramsMap.put("endDate", endDate);
        paramsMap.put("dtuSn", dtuSn);

        String rateResult = sendRequestGet(deviceSnRateUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(rateResult)) {
            return null;
        }

        Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {});
        Integer rateCode = (Integer) rateMap.get("code");
        if (rateCode != 200) {
            return null;
        }

        return rateResult;
    }

    public String getUtilizationRate(String dtuSn) {
        String today = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        String rateResult = getDtuSnRateOfAction(dtuSn, today, today);
        if (StringUtils.isBlank(rateResult)) {
            return "0%";
        }

        Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {});
        JSONArray dataList = (JSONArray) rateMap.get("data");
        if (CollectionUtils.isEmpty(dataList)) {
            return "0%";
        }

        JSONObject todayData = (JSONObject) dataList.get(0);
        JSONArray realRateList = todayData.getJSONArray("realRate");
        if (CollectionUtils.isEmpty(realRateList)) {
            return "0%";
        }

        JSONObject rateObj = (JSONObject) realRateList.get(0);
        long state0 = rateObj.getLongValue("0");
        long state1 = rateObj.getLongValue("1");
        long state2 = rateObj.getLongValue("2");
        long state3 = rateObj.getLongValue("3");
        long state4 = rateObj.getLongValue("4");
        long state5 = rateObj.getLongValue("5");
        long totalTime = state0 + state1 + state2 + state3 + state4 + state5;
        if (totalTime == 0) {
            return "0%";
        }

        double rate = (double) state3 / totalTime * 100;
        return String.format("%.2f%%", rate);
    }

    public String getLampData(String dtuSn, String date) {
        String accessToken = getAccessToken();
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);

        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("dtuSn", dtuSn);
        paramsMap.put("date", date);

        return sendRequestGet(deviceLampUrl, paramsMap, headerMap);
    }

    public void saveOrUpdateDevice(String projectState, String projectType, String deviceName, String dtuId,
                                    String deviceId, String dtuSn, String lampState, String startTime,
                                    String duration, String utilizationRate) {
        // 查询是否已存在（按公司+dtuSn判断）
        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
                "SELECT id FROM " + deviceTableName + " WHERE corp_code = ? AND dtuSn = ?", deviceCorpCode, dtuSn);

        Date now = new Date();
        if (!existList.isEmpty()) {
            // 更新
            jdbcTemplate.update("UPDATE " + deviceTableName + " SET projectState = ?, projectType = ?, deviceName = ?, " +
                            "dtuId = ?, deviceId = ?, lampState = ?, startTime = ?, duration = ?, utilizationRate = ?, updated_at = ? WHERE dtuSn = ?",
                    projectState, projectType, deviceName, dtuId, deviceId, lampState,
                    startTime, duration, utilizationRate, now, dtuSn);
            log.info("设备数据更新成功 - dtuSn:{}", dtuSn);
        } else {
            // 新增
            String id = UUID.randomUUID().toString().replace("-", "");
            jdbcTemplate.update("INSERT INTO " + deviceTableName + " (id, corp_code, created_at, created_by, updated_at, updated_by, " +
                            "deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState, startTime, duration, utilizationRate) " +
                            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                    id, deviceCorpCode, now, "system", now, "system",
                    deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState,
                    startTime, duration, utilizationRate);
            log.info("设备数据新增成功 - dtuSn:{}", dtuSn);
        }
    }

    /**
     * 首次全量同步：本年1月1日 ~ 昨天（手动触发一次）
     */
    public void pullDevUtilAndSave() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1); // 昨天
        String endDate = sdf.format(cal.getTime());
        cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
        String startDate = sdf.format(cal.getTime());

        log.info("【全量同步】设备利用率，日期范围: {} ~ {}", startDate, endDate);
        doSyncDevUtil(startDate, endDate);
    }

    /**
     * 每日增量同步：仅同步昨天的数据（定时任务自动触发）
     */
    @Scheduled(cron = "${scheduler.devUtil.cron:0 30 2 * * ?}")
    public void pullDevUtilDaily() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        String yesterday = sdf.format(cal.getTime());

        log.info("【每日增量】同步设备利用率，日期: {}", yesterday);
        doSyncDevUtil(yesterday, yesterday);
    }

    /**
     * 核心同步逻辑：获取设备列表 → 按每31天分批调用 dtuSnRateOfAction → 写入/更新 t_auto_ymk_iot_dev_util
     */
    private void doSyncDevUtil(String startDate, String endDate) {
        String deviceResult = getDeviceInfo();
        if (StringUtils.isBlank(deviceResult)) {
            log.error("获取设备列表失败");
            return;
        }
        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {});
        JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
        if (CollectionUtils.isEmpty(deviceInfoList)) {
            log.warn("设备列表为空");
            return;
        }

        // 按最多31天拆分为多个日期区间
        List<DateRange> batches = splitDateRange(startDate, endDate);
        log.info("开始同步设备利用率数据，设备数: {}, 日期范围: {} ~ {}, 共分{}批次",
                deviceInfoList.size(), startDate, endDate, batches.size());
        int totalSaved = 0;

        for (Object o : deviceInfoList) {
            JSONObject deviceInfoJson = (JSONObject) o;
            String dtuSn = deviceInfoJson.getString("dtuSn");

            // 每个设备按31天一批次逐批调用
            for (DateRange batch : batches) {
                try {
                    String rateResult = getDtuSnRateOfAction(dtuSn, batch.start, batch.end);
                    if (StringUtils.isBlank(rateResult)) continue;

                    Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {});
                    Integer code = (Integer) rateMap.get("code");
                    if (code == null || code != 200) continue;

                    JSONArray dataList = (JSONArray) rateMap.get("data");
                    if (CollectionUtils.isEmpty(dataList)) continue;

                    for (int i = 0; i < dataList.size(); i++) {
                        JSONObject dayData = (JSONObject) dataList.get(i);
                        String dateStr = dayData.getString("date");
                        JSONArray realRateList = dayData.getJSONArray("realRate");
                        if (CollectionUtils.isEmpty(realRateList)) continue;

                        JSONObject rateObj = (JSONObject) realRateList.get(0);
                        double state0 = rateObj.getDoubleValue("0");
                        double state1 = rateObj.getDoubleValue("1");
                        double state2 = rateObj.getDoubleValue("2");
                        double state3 = rateObj.getDoubleValue("3");
                        double state4 = rateObj.getDoubleValue("4");

                        saveOrUpdateDevUtil(dtuSn, dateStr, state0, state1, state2, state3, state4);
                        totalSaved++;
                    }
                } catch (Exception e) {
                    log.error("处理设备 {} 数据异常 - 批次:{}~{}", dtuSn, batch.start, batch.end, e);
                }
            }
        }
        log.info("设备利用率数据同步完成，共保存 {} 条记录", totalSaved);
    }

    /**
     * 按最大31天将日期范围拆分为多段
     */
    private static List<DateRange> splitDateRange(String startDate, String endDate) {
        List<DateRange> ranges = new ArrayList<>();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Calendar cur = Calendar.getInstance();
            cur.setTime(sdf.parse(startDate));
            Calendar endCal = Calendar.getInstance();
            endCal.setTime(sdf.parse(endDate));

            while (!cur.after(endCal)) {
                DateRange range = new DateRange(sdf.format(cur.getTime()), null);

                // 向后推进30天（即当前日+30，共31天）
                Calendar batchEnd = Calendar.getInstance();
                batchEnd.setTime(cur.getTime());
                batchEnd.add(Calendar.DAY_OF_MONTH, 30);

                if (!batchEnd.after(endCal)) {
                    range.end = sdf.format(batchEnd.getTime());
                } else {
                    range.end = sdf.format(endCal.getTime());
                }

                ranges.add(range);
                cur.add(Calendar.DAY_OF_MONTH, 31);
            }
        } catch (Exception e) {
            throw new RuntimeException("日期解析失败: " + startDate + " ~ " + endDate, e);
        }
        return ranges;
    }

    private static class DateRange {
        String start;
        String end;

        DateRange(String start, String end) {
            this.start = start;
            this.end = end;
        }
    }

    private void saveOrUpdateDevUtil(String dtuSn, String dateUtil,
                                     double s0, double s1, double s2, double s3, double s4) {
        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
                "SELECT id FROM " + devUtilTableName + " WHERE corp_code = ? AND dtuSn = ? AND date_util = ?",
                deviceCorpCode, dtuSn, dateUtil);

        Date now = new Date();
        if (!existList.isEmpty()) {
            jdbcTemplate.update(
                    "UPDATE " + devUtilTableName + " SET `0`=?,`1`=?,`2`=?,`3`=?,`4`=?,updated_at=? WHERE dtuSn=? AND date_util=?",
                    s0, s1, s2, s3, s4, now, dtuSn, dateUtil);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jdbcTemplate.update(
                    "INSERT INTO " + devUtilTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,date_util,dtuSn,`0`,`1`,`2`,`3`,`4`) " +
                            "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
                    id, deviceCorpCode, now, "system", now, "system", dateUtil, dtuSn, s0, s1, s2, s3, s4);
        }
    }

    // ==================== OEE 时序数据同步 ====================

    /**
     * 首次全量同步 OEE：本年1月1日 ~ 昨天（手动触发一次）
     */
    public void pullOeeAndSave() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        String endDate = sdf.format(cal.getTime());
        cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
        String startDate = sdf.format(cal.getTime());

        log.info("【全量同步】OEE时序数据，日期范围: {} ~ {}", startDate, endDate);
        doSyncOee(startDate, endDate);
    }

    /**
     * 每日增量同步 OEE：仅同步昨天（定时任务自动触发）
     */
    @Scheduled(cron = "${scheduler.oee.cron:0 35 2 * * ?}")
    public void pullOeeDaily() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        String yesterday = sdf.format(cal.getTime());

        log.info("【每日增量】同步OEE时序数据，日期: {}", yesterday);
        doSyncOee(yesterday, yesterday);
    }

    /**
     * OEE 核心同步：获取设备列表 → 每个设备每天调用 /triColorLamp/dtuSn → lampData JSON 存入 description
     */
    private void doSyncOee(String startDate, String endDate) {
        String deviceResult = getDeviceInfo();
        if (StringUtils.isBlank(deviceResult)) {
            log.error("获取设备列表失败");
            return;
        }
        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {});
        JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
        if (CollectionUtils.isEmpty(deviceInfoList)) {
            log.warn("设备列表为空");
            return;
        }

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        List<String> dateList = new ArrayList<>();
        try {
            Date start = sdf.parse(startDate);
            Date end = sdf.parse(endDate);
            Calendar cur = Calendar.getInstance();
            cur.setTime(start);
            while (!cur.getTime().after(end)) {
                dateList.add(sdf.format(cur.getTime()));
                cur.add(Calendar.DAY_OF_MONTH, 1);
            }
        } catch (Exception e) {
            log.error("日期解析失败: {} ~ {}", startDate, endDate, e);
            return;
        }

        log.info("开始同步OEE时序数据，设备数: {}, 天数: {}", deviceInfoList.size(), dateList.size());
        int totalSaved = 0;

        for (Object o : deviceInfoList) {
            JSONObject deviceInfoJson = (JSONObject) o;
            String dtuSn = deviceInfoJson.getString("dtuSn");

            for (String dateStr : dateList) {
                try {
                    String lampResult = getLampData(dtuSn, dateStr);
                    if (StringUtils.isBlank(lampResult)) continue;

                    Map<String, Object> lampMap = JSON.parseObject(lampResult, new TypeReference<>() {});
                    Integer code = (Integer) lampMap.get("code");
                    if (code == null || code != 200) continue;

                    JSONArray dataList = (JSONArray) lampMap.get("data");
                    if (CollectionUtils.isEmpty(dataList)) continue;

                    JSONObject dataObj = (JSONObject) dataList.get(0);
                    JSONArray lampDataArr = dataObj.getJSONArray("lampData");
                    String description = lampDataArr != null ? lampDataArr.toJSONString() : "[]";

                    saveOrUpdateOee(dtuSn, dateStr, description);
                    totalSaved++;
                } catch (Exception e) {
                    log.error("处理OEE设备 {} 数据异常 - date:{}", dtuSn, dateStr, e);
                }
            }
        }
        log.info("OEE时序数据同步完成，共保存 {} 条记录", totalSaved);
    }

    private void saveOrUpdateOee(String dtuSn, String oeeDate, String description) {
        int maxLen = 60000;
        String lamp1 = "";
        String lamp2 = "";

        if (description.length() > maxLen) {
            lamp1 = description.substring(0, maxLen);
            lamp2 = description.substring(maxLen);
        } else {
            lamp1 = description;
        }

        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
                "SELECT id FROM " + oeeTableName + " WHERE corp_code = ? AND dtuSn = ? AND oee_date = ?",
                deviceCorpCode, dtuSn, oeeDate);

        Date now = new Date();
        if (!existList.isEmpty()) {
            jdbcTemplate.update(
                    "UPDATE " + oeeTableName + " SET triColorLamp1=?, triColorLamp2=?, updated_at=? WHERE dtuSn=? AND oee_date=?",
                    lamp1, lamp2, now, dtuSn, oeeDate);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jdbcTemplate.update(
                    "INSERT INTO " + oeeTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,oee_date,triColorLamp1,triColorLamp2) " +
                            "VALUES (?,?,?,?,?,?,?,?,?,?)",
                    id, deviceCorpCode, now, "system", now, "system", dtuSn, oeeDate, lamp1, lamp2);
        }
    }

    public String getEnergyInfo() {
        String accessToken = getAccessToken();
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);

        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("groupName", "SHC");

        String energyInfoResult = sendRequestGet(energyInfoUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(energyInfoResult)) {
            return null;
        }

        // 解析设备信息
        Map<String, Object> energyInfos = JSON.parseObject(energyInfoResult, new TypeReference<>() {
        });
        Integer energyInfoCode = (Integer) energyInfos.get("code");

        // 如果code不为200，可能是accessToken失效，重新获取token并重试
        if (energyInfoCode != 200) {
            accessToken = getAccessToken();
            if (StringUtils.isEmpty(accessToken)) {
                return null;
            }

            // 更新headerMap中的Authorization
            headerMap.put("Authorization", "Bearer " + accessToken);

            // 第二次请求设备信息
            energyInfoResult = sendRequestGet(energyInfoUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(energyInfoResult)) {
                return null;
            }

            // 重新解析设备信息
            energyInfos = JSON.parseObject(energyInfoResult, new TypeReference<Map<String, Object>>() {
            });
            energyInfoCode = (Integer) energyInfos.get("code");

            // 如果第二次请求仍然失败，返回错误信息
            if (energyInfoCode != 200) {
                return null;
            }
        }

        // 返回成功的设备信息
        return energyInfoResult;
    }

    public String getDeviceInfo() {
        String accessToken = getAccessToken();
        // 初始化headerMap并设置Authorization
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);

        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("groupName", "SHC");

        // 第一次请求设备信息
        String deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);

        // 检查设备信息是否为空
        if (StringUtils.isBlank(deviceResult)) {
            return null;
        }

        // 解析设备信息
        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
        });
        Integer deviceInfoCode = (Integer) deviceInfos.get("code");

        // 如果code不为200，可能是accessToken失效，重新获取token并重试
        if (deviceInfoCode != 200) {
            accessToken = getAccessToken();
            if (StringUtils.isEmpty(accessToken)) {
                return null;
            }

            // 更新headerMap中的Authorization
            headerMap.put("Authorization", "Bearer " + accessToken);

            // 第二次请求设备信息
            deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(deviceResult)) {
                return null;
            }

            // 重新解析设备信息
            deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
            });
            deviceInfoCode = (Integer) deviceInfos.get("code");

            // 如果第二次请求仍然失败，返回错误信息
            if (deviceInfoCode != 200) {
                return null;
            }
        }

        // 返回成功的设备信息
        return deviceResult;
    }

    private String getAccessToken() {
        String accessToken = "";
        String redisKey = "hnyssl_device_token";
        if (StringUtils.isNotBlank(redisTemplate.opsForValue().get(redisKey)) && redisTemplate.getExpire(redisKey) > 0) {
            return redisTemplate.opsForValue().get(redisKey);
        }

        Map<String, String> param = new HashMap<>(2);
        param.put("username", deviceUserName);
        param.put("password", devicePassword);
        HttpPost httpPost = new HttpPost(deviceTokenUrl);
        String result = sendPost(httpPost, JSON.toJSONString(param));
        if (StringUtils.isBlank(result)) {
            return accessToken;
        }

        Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {
        });

        Integer code = (Integer) res.get("code");
        if (code == 200) {
            JSONObject data = (JSONObject) res.get("data");
            accessToken = (String) data.get("token");
            redisTemplate.opsForValue().set(redisKey, accessToken, 3600, TimeUnit.SECONDS); // 一小时过期
        }

        return accessToken;
    }

    public static String sendRequestGet(String url, Map<String, String> params, Map<String, String> header) {
        //实例化httpclient
        CloseableHttpClient httpclient = HttpClients.createDefault();
        url = builderUrl(url, params);
        //请求结果
        String content = "";
        //实例化get方法
        HttpGet httpget = new HttpGet(url);
        if (!CollectionUtils.isEmpty(header)) {
            for (Map.Entry<String, String> entry : header.entrySet()) {
                httpget.setHeader(entry.getKey(), entry.getValue());
            }
        }

        try (CloseableHttpResponse response = httpclient.execute(httpget)) {

            //执行get方法
            if (response.getStatusLine().getStatusCode() == 200) {
                content = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (IOException e) {
            log.error("sendRequest---GET Error!", e);
        }
        return content;
    }

    private static String builderUrl(String url, Map<String, String> params) {
        UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
        if (!CollectionUtils.isEmpty(params)) {
            MultiValueMap<String, String> paramsValue = new LinkedMultiValueMap<>();
            for (Map.Entry<String, String> entry : params.entrySet()) {
                paramsValue.add(entry.getKey(), entry.getValue());
            }

            uriBuilder = uriBuilder.queryParams(paramsValue);
        }

        return uriBuilder.toUriString();
    }

    private String sendPost(HttpPost httpPost, String jsonData) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        StringEntity entity = new StringEntity(jsonData, ContentType.create("application/json", Consts.UTF_8));
        httpPost.setEntity(entity);
        String result = null;
        try {
            CloseableHttpResponse execute = httpClient.execute(httpPost);
            HttpEntity res = execute.getEntity();
            InputStream is = res.getContent();
            int len;
            byte[] buf = new byte[128];
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            while ((len = is.read(buf)) != -1) {
                byteArrayOutputStream.write(buf, 0, len);
            }
            result = byteArrayOutputStream.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
}