package com.zhgd.xmgl.task;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.gexin.fastjson.JSON;
import com.zhgd.xmgl.modules.bigdevice.entity.Tower;
import com.zhgd.xmgl.modules.bigdevice.entity.TowerCurrentData;
import com.zhgd.xmgl.modules.bigdevice.entity.TowerWorkCycle;
import com.zhgd.xmgl.modules.bigdevice.mapper.TowerCurrentDataMapper;
import com.zhgd.xmgl.modules.bigdevice.mapper.TowerMapper;
import com.zhgd.xmgl.modules.bigdevice.mapper.TowerWorkCycleMapper;
import com.zhgd.xmgl.modules.bigdevice.service.ITowerCurrentDataService;
import com.zhgd.xmgl.modules.bigdevice.service.ITowerWorkCycleService;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.task.dto.TowerCycleDataDto;
import com.zhgd.xmgl.task.dto.TowerDataDto;
import com.zhgd.xmgl.util.XiwonUtil;
import lombok.extern.slf4j.Slf4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.CompletableFuture;

@Slf4j
@Component
@RestController
@RequestMapping("/xmgl/task/")
public class TowerTask {
    @Autowired
    private ProjectMapper projectMapper;
    @Autowired
    private TowerMapper towerMapper;
    @Autowired
    private TowerCurrentDataMapper towerCurrentDataMapper;
    @Autowired
    private TowerWorkCycleMapper towerWorkCycleMapper;
    @Autowired
    private ITowerCurrentDataService towerCurrentDataService;

    @Autowired
    private ITowerWorkCycleService towerWorkCycleService;


    @Resource
    private XiwonUtil xiwonUtil;

    /**
     * 获取塔吊数据(携稳) 每5分钟触发任务
     */
    @SchedulerLock(name = "getTowerData", lockAtMostFor = 1000 * 60 * 5, lockAtLeastFor = 1000 * 60 * 3)
    @Scheduled(cron = "0 0/5 * * * ?")
    @GetMapping("tower")
    public void getEnvironmentDustData() {
        log.info("获取塔吊数据(携稳)开始任务");
        List<Project> projects = projectMapper.selectList(new LambdaQueryWrapper<Project>()
                .isNotNull(Project::getXiwonAppId)
                .isNotNull(Project::getXiwonAppSecret)
        );
        for (Project project : projects) {
            // 获取设备列表
            List<Tower> devList = towerMapper.selectList(new LambdaQueryWrapper<Tower>()
                    .eq(Tower::getProjectSn, project.getProjectSn()));
            devList.forEach(dev -> CompletableFuture.runAsync(() -> {
                        doGetTowerData(dev, project);
                        doGetTowerCycleData(dev, project);
                    }).exceptionally(throwable -> {
                        log.error("err", throwable);
                        return null;
                    })
            );
        }
    }

