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.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.lamp.url}")
    private String deviceLampUrl;

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

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

    public void pullDeviceAndPushToIot(String corpCode) throws ParseException {
        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
            log.warn("【设备同步】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
            return;
        }
        String deviceResult = getDeviceInfo(corpCode);
        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(corpCode, 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(corpCode, dtuSn);

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

            saveOrUpdateDevice(corpCode, projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                    lampState, startTime, duration, utilizationRate);
        }
    }

    public String getDeviceInfoDetail(String corpCode, String dtuSn) {
        String accessToken = getAccessToken(corpCode);
        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);
        Integer lampState = deviceInfoDetailJson.getInteger("lampState");
        if (lampState == null) return null;
        return deviceInfoDetail;
    }

    public String getDtuSnRateOfAction(String corpCode, String dtuSn, String startDate, String endDate) {
        String accessToken = getAccessToken(corpCode);
        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 corpCode, String dtuSn) {
        String today = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        String rateResult = getDtuSnRateOfAction(corpCode, 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 corpCode, String dtuSn, String date) {
        String accessToken = getAccessToken(corpCode);
        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);
    }

    private void saveOrUpdateDevice(String corpCode, String projectState, String projectType, String deviceName, String dtuId,
                                    String deviceId, String dtuSn, String lampState, String startTime,
                                    String duration, String utilizationRate) {
        String tableName = corpConfigService.getDeviceTableName(corpCode);
        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);

        List<Map<String, Object>> existList = jt.queryForList(
                "SELECT id FROM " + tableName + " WHERE corp_code = ? AND dtuSn = ?", corpCode, dtuSn);
        Date now = new Date();
        if (!existList.isEmpty()) {
            jt.update("UPDATE " + tableName + " 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("设备数据更新成功 - corpCode:{}, dtuSn:{}", corpCode, dtuSn);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jt.update("INSERT INTO " + tableName + " (id, corp_code, created_at, created_by, updated_at, updated_by, " +
                            "deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState, startTime, duration, utilizationRate) " +
                            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                    id, corpCode, now, "system", now, "system",
                    deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState, startTime, duration, utilizationRate);
            log.info("设备数据新增成功 - corpCode:{}, dtuSn:{}", corpCode, dtuSn);
        }
    }

    /**
     * 首次全量同步
     */
    public void pullDevUtilAndSave(String corpCode) {
        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
            log.warn("【全量同步-利用率】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
            return;
        }
        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("【全量同步】设备利用率, corpCode:{}, 日期范围: {} ~ {}", corpCode, startDate, endDate);
        doSyncDevUtil(corpCode, "2026-05-01", endDate);
    }

    @Scheduled(cron = "${scheduler.devUtil.cron:0 30 2 * * ?}")
    public void pullDevUtilDaily() {
        List<String> corpCodes = corpConfigService.getAllCorpCodes();
        if (corpCodes.isEmpty()) {
            log.warn("【每日增量】设备利用率: 未找到任何公司配置，跳过");
            return;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        String yesterday = sdf.format(cal.getTime());
        for (String corpCode : corpCodes) {
            log.info("【每日增量】同步设备利用率, corpCode:{}, 日期: {}", corpCode, yesterday);
            doSyncDevUtil(corpCode, yesterday, yesterday);
        }
    }

    private void doSyncDevUtil(String corpCode, String startDate, String endDate) {
        String deviceResult = getDeviceInfo(corpCode);
        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;
        }

        List<DateRange> batches = splitDateRange(startDate, endDate);
        log.info("开始同步设备利用率数据, corpCode:{}, 设备数:{}, 日期范围: {} ~ {}, 共分{}批次",
                corpCode, deviceInfoList.size(), startDate, endDate, batches.size());

        for (Object o : deviceInfoList) {
            JSONObject deviceInfoJson = (JSONObject) o;
            String dtuSn = deviceInfoJson.getString("dtuSn");
            for (DateRange batch : batches) {
                try {
                    String rateResult = getDtuSnRateOfAction(corpCode, 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 s0 = rateObj.getDoubleValue("0");
                        double s1 = rateObj.getDoubleValue("1");
                        double s2 = rateObj.getDoubleValue("2");
                        double s3 = rateObj.getDoubleValue("3");
                        double s4 = rateObj.getDoubleValue("4");
                        saveOrUpdateDevUtil(corpCode, dtuSn, dateStr, s0, s1, s2, s3, s4);
                    }
                } catch (Exception e) {
                    log.error("处理设备 {} 数据异常 - 批次:{}~{}", dtuSn, batch.start, batch.end, e);
                }
            }
        }
    }

    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);
                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;
    }

    static class DateRange {
        String start;
        String end;

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

    private void saveOrUpdateDevUtil(String corpCode, String dtuSn, String dateUtil, double s0, double s1, double s2, double s3, double s4) {
        String devUtilTableName = corpConfigService.getDevUtilTableName(corpCode);
        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);

        List<Map<String, Object>> existList = jt.queryForList(
                "SELECT id FROM " + devUtilTableName + " WHERE corp_code = ? AND dtuSn = ? AND date_util = ?",
                corpCode, dtuSn, dateUtil);
        Date now = new Date();
        if (!existList.isEmpty()) {
            jt.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("-", "");
            jt.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, corpCode, now, "system", now, "system", dateUtil, dtuSn, s0, s1, s2, s3, s4);
        }
    }

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

    public void pullOeeAndSave(String corpCode) {
        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
            log.warn("【全量同步-OEE】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
            return;
        }
        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时序数据, corpCode:{}, 日期范围: {} ~ {}", corpCode, startDate, endDate);
        doSyncOee(corpCode, "2026-05-01", endDate);
    }

    @Scheduled(cron = "${scheduler.oee.cron:0 35 2 * * ?}")
    public void pullOeeDaily() {
        List<String> corpCodes = corpConfigService.getAllCorpCodes();
        if (corpCodes.isEmpty()) {
            log.warn("OEE: no corp config found, skip");
            return;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        String yesterday = sdf.format(cal.getTime());
        for (String corpCode : corpCodes) {
            log.info("[Daily] sync OEE, corpCode:{}, date: {}", corpCode, yesterday);
            doSyncOee(corpCode, yesterday, yesterday);
        }
    }

    private void doSyncOee(String corpCode, String startDate, String endDate) {
        String deviceResult = getDeviceInfo(corpCode);
        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;
        }

        int totalSaved = 0;
        for (Object o : deviceInfoList) {
            JSONObject deviceInfoJson = (JSONObject) o;
            String dtuSn = deviceInfoJson.getString("dtuSn");
            for (String dateStr : dateList) {
                try {
                    String lampResult = getLampData(corpCode, 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(corpCode, dtuSn, dateStr, description);
                    totalSaved++;
                } catch (Exception e) {
                    log.error("处理OEE设备 {} 数据异常 - date:{}", dtuSn, dateStr, e);
                }
            }
        }
        log.info("OEE时序数据同步完成，共保存 {} 条记录", totalSaved);
    }

    private void saveOrUpdateOee(String corpCode, String dtuSn, String oeeDate, String description) {
        String oeeTableName = corpConfigService.getOeeTableName(corpCode);
        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
        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 = jt.queryForList(
                "SELECT id FROM " + oeeTableName + " WHERE corp_code = ? AND dtuSn = ? AND oee_date = ?",
                corpCode, dtuSn, oeeDate);
        Date now = new Date();
        if (!existList.isEmpty()) {
            jt.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("-", "");
            jt.update("INSERT INTO " + oeeTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,oee_date,triColorLamp1,triColorLamp2) " +
                    "VALUES (?,?,?,?,?,?,?,?,?,?)", id, corpCode, now, "system", now, "system", dtuSn, oeeDate, lamp1, lamp2);
        }
    }

    public String getEnergyInfo(String corpCode) {
        String accessToken = getAccessToken(corpCode);
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);
        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("groupName", corpConfigService.getIotOrg(corpCode));
        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");
        if (energyInfoCode != 200) {
            accessToken = getAccessToken(corpCode);
            if (StringUtils.isEmpty(accessToken)) return null;
            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 corpCode) {
        String accessToken = getAccessToken(corpCode);
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);
        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("groupName", corpConfigService.getIotOrg(corpCode));
        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");
        if (deviceInfoCode != 200) {
            accessToken = getAccessToken(corpCode);
            if (StringUtils.isEmpty(accessToken)) return null;
            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 corpCode) {
        String redisKey = "hnyssl_device_token_" + corpCode;
        String accessToken = "";
        if (StringUtils.isNotBlank(redisTemplate.opsForValue().get(redisKey)) && redisTemplate.getExpire(redisKey) > 0) {
            return redisTemplate.opsForValue().get(redisKey);
        }
        // 使用公司配置中的用户名密码，如果没有则用默认值
        String userName = corpConfigService.getIotUsername(corpCode);
        String password = corpConfigService.getIotPassword(corpCode);
        Map<String, String> param = new HashMap<>(2);
        param.put("username", userName);
        param.put("password", password);
        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) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        url = builderUrl(url, params);
        String content = "";
        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)) {
            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;
    }
}