package com.fs.watch.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.fs.common.config.WatchConfig;
import com.fs.common.utils.DateUtils;
import com.fs.common.utils.StringUtils;
import com.fs.watch.domain.SleepSection;
import com.fs.watch.domain.WatchRriData;
import com.fs.watch.mapper.WatchRriDataMapper;
import com.fs.watch.service.WatchRriDataService;
import com.fs.watch.utils.ListConverterUtils;
import com.fs.watch.utils.MyHttpUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.*;

/**
 * @author Administrator
 * @description 针对表【watch_rri_data(设备心跳间隙数据，每分钟一个数据包)】的数据库操作Service实现
 * @createDate 2024-10-15 11:06:51
 */
@Service
@Slf4j
public class WatchRriDataServiceImpl implements WatchRriDataService {

    @Autowired
    private WatchRriDataMapper mapper;

    @Autowired
    private WatchConfig watchConfig;

    private static final MyHttpUtils httpUtils = new MyHttpUtils();

    /**
     * @author Administrator
     * @description 针对表【watch_rri_data(rri数据)】的数据库操作Service实现
     * @createDate 2024-08-01 14:00:23
     */

    @Override
    public Boolean insert(WatchRriData watchRriData) {
        //判断创建时间是否唯一
        Integer num = mapper.queryByCreateTime(watchRriData.getCreateTime());
        if (num != null && num > 0) {
            return false;
        }
        try {
            mapper.insert(watchRriData);
        } catch (Exception e) {
            log.error("===============watchRriData:insert=========================={}", e.getMessage());
            return false;
        }
        return true;
    }

    @Override
    public Map<String, Object> queryByDateAndDeviceId(String date, String deviceId) {
        //1.查询数据
        List<WatchRriData> data = this.getByDateAndDeviceId(date, deviceId);
        Map<String, Object> map = new HashMap<>();
        map.put("data", data);
        //2.分析数据得到结果
        //2.1组装分析所需参数
        List<Short> params = new ArrayList<>();
        for (WatchRriData rriData : data) {
//            String jsonDataVal = rriData.getJsonDataVal();
//            List<Short> vals = ListConverterUtils.convertStringToShortList(jsonDataVal);

            params.addAll(rriData.getVal());
        }
        HashMap<String, Object> param = new HashMap<>();
        param.put("rri_list", params);
        //2025.1.6新增三个参数
        param.put("device_id", deviceId);
        param.put("account", watchConfig.getAccount1());
        param.put("password", watchConfig.getPassword1());
        //2.2发送请求
        Map resData = httpUtils.getPost2("https://api1.iwown.com/algoservice", "/calculation/af", param);

        if (resData == null) {
            param.put("account", watchConfig.getAccount2());
            param.put("password", watchConfig.getPassword2());
            resData = httpUtils.getPost2("https://api1.iwown.com/algoservice", "/calculation/af", param);
            if (resData == null) {
                param.put("account", watchConfig.getAccount3());
                param.put("password", watchConfig.getPassword3());
                resData = httpUtils.getPost2("https://api1.iwown.com/algoservice", "/calculation/af", param);
            }
        }
        if (resData != null) {
            /**
             * 0 无结果, 有干扰或者数据异常
             * 1 窦性心率
             * 2 窦性心率过缓
             * 3 窦性心率过速
             * 4 心律不齐（早搏）
             * 5 心律不齐（房颤）
             * 6 心率过速（室上性心动过速）
             */
            Integer result = (Integer) resData.get("result");
            String mes = "";
            switch (result) {
                case 0:
                    mes = "无结果";
                    break;
                case 1:
                    mes = "窦性心率. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                    break;
                case 2:
                    mes = "窦性心率过缓. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                    break;
                case 3:
                    mes = "窦性心率过速. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                    break;
                case 4:
                    mes = "心律不齐（早搏）. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                    break;
                case 5:
                    mes = "心律不齐（房颤）. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                    break;
                case 6:
                    mes = "心率过速（室上性心动过速）. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                    break;
            }
            map.put("mes", mes);
//            map.put("result", resData);
        }
        return map;
    }

    @Override
    public Map<String, Object> queryLastByDateAndDeviceId(String deviceId) {
        //查询最新时间
        String time = mapper.getLastTime(deviceId);
        //1.查询数据
        List<WatchRriData> data = mapper.getLastByDateAndDeviceId(time,deviceId);
        if (data != null && !data.isEmpty()) {
            Map<String, Object> map = new HashMap<>();
            map.put("data", data);
            //2.分析数据得到结果
            //2.1组装分析所需参数
            List<Short> params = new ArrayList<>();
            for (WatchRriData rriData : data) {
                params.addAll(rriData.getVal());
            }
            HashMap<String, Object> param = new HashMap<>();
            param.put("rri_list", params);
            param.put("device_id", deviceId);
            param.put("account", watchConfig.getAccount1());
            param.put("password", watchConfig.getPassword2());
            //2.2发送请求
            Map resData = null;
            if (!params.isEmpty()) {
                resData = httpUtils.getPost2("https://api1.iwown.com/algoservice", "/calculation/af", param);
                if (resData == null) {
                    param.put("account", watchConfig.getAccount2());
                    param.put("password", watchConfig.getPassword2());
                    resData = httpUtils.getPost2("https://api1.iwown.com/algoservice", "/calculation/af", param);
                    if (resData == null) {
                        param.put("account", watchConfig.getAccount3());
                        param.put("password", watchConfig.getPassword3());
                        resData = httpUtils.getPost2("https://api1.iwown.com/algoservice", "/calculation/af", param);
                    }
                }
            } else {
                return null;
            }

            if (resData != null) {
                /**
                 * 0 无结果, 有干扰或者数据异常
                 * 1 窦性心率
                 * 2 窦性心率过缓
                 * 3 窦性心率过速
                 * 4 心律不齐（早搏）
                 * 5 心律不齐（房颤）
                 * 6 心率过速（室上性心动过速）
                 */
                Integer result = (Integer) resData.get("result");
                String mes = "";
                switch (result) {
                    case 0:
                        mes = "无结果";
                        break;
                    case 1:
                        mes = "窦性心率. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                        break;
                    case 2:
                        mes = "窦性心率过缓. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                        break;
                    case 3:
                        mes = "窦性心率过速. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                        break;
                    case 4:
                        mes = "心律不齐（早搏）. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                        break;
                    case 5:
                        mes = "心律不齐（房颤）. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                        break;
                    case 6:
                        mes = "心率过速（室上性心动过速）. 散点图: 基于⾮线性混沌理论,依靠计算机快速运算技术,对⻓程RR间期数据进⾏图形表达,⽤于⼼率变异";
                        break;
                }
                map.put("mes", mes);
                map.put("date",data.get(0).getCreateTime());
                return map;
            }
        }
        return null;
    }

    /**
     * 查询某天某个设备的房颤数据
     *
     * @param date
     * @param deviceId
     * @return
     */
    @Override
    public List<WatchRriData> getByDateAndDeviceId(String date, String deviceId) {
        if (StringUtils.isBlank(date)) {
            date = DateUtils.dateTimeNow("yyyy-MM-dd");
        }
        return mapper.getByDateAndDeviceId(date,deviceId);
    }
}
