package com.yingji.quartz;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.json.JSONUtil;
import com.yingji.entity.Alarm;
import com.yingji.entity.dto.request.AlarmRequest;
import com.yingji.service.AlarmService;
import com.yingji.service.SourceService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
 * 110数据保存定时任务
 *
 * @author wu
 * @since 2024/05/06 10:18
 */
@Configuration
public class AlarmQuartz {

    public static final Logger log = LoggerFactory.getLogger(AlarmQuartz.class);

    @Resource
    private AlarmService alarmService;

    @Resource
    private SourceService sourceService;

    /**
     * 保存所有数据
     */
    @Async
    @Scheduled(cron = "0 */1 * * * ? ")
    public void savaData() {
        // 获取token
        String token = alarmService.getToken();
        // 查询所有id
        List<String> idList = findId(token);
        // 根据id查询数据保存
        addList(idList, token);
        // 110算法接口
        if (CollectionUtil.isNotEmpty(idList)) {
            emergencyAlgorithm();
        }
    }

    /**
     * 110算法接口
     */
    public void emergencyAlgorithm() {
        log.info("============110算法接口开始" + LocalDateTime.now() + "=============");
        // 获取当前的时间
        LocalDateTime endTime = LocalDateTime.now();
        // 获取五分钟前时间
        LocalDateTime startTime = endTime.minusMinutes(1);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
        String endTimeStr = endTime.format(formatter) + ":00";
        String startTimeStr = startTime.format(formatter) + ":00";
        Map<String, String> map = new HashMap<>();
        map.put("startTime", startTimeStr);
        map.put("endTime", endTimeStr);
        String body = JSONUtil.toJsonStr(map);
        HttpRequest.post("http://localhost:9002/emergency_algorithm").body(body).execute().body();
        log.info("============110算法接口结束" + LocalDateTime.now() + "=============");
    }

    /**
     * 根据id查询数据保存
     *
     * @param idList 数据id
     * @param token  token
     */
    private void addList(List<String> idList, String token) {
        // 查询数据条件
        AlarmRequest alarmRequest = new AlarmRequest();
        alarmRequest.setType("getValue");
        alarmRequest.setPageIndex(1);
        alarmRequest.setPageSize(10);
        // 定义成功条数
        int successNum = 0;
        // 定义保存数据的集合
        List<Alarm> list = new ArrayList<>();
        if (CollUtil.isNotEmpty(idList)) {
            try {
                for (String x : idList) {
                    alarmRequest.setValue(x);
                    // 查询数据
                    Alarm alarm = alarmService.findDataList(alarmRequest, token);
                    if (alarm != null) {
                        alarm.setSourceId(x);
                        list.add(alarm);
                        successNum++;
                        // 生成100到200的随机数
                        Random random = new Random();
                        int randomNumber = random.nextInt(101) + 100;
                        Thread.sleep(randomNumber);
                    } else {
                        return;
                    }
                }
            } catch (Exception e) {
                log.info("==========================" + e.getMessage());
            }
        }
        alarmService.saveAll(list);
        log.info("成功条数==========================" + successNum);
    }

    /**
     * 查询数据id
     *
     * @param token token
     * @return token token
     */
    private List<String> findId(String token) {
        // 定义变量存放 id
        List<String> idList = new ArrayList<>();
        if (StrUtil.isEmpty(token)) {
            return idList;
        }
        // 获取数据库中最新的时间
        LocalDateTime nowTime = alarmService.findNowTime();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmm");
        String yesterdayStr = nowTime.format(formatter) + "00";
        // 定义起始页
        int pageIndex = 1;
        // 定义每页显示条数
        int pageSize = 500;
        // 定义总数据条数
        int size = 0;
        // 定义type
        String type = "getId";
        // 查询id条件
        AlarmRequest req = new AlarmRequest();
        req.setType(type);
        req.setValue(yesterdayStr);
        req.setPageIndex(pageIndex);
        req.setPageSize(pageSize);
        while (true) {
            List<String> data = alarmService.findDataIdList(req, token);
            if (data == null) {
                return idList;
            }
            sourceService.addList(data);
            idList.addAll(data);
            size += data.size();
            if (data.size() == pageSize) {
                req.setPageIndex(pageIndex++);
                log.info("第" + pageIndex + "页==========================" + size + "条数据");
            } else {
                break;
            }
        }
        return idList;
    }
}