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.scheduling.annotation.Scheduled;
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.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class EnergyPullService {

    @Value("${energy.token.url}")
    private String energyTokenUrl;
    @Value("${energy.token.userName}")
    private String energyUserName;
    @Value("${energy.token.password}")
    private String energyPassword;
    @Value("${energy.deviceList.url}")
    private String energyDeviceListUrl;
    @Value("${energy.detail.url}")
    private String energyDetailUrl;
    @Value("${energy.db.corpCode}")
    private String energyCorpCode;
    @Value("${energy.db.tableName}")
    private String energyTableName;
    @Value("${energy.db.eqKwhTableName}")
    private String eqKwhTableName;
    @Value("${energy.db.eRunDtlTableName}")
    private String eRunDtlTableName;
    @Value("${energy.runStatus.url}")
    private String energyRunStatusUrl;

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

    /**
     * 定时任务：同步能耗设备数据
     */
    @Scheduled(cron = "${scheduler.energy.cron:0 0/5 * * ?}")
    public void pullEnergyDeviceAndSave() {
        log.info("【能耗数据同步】开始同步能耗设备数据");
        try {
            String energyResult = getEnergyDeviceList();
            if (StringUtils.isBlank(energyResult)) {
                log.error("【能耗数据同步】获取能耗设备列表失败");
                return;
            }

            Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {});
            Integer code = (Integer) energyInfos.get("code");
            if (code == null || code != 200) {
                log.error("【能耗数据同步】获取能耗设备列表返回code不为200, code:{}, response:{}", code, energyResult);
                return;
            }

            JSONArray dataList = (JSONArray) energyInfos.get("data");
            if (CollectionUtils.isEmpty(dataList)) {
                log.warn("【能耗数据同步】能耗设备列表为空");
                return;
            }

            int successCount = 0;
            for (Object o : dataList) {
                JSONObject deviceJson = (JSONObject) o;

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

                log.info("【能耗数据处理】deviceName:{}, dtuSn:{}, projectState:{}, projectType:{}",
                        deviceName, dtuSn, projectState, projectType);

                // 获取今日用电量
                String todayEvalue = getTodayEnergyValue(dtuSn);

                // 获取能耗OEE历史数据（最后一条的duration和runStatus）
                Map<String, String> runStatusMap = getEnergyRunStatus(dtuSn);
                String duration = runStatusMap.get("duration");
                String runStatus = runStatusMap.get("runStatus");

                saveOrUpdateEnergyDevice(projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                        todayEvalue, duration, runStatus);
                successCount++;
            }

            log.info("【能耗数据同步】同步完成，共处理 {} 条设备数据", successCount);
        } catch (Exception e) {
            log.error("【能耗数据同步】同步过程发生异常", e);
        }
    }

    /**
     * 获取能耗设备列表
     */
    public String getEnergyDeviceList() {
        String accessToken = getEnergyAccessToken();
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);

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

        // 第一次请求
        String result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(result)) {
            return null;
        }

        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {});
        Integer resultCode = (Integer) resultMap.get("code");

        // Token失效，重试一次
        if (resultCode == null || resultCode != 200) {
            log.warn("【能耗设备列表】第一次请求失败，重新获取Token重试");
            accessToken = getEnergyAccessToken();
            if (StringUtils.isEmpty(accessToken)) {
                return null;
            }
            headerMap.put("Authorization", "Bearer " + accessToken);

            result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(result)) {
                return null;
            }

            resultMap = JSON.parseObject(result, new TypeReference<>() {});
            resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                log.error("【能耗设备列表】重试后仍然失败, code:{}", resultCode);
                return null;
            }
        }

        return result;
    }

    /**
     * 获取能耗Token
     */
    private String getEnergyAccessToken() {
        String redisKey = "hnyssl_energy_token";
        
        // 检查Redis中是否有有效Token
        String cachedToken = redisTemplate.opsForValue().get(redisKey);
        if (StringUtils.isNotBlank(cachedToken) && redisTemplate.getExpire(redisKey) > 0) {
            return cachedToken;
        }

        // 请求新Token
        Map<String, String> param = new HashMap<>(2);
        param.put("username", energyUserName);
        param.put("password", energyPassword);

        HttpPost httpPost = new HttpPost(energyTokenUrl);
        String result = sendPost(httpPost, JSON.toJSONString(param));
        if (StringUtils.isBlank(result)) {
            log.error("【能耗Token】请求Token失败，响应为空");
            return "";
        }

        Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {});
        Integer code = (Integer) res.get("code");
        if (code == null || code != 200) {
            log.error("【能耗Token】请求Token返回异常, code:{}", code);
            return "";
        }

        JSONObject data = (JSONObject) res.get("data");
        String token = data.getString("token");
        if (StringUtils.isBlank(token)) {
            log.error("【能耗Token】响应中没有token");
            return "";
        }

        // 缓存Token，有效期1小时（Token实际有效期2小时）
        redisTemplate.opsForValue().set(redisKey, token, 3600, TimeUnit.SECONDS);
        log.info("【能耗Token】获取Token成功并缓存");

        return token;
    }

    /**
     * 保存或更新能耗设备数据（含用电量evalue、duration、runStatus）
     */
    private void saveOrUpdateEnergyDevice(String projectState, String projectType, String deviceName,
                                          String dtuId, String deviceId, String dtuSn,
                                          String evalue, String duration, String runStatus) {
        // 查询是否已存在（按公司+dtuSn判断）
        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
                "SELECT id FROM " + energyTableName + " WHERE corp_code = ? AND dtuSn = ?", energyCorpCode, dtuSn);

        Date now = new Date();
        if (!existList.isEmpty()) {
            // 更新
            jdbcTemplate.update(
                    "UPDATE " + energyTableName +
                    " SET projectState = ?, projectType = ?, deviceName = ?, dtuId = ?, deviceId = ?, evalue = ?, duration = ?, runStatus = ?, updated_at = ?" +
                    " WHERE corp_code = ? AND dtuSn = ?",
                    projectState, projectType, deviceName, dtuId, deviceId, evalue, duration, runStatus, now, energyCorpCode, dtuSn);
            log.debug("【能耗数据】更新成功 - dtuSn:{}, evalue:{}, runStatus:{}", dtuSn, evalue, runStatus);
        } else {
            // 新增
            String id = UUID.randomUUID().toString().replace("-", "");
            jdbcTemplate.update(
                    "INSERT INTO " + energyTableName +
                    " (id, corp_code, created_at, created_by, updated_at, updated_by, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus)" +
                    " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                    id, energyCorpCode, now, "system", now, "system",
                    deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus);
            log.debug("【能耗数据】新增成功 - dtuSn:{}, evalue:{}", dtuSn, evalue);
        }
    }

    /**
     * 获取能耗OEE历史数据
     * 调用 /api/energy/runStatus?dtuSn=xxx&date=today
     * @return Map包含 lastDuration（最后一条的duration）和 lastRunStatus（最后一条的runStatus），失败返回空Map
     */
    private Map<String, String> getEnergyRunStatus(String dtuSn) {
        Map<String, String> result = new HashMap<>();
        result.put("duration", null);
        result.put("runStatus", null);
        try {
            String accessToken = getEnergyAccessToken();
            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", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));

            String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(response)) {
                return result;
            }

            Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {});
            Integer resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                // Token失效重试
                accessToken = getEnergyAccessToken();
                if (StringUtils.isEmpty(accessToken)) {
                    return result;
                }
                headerMap.put("Authorization", "Bearer " + accessToken);
                response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
                if (StringUtils.isBlank(response)) {
                    return result;
                }
                resultMap = JSON.parseObject(response, new TypeReference<>() {});
                resultCode = (Integer) resultMap.get("code");
                if (resultCode == null || resultCode != 200) {
                    return result;
                }
            }

            JSONArray dataList = (JSONArray) resultMap.get("data");
            // 完整data保存到 t_auto_ymk_iot_e_run_dtl 表
            String description = dataList != null ? dataList.toJSONString() : "[]";
            saveOrUpdateERunDtl(dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));

            // 取最后一条数据的 duration 和 runStatus
            if (!CollectionUtils.isEmpty(dataList)) {
                JSONObject lastItem = (JSONObject) dataList.get(dataList.size() - 1);
                Long durVal = lastItem.getLong("duration");
                Integer statusVal = lastItem.getInteger("runStatus");
                result.put("duration", durVal != null ? String.valueOf(durVal) : null);
                result.put("runStatus", statusVal != null ? String.valueOf(statusVal) : null);
                log.info("【能耗OEE】dtuSn:{}, 最后一条 - duration:{}, runStatus:{}",
                        dtuSn, result.get("duration"), result.get("runStatus"));
            }
        } catch (Exception e) {
            log.error("【能耗OEE】获取异常 - dtuSn:{}", dtuSn, e);
        }
        return result;
    }

    /**
     * 保存或更新能耗OEE运行状态明细到 t_auto_ymk_iot_e_run_dtl 表
     * 超过60000字符拆分存入runStatus2
     */
    private void saveOrUpdateERunDtl(String dtuSn, String description, String useDate) {
        int maxLen = 60000;
        String rs1 = "";
        String rs2 = "";

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

        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
                "SELECT id FROM " + eRunDtlTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?",
                energyCorpCode, dtuSn, useDate);

        Date now = new Date();
        if (!existList.isEmpty()) {
            jdbcTemplate.update(
                    "UPDATE " + eRunDtlTableName + " SET runStatus1=?, runStatus2=?, updated_at=? WHERE corp_code=? AND dtuSn=? AND use_date=?",
                    rs1, rs2, now, energyCorpCode, dtuSn, useDate);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jdbcTemplate.update(
                    "INSERT INTO " + eRunDtlTableName +
                    " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,use_date,runStatus1,runStatus2)" +
                    " VALUES (?,?,?,?,?,?,?,?,?,?)",
                    id, energyCorpCode, now, "system", now, "system", dtuSn, useDate, rs1, rs2);
        }
    }

    // ==================== 能耗历史数据全量/增量同步 ====================

    /**
     * 首次全量同步：本年1月1日 ~ 昨天（手动触发一次）
     */
    public void pullEnergyHistoryAndSave() {
        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);
        doSyncEnergyHistory(startDate, endDate);
    }
