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.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.message.BasicHeader;
import org.apache.http.util.EntityUtils;
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 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 GhDevicePullService {

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


    @Resource
    private RedisTemplate<String, String> redisTemplate;

    public void pullDeviceAndPushToIot() {
        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);
                    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() {
        JSONArray jsonArray = new JSONArray();
        List<JSONObject> jsonObjectList = new ArrayList<>(13);
        for (int index = 1; index < 14; index++) {
            Map<String, Object> map = new HashMap<>(3);
            map.put("deviceName", "无纺布机组" + index);
            map.put("dtuSn", "AGH20260123" + String.format("%03d", index));
            map.put("lampState", 3);
            JSONObject jsonObject = new JSONObject();
            jsonObject.putAll(map);
            jsonObjectList.add(jsonObject);
        }

        jsonArray.addAll(jsonObjectList);
        return jsonArray;
    }

    private String getTotalCapacity(String key) {
        String totalCapacity = redisTemplate.opsForValue().get(key);
        Double production = 100D;
        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;
    }
}