package com.zc.business.controller;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.tree.Tree;
import com.alibaba.excel.util.DateUtils;
import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelMultipleSheetsUtil;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.zc.business.constant.RedisKeyConstants;
import com.zc.business.controller.queryParams.OnlineQueryParams;
import com.zc.business.domain.*;
import com.zc.business.enums.UniversalEnum;
import com.zc.business.service.IDcRoadSectionService;
import com.zc.business.service.IOnlineLogService;
import com.zc.business.service.IOnlineSumService;
import com.zc.business.service.impl.DcDeviceServiceImpl;
import com.zc.business.utils.MathUtil;
import eu.bitwalker.useragentutils.DeviceType;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

@Api(tags = "设备在线监测")
@RestController
@RequestMapping("/system/status")
public class DcDeviceOnlineController extends BaseController {
    @Autowired
    private DcDeviceServiceImpl dcDeviceService;
    @Resource
    private RedisCache redisCache;
    @Resource
    private IDcRoadSectionService dcRoadSectionService;
    @Resource
    private IOnlineSumService onlineSumService;
    @Resource
    private IOnlineLogService onlineLogService;

    private static final String ORDERRULE = "orderRule";//排序策略key

    @ApiOperation("设备状态导出")
    @Log(title = "【设备状态导出】", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, OnlineQueryParams params) {
        if (ObjectUtils.isEmpty(params.getType())) {
            return;
        }
        if (StringUtil.isEmpty(params.getOrderByField()) || "time".equals(params.getOrderByField())) {
            params.setOrderByField("online_rate");
        }

        String stakeMark = params.getStakeMark();
        if (stakeMark!=null) {
            params.setStakeMark(stakeMark.replace(UniversalEnum.BLANK_SPACE.getValue(), UniversalEnum.PLUS_SIGN.getValue()));
        }

        List<OnlineSum> sums = onlineSumService.queryByDeviceTypesOfToday(params);
        if (params.getExportType() != null && params.getExportType().equals(UniversalEnum.ONE.getValue())) {
            sums = sums.stream()
                    .filter(OnlineSum::isLossRatePositive)
                    .sorted(Comparator.comparing(OnlineSum::getLossRate).reversed())
                    .collect(Collectors.toList());
        }

        Map<String, List<OnlineSum>> sumsMap = sums.stream().collect(Collectors.groupingBy(OnlineSum::getDeviceType));
        LinkedHashMap<String, Object> map = new LinkedHashMap<>();
        for (String deviceType : params.getType()) {
            List<OnlineSum> list = sumsMap.getOrDefault(deviceType, new ArrayList<>());
            String typeName = DeviceType.getDescriptionByValue(deviceType);
            if (StringUtil.isNotEmpty(typeName)) {
                map.put(DeviceType.getDescriptionByValue(deviceType), list);
            }
        }
        ExcelMultipleSheetsUtil multipleSheetsUtil = new ExcelMultipleSheetsUtil();
        multipleSheetsUtil.excelMultipleSheets(map, UniversalEnum.DEVICE_STATUS_LIST.getValue() + DateUtil.format(new Date(), "yyyyMMddHHmmss"),
                "xlsx", response);
    }

    @ApiOperation("设备状态列表按时间和类型")
    @GetMapping("/tablist")
    public TableDataInfo getTabList(OnlineQueryParams params) {

        if (ObjectUtils.isEmpty(params.getType())) {
            return getDataTable(new ArrayList<>());
        }
        if (StringUtil.isEmpty(params.getOrderByField()) || "time".equals(params.getOrderByField())) {
            params.setOrderByField("online_rate");
        }
        startPage();
        String stakeMark = params.getStakeMark();
        if (stakeMark != null) {
            params.setStakeMark(stakeMark.replace(UniversalEnum.BLANK_SPACE.getValue(), UniversalEnum.PLUS_SIGN.getValue()));
        }
        List<OnlineSum> sums = onlineSumService.queryByDeviceTypesOfToday(params);
        /*Map<String,OnlineSum> onlineSumMap = redisCache.getCacheMap(RedisKeyConstants.DEVICE_ONLINE);
        String date = LocalDate.now().toString();*/
        /*for (OnlineSum sum : sums) {
            String deviceId = sum.getDeviceId().toString();
            String hKey = date+":"+deviceId;
            OnlineSum online = onlineSumMap.get(hKey);
            if(ObjectUtils.isEmpty(online)) {
                continue;
            }
            sum.setLastOnlineTime(onlineSumMap.get(hKey).getLastOnlineTime());
            sum.setDeviceStatus(onlineSumMap.get(hKey).getDeviceStatus());
        }*/
        return getDataTable(sums);
    }

