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 com.iot.scheduler.model.DeviceToken;
import com.iot.scheduler.model.QxDeviceInfo;
import com.iot.scheduler.model.QxDeviceInfoDetail;
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.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.message.BasicHeader;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalTime;
import java.util.*;

/**
 * 双龙应用数据同步
 */
@Slf4j
@Service
public class ShzzDevicePullService {

    @Value("${shzz.iot.organizeId:}")
    private String iotOrganizeId;
    @Value("${shzz.iot.profileId}")
    private String iotProfileId;
    @Value("${shzz.iot.deviceProfileId}")
    private String iotDeviceProfileId;
    @Value("${shzz.iot.userName:}")
    private String iotUserName;
    @Value("${shzz.iot.password:}")
    private String iotPassword;
    @Value("${shzz.iot.tokenUrl}")
    private String iotTokenUrl;
    @Value("${shzz.iot.infoUrl}")
    private String iotDeviceInfoUrl;
    @Value("${shzz.iot.detailUrl}")
    private String iotDeviceDetailUrl;


    @Resource
    private RedisTemplate<String, String> redisTemplate;

    public void pullDeviceAndPushToIot() {
        LocalTime currentTime = LocalTime.now();
        LocalTime startTime = LocalTime.of(8, 0, 0);  // 08:00:00
        LocalTime endTime = LocalTime.of(18, 0, 0);   // 18:00:00

        boolean isWithinRange =
                !currentTime.isBefore(startTime) &&
                        currentTime.isBefore(endTime);

        if (!isWithinRange) {
            return;
        }

        JSONArray deviceInfoList = getDeviceInfo();
        List<QxDeviceInfo> qxDeviceInfos = new ArrayList<>();
        List<QxDeviceInfoDetail> qxAddDeviceInfoDetails = new ArrayList<>();
        Map<String, QxDeviceInfoDetail> qxDeviceInfoDetailMap = new HashMap<>();
        for (Object o : deviceInfoList) {
            JSONObject deviceInfoJson = (JSONObject) o;
            QxDeviceInfo qxDeviceInfo = new QxDeviceInfo();
            qxDeviceInfo.setDeviceType("DIRECT_CONNECTION");
            qxDeviceInfo.setTransportType("DEFAULT");
            qxDeviceInfo.setOrganizationId(iotOrganizeId);
            qxDeviceInfo.setDeviceProfileId(iotDeviceProfileId);
            qxDeviceInfo.setProfileId(iotProfileId);
//            //项目状态（1：在线，2：离线，3：报警）
//            Integer projectState = deviceInfoJson.getInteger("projectState");
//            if (projectState != null) {
//                qxDeviceInfo.setDescription(String.valueOf(projectState));
//            }

            //项目类型
            qxDeviceInfo.setLabel("生产设备");
            //设备名称
            String deviceName = deviceInfoJson.getString("deviceName");

            qxDeviceInfo.setName(deviceName);
            qxDeviceInfo.setBrand(deviceName);
            //序列号
            String dtuSn = deviceInfoJson.getString("dtuSn");
            qxDeviceInfo.setSn(dtuSn);
            DeviceToken deviceToken = new DeviceToken();
            deviceToken.setCredentialsType("ACCESS_TOKEN");
            deviceToken.setCredentialsId(dtuSn);
            deviceToken.setCredentialsValue(dtuSn);
            qxDeviceInfo.setDeviceToken(deviceToken);
            qxDeviceInfos.add(qxDeviceInfo);
            QxDeviceInfoDetail qxDeviceInfoDetail = new QxDeviceInfoDetail();
            qxDeviceInfoDetail.setAlarm(false);
            //灯状态(0:灭灯，1：红，2：黄，3：绿，4：蓝)
            Integer lampState = deviceInfoJson.getInteger("lampState");
            switch (lampState) {
                case 0:
                    qxDeviceInfoDetail.setStatus("OFF");
                    break;
                case 1:
                    qxDeviceInfoDetail.setStatus("ERROR");
                    qxDeviceInfoDetail.setAlarm(true);
                    break;
                case 2:
                    qxDeviceInfoDetail.setStatus("STAND");
                    break;
                case 3:
                    qxDeviceInfoDetail.setStatus("RUN");
                    //先从缓存里面拿token信息
                    String totalCapacity = getTotalCapacity("gh_total_capacity_" + dtuSn, deviceInfoJson.getDouble("production"));
                    qxDeviceInfoDetail.setCumulativeOutput(Double.valueOf(totalCapacity));
                    break;
                default:
                    continue;
            }


            qxDeviceInfoDetail.setStartTime(new Date());
            qxDeviceInfoDetail.setDtuSn(dtuSn);
            qxDeviceInfoDetailMap.put(dtuSn, qxDeviceInfoDetail);
            qxAddDeviceInfoDetails.add(qxDeviceInfoDetail);
        }

        //将数据同步到IOT平台
        Map<String, String> qxParam = new HashMap<>(2);
        qxParam.put("username", iotUserName);
        qxParam.put("password", iotPassword);

        HttpPost qxHttpPost = new HttpPost(iotTokenUrl);
        String qxResult = sendPost(qxHttpPost, JSON.toJSONString(qxParam));
        if (StringUtils.isBlank(qxResult)) {
            return;
        }
        Map<String, Object> qxRes = JSON.parseObject(qxResult, new TypeReference<>() {
        });

        String qxAccessToken = (String) qxRes.get("token");
        if (StringUtils.isBlank(qxAccessToken)) {
            return;
        }

        BasicHeader qxAuthorization = new BasicHeader("X-Authorization", "Bearer " + qxAccessToken);
        if (!CollectionUtils.isEmpty(qxDeviceInfos)) {
            HttpPost qxDeviceInfoPost = new HttpPost(iotDeviceInfoUrl);
            qxDeviceInfoPost.addHeader(qxAuthorization);
            for (QxDeviceInfo qxDeviceInfo : qxDeviceInfos) {
                // todo
                String syncDeviceInfo = sendPost(qxDeviceInfoPost, JSON.toJSONString(qxDeviceInfo));
                //log.info("同步设备信息 syncDeviceInfo:{}", syncDeviceInfo);
            }
        }

        if (!CollectionUtils.isEmpty(qxAddDeviceInfoDetails)) {
            for (QxDeviceInfoDetail qxDeviceInfoDetail : qxAddDeviceInfoDetails) {
                String qxDeviceInfoDetailUrlStr = iotDeviceDetailUrl + qxDeviceInfoDetail.getDtuSn() + "/telemetry";
                HttpPost qxDeviceInfoDetailPost = new HttpPost(qxDeviceInfoDetailUrlStr);
                qxDeviceInfoDetailPost.addHeader(qxAuthorization);
                String syncDeviceInfoDetail = sendPost(qxDeviceInfoDetailPost, JSON.toJSONString(qxDeviceInfoDetail));
            }
        }
    }