    private void doGetTowerData(Tower dev, Project project) {
        // 设备sn
        String devSn = dev.getDevSn();
        log.info("doGetTowerData设备sn：{}", devSn);
        TowerCurrentData newestData = towerCurrentDataMapper.selectOne(new LambdaQueryWrapper<TowerCurrentData>().eq(TowerCurrentData::getDevSn, devSn).orderByDesc(TowerCurrentData::getXiewenId).last("limit 1"));
        // 请求参数
        Map<String, Object> map = new HashMap<>(4);
        map.put("pageSize", "10");
        map.put("pageNum", "1");
        JSONObject realTimeData = xiwonUtil.postForm("/tower/realTimeData", project.getXiwonAppId(), project.getXiwonAppSecret(), map, JSONObject.class, (() -> {
            map.put("deviceSn", devSn);
            if (newestData != null && newestData.getXiewenId() != null) {
                map.put("dataId", newestData.getXiewenId());
            }
            return map;
        }));
        log.info("携稳接口响应数据（塔吊）：devSn:{}，rs:{}", devSn, JSON.toJSONString(realTimeData));
        Integer code = realTimeData.getInteger("code");
        // code校验是否成功请求
        if (code == HttpStatus.OK.value()) {
            JSONArray dataArray = realTimeData.getJSONArray("data");
            if (CollUtil.isNotEmpty(dataArray)) {
                // 解析请求到的参数，保存到我们的数据库
                for (Object o : dataArray) {
                    TowerDataDto dto = BeanUtil.toBean(o, TowerDataDto.class);
                    TowerCurrentData data = new TowerCurrentData();
                    data.setDevSn(devSn);
                    data.setDevName(dev.getDevName());
                    data.setProjectSn(dev.getProjectSn());
                    data.setReciveTime(DateUtil.parse(dto.getCraneTime()));
                    data.setStartTime(DateUtil.parse(dto.getCraneTime()));
                    data.setLoading(Convert.toStr(dto.getCraneElevatingCapacity()));
                    data.setLoadRatio(Convert.toStr(dto.getCraneWeightPercentage()));
                    data.setTorque(null);
                    data.setTorqueRatio(Convert.toStr(dto.getCraneTorquePercentage()));
                    if (dto.getCraneTiltAngle() != null) {
                        data.setAngle(Convert.toStr(dto.getCraneTiltAngle() / 10));
                    }
                    if (dto.getCraneRange() != null) {
                        data.setRanger(Convert.toStr(dto.getCraneRange() / 10));
                    }
                    if (dto.getCraneHeight() != null) {
                        data.setHeight(Convert.toStr(dto.getCraneHeight() / 10));
                    }
                    if (dto.getCraneWindSpeed() != null) {
                        data.setWindspeed(Convert.toStr(dto.getCraneWindSpeed() / 10));
                    }
                    if (dto.getCraneTiltAngle() != null) {
                        data.setObliguity(Convert.toStr(dto.getCraneTiltAngle() / 10));
                    }
                    data.setRate(null);
                    data.setDriverName(null);
                    data.setDriverIdCard(null);
                    data.setObliguityX(null);
                    data.setObliguityY(null);
                    data.setRealFlag("0");
                    Integer craneAlarmReason = dto.getCraneAlarmReason();
                    if (craneAlarmReason != null) {
                        switch (craneAlarmReason) {
                            /*
                            0 正常 111 112 113 114碰撞报警 12 13 14 15 重量 力矩 倾斜 风速报警
                            211 212 213 214碰撞预警 22 23 24 25 重量 力矩 倾斜 风速预警 201幅度限位预警 202高度限位预警 203回转限位预警
                            101幅度限位报警 102高度限位报警 103回转限位报警 118酒精报警 218酒精预警 119重量违章报警 219重量违章预警
                             */
                            //data.setNoError();
                            //data.setWeightError();
                            //data.setWindSpeedError();
                            //data.setRangeError();
                            //data.setHeightError();
                            //data.setAngleError();
                            //data.setObliguityError();
                            //data.setGpsError();
                            //data.setIdError();
                            case 111:
                                data.setMultiAlarmAll(1);
                                break;
                            case 112:
                                data.setMultiAlarmAll(1);
                                break;
                            case 113:
                                data.setMultiAlarmAll(1);
                                break;
                            case 114:
                                data.setMultiAlarmAll(1);
                                break;
                            case 13:
                                data.setMomentAlarm(1);
                                break;
                            case 14:
                                data.setObliguityAlarm(1);
                                break;
                            case 15:
                                data.setWindSpeedAlarm(1);
                                break;
                            case 211:
                                data.setMultiAlarmAll(1);
                                break;
                            case 212:
                                data.setMultiAlarmAll(1);
                                break;
                            case 213:
                                data.setMultiAlarmAll(1);
                                break;
                            case 214:
                                data.setMultiAlarmAll(1);
                                break;
                            case 23:
                                data.setMomentAlarm(2);
                                break;
                            case 24:
                                data.setObliguityAlarm(2);
                                break;
                            case 25:
                                data.setWindSpeedAlarm(2);
                                break;
                            case 201:
                                data.setMinRangeAlarm(2);
                                data.setMaxRangeAlarm(2);
                                break;
                            case 202:
                                data.setHeightAlarm(2);
                                data.setHeightLowerAlarm(2);
                                break;
                            case 203:
                                data.setPosAngleAlarm(2);
                                data.setNegAngleAlarm(2);
                                break;
                            case 101:
                                data.setMinRangeAlarm(1);
                                data.setMaxRangeAlarm(1);
                                break;
                            case 102:
                                data.setHeightAlarm(1);
                                data.setHeightLowerAlarm(1);
                                break;
                            case 103:
                                data.setPosAngleAlarm(1);
                                data.setNegAngleAlarm(1);
                                break;
                            default:
                        }
                        if (Objects.equals(craneAlarmReason, 0)) {
                            data.setNoAlarm(1);
                        } else {
                            data.setNoAlarm(0);
                        }
                    }
                    data.setXiewenId(dto.getId());
                    towerCurrentDataService.saveTowerCurrentData(data);
                }
            } else {
                log.info("塔吊设备sn：{}，当前无数据！", devSn);
            }
        } else {
            log.error("塔吊设备sn：{}，请求失败！当前code：{}，msg：{}", devSn, code, realTimeData.getString("msg"));
        }
    }