    //按时间划分设备柱状图
    @ApiOperation("设备状态柱状图按时间和类型")
    @GetMapping("/list")
    public AjaxResult getStatusList(
            @RequestParam("startTime") String startTime,
            @RequestParam("time") String endTime,
            @RequestParam("type") String[] types,
            @RequestParam(value = "direction", required = false) String direction) {
        Map<String, Map<String, String>> maps = new HashMap<>();
        LocalDateTime start = LocalDateTime.parse(startTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        LocalDateTime end = LocalDateTime.parse(endTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        List<OnlineSum> onlineSums = onlineSumService.queryByDeviceTypeAndDate(types, start.toLocalDate(), end.toLocalDate(), direction);
        Map<String, List<OnlineSum>> stringListMap = onlineSums.stream().collect(Collectors.groupingBy(OnlineSum::getDeviceType));
        for (String type : types) {
            Map<String, String> map = new HashMap<>();
            List<OnlineSum> listOfType = stringListMap.getOrDefault(type, new ArrayList<>());
            Map<LocalDate, List<OnlineSum>> localDateListMap = listOfType.stream().collect(Collectors.groupingBy(OnlineSum::getStatisticalDate));
            for (LocalDate date = start.toLocalDate(); date.isBefore(end.toLocalDate().plusDays(1)); date = date.plusDays(1)) {
                List<OnlineSum> dayList = localDateListMap.getOrDefault(date, new ArrayList<>());
                map.put(date.toString(), MathUtil.doubleTwoDecimalStr(dayList.stream().mapToDouble(OnlineSum::getOnlineRate).average().orElse(0.0)) + "%");
            }
            maps.put(type, new TreeMap<>(map));
        }
        return AjaxResult.success(maps);
    }

    /**
     * 查询设备在线率
     *
     * @param deviceId
     * @return
     */
    @ApiOperation("根据设备Id查询折线图数据")
    @GetMapping("/deviceStatusList/{deviceId}")
    public AjaxResult getDeviceStatusList(@PathVariable Long deviceId) {
        LocalDate startDate = LocalDate.now().minusDays(30);
        LocalDate endDate = LocalDate.now();
        List<OnlineSum> onlineSums = onlineSumService.queryByDateRangeOfDevice(deviceId, startDate, endDate);
        if (onlineSums.isEmpty()) {
            return AjaxResult.success(UniversalEnum.NO_DATA_AVAILABLE.getValue());
        }
        Map<String, Object> map = new HashMap<>();
        for (OnlineSum onlineSum : onlineSums) {
            map.put(onlineSum.getStatisticalDate().toString(), onlineSum.getOnlineRate());
        }
        return AjaxResult.success(new TreeMap<>(map));
    }

    /**
     * 缓存类型卡片排序规则
     *
     * @param rule 排序规则
     * @return AjaxResult
     */
    @ApiOperation("缓存类型卡片排序规则")
    @GetMapping("/rule")
    public AjaxResult setRule(String rule) {
        redisCache.setCacheObject(ORDERRULE, rule);
        return AjaxResult.success();
    }

    /**
     * 设备分类当日在线率
     */
    @ApiOperation("设备分类当日在线率")
    @GetMapping("/type")
    public AjaxResult getTypeList() {
        String LOST_RATE = "lostRate";//丢包率
        String SUCESS_RATE = "sucessRate";//在线率
        String FAIL_RATE = "failRate";//离线率
        String SUM_USE_STATE = "sumUseState";//在用数
        String SUM = "sum";//总数
        String RULE = "rule";
        String All_TYPE = "全部设备";
        String SORT_RULE = "排序规则";
        Map<String, Object> returnMap = new HashMap<>();
        List<OnlineSum> onlineSums = onlineSumService.queryByDateOfDeviceType(LocalDate.now());
        List<DcDevice> dcDeviceList = dcDeviceService.list();
        List<DcDevice> useDeviceList = dcDeviceList.stream().filter(device -> device.getUseState() != null && device.getUseState() == 1).collect(Collectors.toList());
        //分类总数
        Map<String, Long> totalCounts = dcDeviceList.stream()
                .collect(Collectors.groupingBy(DcDevice::getRealType, Collectors.counting()));
        //分类在用数
        Map<String, Long> useCounts = useDeviceList.stream()
                .collect(Collectors.groupingBy(DcDevice::getRealType, Collectors.counting()));
        Map<String, List<OnlineSum>> typeSumGroup = onlineSums.stream().collect(Collectors.groupingBy(OnlineSum::getDeviceType));
        DeviceType.toMap().forEach((k, v) -> {
            Map<String, Object> itemMap = new HashMap<>();
            itemMap.put(SUM, totalCounts.getOrDefault(k, 0L).toString());//总数
            itemMap.put(SUM_USE_STATE, useCounts.getOrDefault(k, 0L).toString());//在用数
            List<OnlineSum> onlineSumsOfType = typeSumGroup.getOrDefault(k, new ArrayList<>());
            itemMap.put(LOST_RATE, MathUtil.doubleTwoDecimalStr(onlineSumsOfType.stream().mapToDouble(OnlineSum::getLossRate).average().orElse(0.0)) + "%");
            itemMap.put(SUCESS_RATE, MathUtil.doubleTwoDecimalStr(onlineSumsOfType.stream().mapToDouble(OnlineSum::getOnlineRate).average().orElse(0.0)) + "%");
            itemMap.put(FAIL_RATE, MathUtil.doubleTwoDecimalStr(onlineSumsOfType.stream().mapToDouble(OnlineSum::getOfflineRate).average().orElse(0.0)) + "%");
            returnMap.put(v, itemMap);
        });
        Map<String, Object> allMap = new HashMap<>();
        allMap.put(SUM, dcDeviceList.size() + "");//总数
        allMap.put(SUM_USE_STATE, useDeviceList.size() + "");//在用数
        allMap.put(LOST_RATE, MathUtil.doubleTwoDecimalStr(onlineSums.stream().mapToDouble(OnlineSum::getLossRate).average().orElse(0.0)) + "%");
        allMap.put(SUCESS_RATE, MathUtil.doubleTwoDecimalStr(onlineSums.stream().mapToDouble(OnlineSum::getOnlineRate).average().orElse(0.0)) + "%");
        allMap.put(FAIL_RATE, MathUtil.doubleTwoDecimalStr(onlineSums.stream().mapToDouble(OnlineSum::getOfflineRate).average().orElse(0.0)) + "%");
        returnMap.put(All_TYPE, allMap);
        Map<String, Object> sortMap = new TreeMap<>();
        String orderRule = redisCache.getCacheObject(ORDERRULE);
        if (StringUtil.isNotEmpty(orderRule)) {
            sortMap.put(RULE, orderRule);
        } else {
            sortMap.put(RULE, DeviceType.defaultSortRule());
        }
        returnMap.put(SORT_RULE, sortMap);
        return AjaxResult.success(returnMap);
    }

    //按路段统计设备在线率
    @ApiOperation("设备状态列表按路段")
    @GetMapping("/section")
    public AjaxResult getSectionList() {
        String LOST_RATE = "lostRate";//丢包率
        String SUCESS_RATE = "sucessRate";//在线率
        String FAIL_RATE = "failRate";//离线率
        String SUM_USE_STATE = "sumUseState";//在用数
        String SUM = "sum";//总数
        Map<String, Object> returnMap = new HashMap<>();
        List<Map<String, Object>> deviceOfRoad = dcDeviceService.selectDeviceOfRoad();
        List<DcRoadSection> dcRoadSections = dcRoadSectionService.selectDcRoadSectionList(new DcRoadSection());
        List<OnlineSum> onlineSums = onlineSumService.queryByDateOfRoad(LocalDate.now());
        Map<String, Long> totalRoadCounts = deviceOfRoad.stream()
                .collect(Collectors.groupingBy(m -> m.get("roadId").toString(), Collectors.counting()));
        Map<String, Long> useRoadCounts = deviceOfRoad.stream().filter(dr -> dr.get("useStata") != null && dr.get("useStata").toString().equals("1"))
                .collect(Collectors.groupingBy(m -> m.get("roadId").toString(), Collectors.counting()));
        Map<Long, List<OnlineSum>> onLineSumMap = onlineSums.stream().filter(onlineSum -> onlineSum.getRoadId() != null).collect(Collectors.groupingBy(OnlineSum::getRoadId));
        for (DcRoadSection dcRoadSection : dcRoadSections) {
            Map<String, Object> itemMap = new HashMap<>();
            itemMap.put(SUM, totalRoadCounts.getOrDefault(dcRoadSection.getId().toString(), 0L).toString());//总数
            itemMap.put(SUM_USE_STATE, useRoadCounts.getOrDefault(dcRoadSection.getId().toString(), 0L).toString());//在用数
            List<OnlineSum> onlineSumsByRoad = onLineSumMap.getOrDefault(dcRoadSection.getId(), new ArrayList<>());
            itemMap.put(LOST_RATE, MathUtil.doubleTwoDecimalStr(onlineSumsByRoad.stream().mapToDouble(OnlineSum::getLossRate).average().orElse(0.0)) + "%");
            itemMap.put(SUCESS_RATE, MathUtil.doubleTwoDecimalStr(onlineSumsByRoad.stream().mapToDouble(OnlineSum::getOnlineRate).average().orElse(0.0)) + "%");
            itemMap.put(FAIL_RATE, MathUtil.doubleTwoDecimalStr(onlineSumsByRoad.stream().mapToDouble(OnlineSum::getOfflineRate).average().orElse(0.0)) + "%");
            returnMap.put(dcRoadSection.getSectionName(), itemMap);
        }
        return AjaxResult.success(returnMap);
    }

    @ApiOperation("查询设备网络日志")
    @GetMapping("/networkLogTable")
    public TableDataInfo networkLogTable(
            @RequestParam("deviceId") Long deviceId,
            @RequestParam("queryDate") String queryDate) {
        LocalDateTime start = LocalDateTime.parse(queryDate + " 00:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        LocalDateTime end = LocalDateTime.parse(queryDate + " 23:59:59", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        //startPage();
        List<OnlineLog> onlineLogs = onlineLogService.queryByDateAndDevice(start, end, deviceId);
        return getDataTable(onlineLogs);
    }

    @ApiOperation("查询设备网络日志")
    @GetMapping("/networkLogEcharts")
    public AjaxResult networkLogEcharts(
            @RequestParam("deviceId") Long deviceId,
            @RequestParam("queryDate") String queryDate) {
        String LOST_RATE = "lostRate";//丢包率
        String RTT_AVG = "rttAvg";//平均往返时延
        String MONITOR_TIME = "time";//监控时间
        LocalDateTime start = LocalDateTime.parse(queryDate + " 00:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        LocalDateTime end = LocalDateTime.parse(queryDate + " 23:59:59", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        List<OnlineLog> onlineLogs = onlineLogService.queryByDateAndDevice(start, end, deviceId);
        Map<String, Object> returnMap = new HashMap<>();
        List<String> xAxis = new ArrayList<>();
        List<Double> lossRate = new ArrayList<>();
        List<Double> rttAvg = new ArrayList<>();
        onlineLogs.stream().sorted(Comparator.comparing(OnlineLog::getMonitorTime)).forEach(onlineLog -> {
            xAxis.add(onlineLog.getMonitorTime().format(DateTimeFormatter.ofPattern("HH:mm")));
            lossRate.add(onlineLog.getLossRate());
            rttAvg.add(onlineLog.getRttAvg());
        });
        returnMap.put(LOST_RATE, lossRate);
        returnMap.put(RTT_AVG, rttAvg);
        returnMap.put(MONITOR_TIME, xAxis);
        return AjaxResult.success(new TreeMap<>(returnMap));
    }

    enum DeviceType {
        GUN_CAMERA("1-1", "高清网络枪型固定摄像机"),
        SPHERICAL_CAMERA("1-2", "高清网络球形摄像机"),
        SPHERICAL_CAMERA_BRIDGE("1-3", "桥下高清网络球形摄像机"),
        PANORAMIC_CAMERA_360("1-4", "360°全景摄像机"),
        PANORAMIC_CAMERA_180("1-5", "180°全景摄像机"),
        GANTRY_VMS("2-1", "门架式可变信息标志"),
        STATION_FRONT_VMS("2-2", "站前可变信息标志"),
        AWNING_VMS("2-3", "雨棚可变信息标志"),
        //站前悬臂式可变信息标志2-4
        MET_DET("3", "气象检测器"),
        //出口诱导灯4
        VOICE_BROADCAST("5", "路段语音广播系统"),
        GUARDRAIL_COLLISION("6", "护栏碰撞预警系统"),
        MMW_RADAR("7", "毫米波雷达"),
        CA_EARLY("8", "合流区预警系统"),
        //智慧锥桶9
        LASER_FATIGUE_AWAKENING("10", "激光疲劳唤醒"),
        TRAFFIC_SURVEY_STATION("11", "一类交通量调查站"),
        DRIVING_GUIDANCE("12", "智能行车诱导系统"),
        DEVICE_BOX("13", "智能设备箱"),
        //光纤在线监测14
        SOLAR_PANEL("15", "太阳能板"),
        REMOTE_COMPUTER("16", "远端机");
        private final String value;
        private final String description;

        public String getValue() {
            return value;
        }

        public String getDescription() {
            return description;
        }

        DeviceType(String value, String description) {
            this.value = value;
            this.description = description;
        }

        /**
         * map转换{value,description}
         *
         * @return 转换后的map
         */
        static Map<String, String> toMap() {
            Map<String, String> map = new HashMap<>();
            for (DeviceType deviceType : DeviceType.values()) {
                map.put(deviceType.getValue(), deviceType.getDescription());
            }
            return map;
        }

        /**
         * 默认排序规则
         *
         * @return 排序规则
         */
        static String defaultSortRule() {
            StringBuilder stringBuilder = new StringBuilder();
            String ALL_TYPE = "全部设备";
            stringBuilder.append(ALL_TYPE);
            for (DeviceType deviceType : DeviceType.values()) {
                stringBuilder.append(",").append(deviceType.getDescription());
            }
            return stringBuilder.toString();
        }

        static String getDescriptionByValue(String value) {
            for (DeviceType type : DeviceType.values()) {
                if (type.value.equals(value)) {
                    return type.description;
                }
            }
            return "";
        }
    }

}