    private JSONArray getDeviceInfo() {
        List<String> deviceNameList = Arrays.asList(
                "新发现KSJ-160智能纸杯机7oz-1", "新发现KSJ-160智能纸杯机7oz-2", "新发现KSJ-160智能纸杯机6.5oz", "新发现KSJ-160智能纸杯机8oz-1",
                "新发现KSJ-160智能纸杯机8oz-2", "新发现PJJ-III型纸容器品检机6.5oz/7oz", "新发现PJJ-III型纸容器品检机7.5oz/8oz",
                "新发现PJJ-I-02型纸容器品检机7.5oz/8oz", "新发现PJJ-I-02型纸容器品检机7.5oz/12oz", "新发现KSJ-160智能快速纸杯机7.5oz-1",
                "新发现KSJ-160智能快速纸杯机7.5oz-2", "新发现KSJ-160智能快速纸杯机12oz", "智能中速纸杯机JBZ-22D-1",
                "智能中速纸杯机JBZ-22D-2", "智能中速纸杯机JBZ-22D-3", "智能中速纸杯机JBZ-22D-4", "智能中速纸杯机JBZ-22D-5", "智能中速纸杯机JBZ-22D-6",
                "智能中速纸杯机JBZ-22D-7", "智能中速纸杯机JBZ-22D-8", "智能中速纸杯机JBZ-22D-9", "智能中速纸杯机JBZ-22S-1", "智能中速纸杯机JBZ-22S-2",
                "高速智能纸杯机DEBAO-100S", "纸机杯XC-L12齿轮340-B型-1", "纸机杯XC-L12齿轮340-B型-2", "中速外贴机SM100-KT490(12oz)",
                "中速外贴机SM100-KT491(4oz)", "中速外贴机SM100-KY373", "中速外贴机SM100-KT489(16oz)", "外贴机8oz", "外贴机12oz", "模切机1",
                "模切机2", "模切机3", "模切机4", "模切机5");
        JSONArray jsonArray = new JSONArray();
        List<JSONObject> jsonObjectList = new ArrayList<>(38);
        for (int index = 0; index < deviceNameList.size(); index++) {
            Map<String, Object> map = new HashMap<>(3);
            map.put("deviceName", deviceNameList.get(index));
            map.put("dtuSn", "SGH20250123" + String.format("%03d", index));
            map.put("lampState", 3);
            if (index < 11) {
                map.put("production", 130D);
            } else if (index == 11) {
                map.put("production", 120D);
            } else if (index < 23) {
                map.put("production", 80D);
            } else if (index == 23) {
                map.put("production", 110D);
            } else if (index < 26) {
                map.put("production", 50D);
            } else if (index < 30) {
                map.put("production", 120D);
            } else {
                map.put("production", 80D);
            }
            JSONObject jsonObject = new JSONObject();
            jsonObject.putAll(map);
            jsonObjectList.add(jsonObject);
        }

        jsonArray.addAll(jsonObjectList);
        return jsonArray;
    }

    private String getTotalCapacity(String key, Double production) {
        String totalCapacity = redisTemplate.opsForValue().get(key);
        Double totalCapacityD = 0D;
        if (StringUtils.isEmpty(totalCapacity)) {
            totalCapacityD = production;
        } else {
            totalCapacityD = Double.parseDouble(totalCapacity) + production;
        }

        redisTemplate.opsForValue().set(key, String.valueOf(totalCapacityD));
        return String.valueOf(totalCapacityD);
    }

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