    private void doGetTowerCycleData(Tower dev, Project project) {
        // 设备sn
        String devSn = dev.getDevSn();
        log.info("doGetTowerCycleData设备sn：{}", devSn);
        TowerWorkCycle newestData = towerWorkCycleMapper.selectOne(new LambdaQueryWrapper<TowerWorkCycle>().eq(TowerWorkCycle::getDevSn, devSn).orderByDesc(TowerWorkCycle::getEndTime).last("limit 1"));
        // 请求参数
        Map<String, Object> map = new HashMap<>(4);
        map.put("pageSize", "10");
        map.put("pageNum", "1");
        JSONObject realTimeData = xiwonUtil.postForm("/tower/workCycle", project.getXiwonAppId(), project.getXiwonAppSecret(), map, JSONObject.class, (() -> {
            map.put("deviceSn", devSn);
            if (newestData != null && newestData.getEndTime() != null) {
                map.put("startTime", DateUtil.formatDateTime(DateUtil.offsetSecond(newestData.getEndTime(), 1)));
            }
            map.put("endTime", DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
            return map;
        }));
        log.info("携稳接口响应数据（塔吊循环）：devSn:{}，rs:{}", devSn, JSON.toJSONString(realTimeData));
        Integer code = realTimeData.getInteger("code");
        // code校验是否成功请求
        if (code == HttpStatus.OK.value()) {
            JSONArray dataArray = realTimeData.getJSONArray("data");
            if (CollUtil.isNotEmpty(dataArray)) {
                // 解析请求到的参数，保存到我们的数据库
                for (Object o : dataArray) {
                    TowerCycleDataDto dto = BeanUtil.toBean(o, TowerCycleDataDto.class);
                    TowerWorkCycle data = new TowerWorkCycle();
                    data.setDevSn(dev.getDevSn());
                    data.setDevName(dev.getDevName());
                    data.setProjectSn(dev.getProjectSn());
                    data.setStartTime(DateUtil.parse(dto.getStartTime()));
                    data.setEndTime(DateUtil.parse(dto.getEndTime()));
                    data.setAddTime(DateUtil.parse(dto.getSystemTime()));
                    data.setWorkTime(String.valueOf(DateUtil.between(data.getStartTime(), data.getEndTime(), DateUnit.SECOND)));
                    data.setLoading(Convert.toStr(dto.getCycleMaximumWeight()));
                    data.setWorkMaxForce(Convert.toStr(dto.getCycleMaximumTorque()));
                    Long maximumHeight = dto.getMaximumHeight();
                    if (maximumHeight != null) {
                        data.setMaxHeight(Convert.toStr(maximumHeight / 10));
                    }
                    Long minimumHeight = dto.getMinimumHeight();
                    if (minimumHeight != null) {
                        data.setMinHeight(Convert.toStr(minimumHeight / 10));
                    }
                    Long maximumRange = dto.getMaximumRange();
                    if (maximumRange != null) {
                        data.setMaxRange(Convert.toStr(maximumRange / 10));
                    }
                    Long minimumRange = dto.getMinimumRange();
                    if (minimumRange != null) {
                        data.setMinRange(Convert.toStr(minimumRange / 10));
                    }
                    Long liftingPointAngle = dto.getLiftingPointAngle();
                    if (liftingPointAngle != null) {
                        data.setSlingStartRotation(Convert.toStr(liftingPointAngle / 10));
                    }
                    Long unloadingPointAngle = dto.getUnloadingPointAngle();
                    if (unloadingPointAngle != null) {
                        data.setSlingEndRotation(Convert.toStr(unloadingPointAngle / 10));
                    }
                    Long liftingPointRange = dto.getLiftingPointRange();
                    if (liftingPointRange != null) {
                        data.setSlingStartRange(Convert.toStr(liftingPointRange / 10));
                    }
                    Long unloadingPointRange = dto.getUnloadingPointRange();
                    if (unloadingPointRange != null) {
                        data.setSlingEndRange(Convert.toStr(unloadingPointRange / 10));
                    }

                    Long liftingPointHeight = dto.getLiftingPointHeight();
                    if (liftingPointHeight != null) {
                        data.setSlingStartHeight(Convert.toStr(liftingPointHeight / 10));
                    }
                    Long unloadingPointHeight = dto.getUnloadingPointRange();
                    if (unloadingPointHeight != null) {
                        data.setSlingEndHeight(Convert.toStr(unloadingPointHeight / 10));
                    }
                    towerWorkCycleService.addTowerWorkCycle(data);
                }
            } else {
                log.info("塔吊循环设备sn：{}，当前无数据！", devSn);
            }
        } else {
            log.error("塔吊循环设备sn：{}，请求失败！当前code：{}，msg：{}", devSn, code, realTimeData.getString("msg"));
        }
    }


}