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;

@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;

    @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 accessToken = getAccessToken();
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);

        Map<String, String> paramsMap = new HashMap<>();
        String today = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        paramsMap.put("startDate", today);
        paramsMap.put("endDate", today);
        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 rateResult = getDtuSnRateOfAction(dtuSn);
        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 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);
        }
    }

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