//
//    /**
//     * 每日增量同步：仅同步昨天的数据（定时任务自动触发）
//     */
//    @Scheduled(cron = "${scheduler.energyHistory.cron:0 40 2 * * ?}")
//    public void pullEnergyHistoryDaily() {
//        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);
//        doSyncEnergyHistory(yesterday, yesterday);
//    }

    /**
     * 核心同步逻辑：获取能耗设备列表 → 每个设备每天调用用电量+OEE接口 → 写入 eq_kwh / e_run_dtl 表
     */
    private void doSyncEnergyHistory(String startDate, String endDate) {
        String energyResult = getEnergyDeviceList();
        if (StringUtils.isBlank(energyResult)) {
            log.error("【能耗历史】获取设备列表失败");
            return;
        }

        Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {});
        Integer code = (Integer) energyInfos.get("code");
        if (code == null || code != 200) {
            log.error("【能耗历史】获取设备列表返回code异常, code:{}", code);
            return;
        }

        JSONArray deviceList = (JSONArray) energyInfos.get("data");
        if (CollectionUtils.isEmpty(deviceList)) {
            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("【能耗历史】开始同步，设备数:{}, 天数:{}, 总计 {} 条记录待处理",
                deviceList.size(), dateList.size(), deviceList.size() * dateList.size());

        int totalSaved = 0;
        for (Object o : deviceList) {
            JSONObject deviceJson = (JSONObject) o;
            String dtuSn = deviceJson.getString("dtuSn");

            for (String dateStr : dateList) {
                try {
                    // 1. 同步当日用电量数据到 t_auto_ymk_iot_eq_kwh
                    syncEnergyValueForDate(dtuSn, dateStr);

                    // 2. 同步当日OEE时序数据到 t_auto_ymk_iot_e_run_dtl
                    syncRunStatusForDate(dtuSn, dateStr);

                    totalSaved++;
                } catch (Exception e) {
                    log.error("【能耗历史】处理异常 - dtuSn:{}, date:{}", dtuSn, dateStr, e);
                }
            }
        }

        log.info("【能耗历史】同步完成，共保存 {} 条记录", totalSaved);
    }

    /**
     * 同步指定日期的设备用电量数据到 t_auto_ymk_iot_eq_kwh 表
     */
    private void syncEnergyValueForDate(String dtuSn, String dateStr) {
        String accessToken = getEnergyAccessToken();
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);

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

        String result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(result)) {
            return;
        }

        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {});
        Integer resultCode = (Integer) resultMap.get("code");
        if (resultCode == null || resultCode != 200) {
            accessToken = getEnergyAccessToken();
            if (StringUtils.isEmpty(accessToken)) {
                return;
            }
            headerMap.put("Authorization", "Bearer " + accessToken);
            result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(result)) {
                return;
            }
            resultMap = JSON.parseObject(result, new TypeReference<>() {});
            resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                return;
            }
        }

        JSONArray dataList = (JSONArray) resultMap.get("data");
        String description = dataList != null ? dataList.toJSONString() : "[]";
        saveOrUpdateEqKwh(dtuSn, description, dateStr + " 00:00:00");
    }

    /**
     * 同步指定日期的设备OEE时序数据到 t_auto_ymk_iot_e_run_dtl 表
     */
    private void syncRunStatusForDate(String dtuSn, String dateStr) {
        String accessToken = getEnergyAccessToken();
        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", dateStr);

        String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(response)) {
            return;
        }

        Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {});
        Integer resultCode = (Integer) resultMap.get("code");
        if (resultCode == null || resultCode != 200) {
            accessToken = getEnergyAccessToken();
            if (StringUtils.isEmpty(accessToken)) {
                return;
            }
            headerMap.put("Authorization", "Bearer " + accessToken);
            response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(response)) {
                return;
            }
            resultMap = JSON.parseObject(response, new TypeReference<>() {});
            resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                return;
            }
        }

        JSONArray dataList = (JSONArray) resultMap.get("data");
        String description = dataList != null ? dataList.toJSONString() : "[]";
        saveOrUpdateERunDtl(dtuSn, description, dateStr + " 00:00:00");
    }

    /**
     * 获取今日设备用电量 (type=0 按小时查询)
     * 同时将完整响应data保存到 t_auto_ymk_iot_eq_kwh 表
     * @return 今日用电量value，失败返回null
     */
    private String getTodayEnergyValue(String dtuSn) {
        try {
            String accessToken = getEnergyAccessToken();
            Map<String, String> headerMap = new HashMap<>(1);
            headerMap.put("Authorization", "Bearer " + accessToken);

            Map<String, String> paramsMap = new HashMap<>();
            paramsMap.put("dtuSn", dtuSn);
            paramsMap.put("startDate", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
            paramsMap.put("type", "0");

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

            Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {});
            Integer resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                accessToken = getEnergyAccessToken();
                if (StringUtils.isEmpty(accessToken)) {
                    return null;
                }
                headerMap.put("Authorization", "Bearer " + accessToken);
                result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
                if (StringUtils.isBlank(result)) {
                    return null;
                }
                resultMap = JSON.parseObject(result, new TypeReference<>() {});
                resultCode = (Integer) resultMap.get("code");
                if (resultCode == null || resultCode != 200) {
                    return null;
                }
            }

            JSONArray dataList = (JSONArray) resultMap.get("data");
            // 将完整data保存到eq_kwh表
            String description = dataList != null ? dataList.toJSONString() : "[]";
            saveOrUpdateEqKwh(dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));

            // 累加所有小时的value作为今日总用电量
            double totalValue = 0;
            if (!CollectionUtils.isEmpty(dataList)) {
                for (Object o : dataList) {
                    JSONObject item = (JSONObject) o;
                    totalValue += item.getDoubleValue("value");
                }
            }

            String evalueStr = String.valueOf(totalValue);
            log.info("【能耗用电量】dtuSn:{}, 今日用电量:{}", dtuSn, evalueStr);
            return evalueStr;

        } catch (Exception e) {
            log.error("【能耗用电量】获取异常 - dtuSn:{}", dtuSn, e);
            return null;
        }
    }

    /**
     * 保存或更新用电量数据到 t_auto_ymk_iot_eq_kwh 表
     */
    private void saveOrUpdateEqKwh(String dtuSn, String description, String useDate) {
        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
                "SELECT id FROM " + eqKwhTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?",
                energyCorpCode, dtuSn, useDate);

        Date now = new Date();
        if (!existList.isEmpty()) {
            jdbcTemplate.update(
                    "UPDATE " + eqKwhTableName + " SET description = ?, updated_at = ? WHERE corp_code = ? AND dtuSn = ? AND use_date = ?",
                    description, now, energyCorpCode, dtuSn, useDate);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jdbcTemplate.update(
                    "INSERT INTO " + eqKwhTableName +
                    " (id, corp_code, created_at, created_by, updated_at, updated_by, dtuSn, use_date, description)" +
                    " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                    id, energyCorpCode, now, "system", now, "system", dtuSn, useDate, description);
        }
    }

    /**
     * 发送GET请求
     */
    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;
    }

    /**
     * 构建带参数的URL
     */
    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();
    }

    /**
     * 发送POST请求
     */
    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) {
            log.error("sendPost error!", e);
        }
        return result;
    }
}