package com.casic.service.impl;

import com.alibaba.druid.util.StringUtils;
import com.casic.dao.smartwell.SmartwellDataMapper;
import com.casic.dao.spantilt.TiltDataMapper;
import com.casic.util.FormatUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
@Slf4j
public class HealthIndexBuilder {

    private final SmartwellDataMapper smartwellDataMapper;
    private final TiltDataMapper tiltDataMapper;


    public List<Map<String, Object>> healthIndicatorProvider(String beginTime, String endTime) {
        List<Map<String, Object>> healthIndictorList = new ArrayList<>();
        healthIndictorList.add(smartwellHealthIndicator(beginTime, endTime));
        healthIndictorList.add(tiltHealthIndicator(beginTime, endTime));
        return healthIndictorList;
    }


    public List<Map<String, Object>> deptIndicatorProvider(String beginTime, String endTime) {
        List<Map<String, Integer>> deviceDeptNumberList = smartwellDataMapper.countDeviceNumberByDept();
        List<Map<String, Integer>> alarmDeptList = smartwellDataMapper.countAlarmDeviceByDept(beginTime, endTime);
        List<Map<String, Object>> deptIndicatorList = MergeDeviceCalculateIndicator(deviceDeptNumberList, alarmDeptList);
        return deptIndicatorList;
    }

    public List<Map<String, Object>> healthRoadIndicatorProvider(String isSort, String limitNum, String beginTime, String endTime) {
        return this.smartwellHealthRoadIndicator(isSort, limitNum, beginTime, endTime);
    }


    private Map<String, Object> smartwellHealthIndicator(String beginTime, String endTime) {
        Map<String, Object> smartwellHealth = new HashMap<>();
        Integer deviceNumber = smartwellDataMapper.countDeviceNumber();
        Integer alarmDevice = smartwellDataMapper.countAlarmDevice(beginTime, endTime);
        smartwellHealth.put("typeName", "管网健康指数");
        smartwellHealth.put("count", FormatUtil.DF.format((deviceNumber - alarmDevice) / deviceNumber));
        return smartwellHealth;
    }

    private Map<String, Object> tiltHealthIndicator(String beginTime, String endTime) {
        Map<String, Object> smartwellHealth = new HashMap<>();
        Integer deviceNumber = tiltDataMapper.countColudDevice();
        Integer alarmDevice = tiltDataMapper.countColudAlarm(beginTime, endTime);
        smartwellHealth.put("typeName", "场站健康指数");
        smartwellHealth.put("count", FormatUtil.DF.format(Double.valueOf(deviceNumber - alarmDevice) / deviceNumber));
        return smartwellHealth;
    }

    private List<Map<String, Object>> smartwellHealthRoadIndicator(String isSort, String limitNum, String beginTime, String endTime) {
        List<Map<String, Object>> smartwellHealthList = new ArrayList();
        List<Map<String, Object>> roadNumberList = this.smartwellDataMapper.countRoadNumber();
        List<Map<String, Object>> alarmRoadList = this.smartwellDataMapper.countAlarmRoad(beginTime, endTime);
        Integer count = 0;
        for (Map<String, Object> alarmMap : roadNumberList) {
            count += Integer.valueOf(String.valueOf(alarmMap.get("count")));
        }
        log.info("设备总数量" + count);
        for (Map<String, Object> alarmMap : alarmRoadList) {
            count += Integer.valueOf(String.valueOf(alarmMap.get("count")));
        }
        log.info("报警总数量" + count);
        Map<String, String> alarmRoadMap = alarmRoadList.stream()
                .collect(Collectors.toMap(e -> String.valueOf(e.get("road")), e -> String.valueOf(e.get("count"))));

        roadNumberList.stream()
                .filter(roadMap ->!StringUtils.isEmpty(String.valueOf(roadMap.get("road"))))
                .forEach(roadMap -> {
                                Map<String, Object> wellHealthMap = new HashMap();
                                wellHealthMap.put("typeName", roadMap.get("road"));
                                Integer totalRoad = Integer.valueOf(String.valueOf(roadMap.get("count")));
                                Integer alarmRoad = alarmRoadMap.containsKey(roadMap.get("road").toString()) ? Integer.valueOf(String.valueOf(alarmRoadMap.get(roadMap.get("road").toString()))) : 0;
                                wellHealthMap.put("count", FormatUtil.DF2.format(Double.valueOf((double) (totalRoad - alarmRoad)) * 100.0D / (double) totalRoad));
                                smartwellHealthList.add(wellHealthMap);
                        }
                );

        if (!StringUtils.isEmpty(isSort)) {
//            List<Map<String, Object>> sortlist = smartwellHealthList.stream().sorted((e1, e2) ->
//                    Double.valueOf(String.valueOf(e1.get("count"))).compareTo(Double.valueOf(String.valueOf(e2.get("count"))))).collect(Collectors.toList());
//            List<Map<String, Object>> limitSortlist = sortlist.subList(0, StringUtils.isEmpty(limitNum) ? sortlist.size() : Integer.valueOf(limitNum));
            roadNumberList.stream()
                    .filter(roadMap ->!StringUtils.isEmpty(String.valueOf(roadMap.get("road"))))
                    .forEach(
                    roadMap -> roadMap.put("count", alarmRoadMap.containsKey(roadMap.get("road")) ? alarmRoadMap.get(roadMap.get("road")) : 0)
            );
            List<Map<String, Object>> sortlist = roadNumberList
                    .stream()
                    .filter(roadMap ->!StringUtils.isEmpty(String.valueOf(roadMap.get("road"))))
                    .sorted((
                    e1, e2) -> Double.valueOf(String.valueOf(e2.get("count"))).compareTo(Double.valueOf(String.valueOf(e1.get("count"))))).collect(Collectors.toList());
            List<Map<String, Object>> limitSortlist = sortlist.subList(0, StringUtils.isEmpty(limitNum) ? sortlist.size() : Integer.valueOf(limitNum));
            return limitSortlist;
        } else {
            return smartwellHealthList;
        }
    }

    private List<Map<String, Object>> MergeDeviceCalculateIndicator(List<Map<String, Integer>> deviceDeptNumberList, List<Map<String, Integer>> alarmDeptList) {
        Map<String, String> alarmDeptMap = alarmDeptList.stream().collect(
                Collectors.toMap(e -> String.valueOf(e.get("deptid")), e -> String.valueOf(e.get("counts")))
        );
        List<Map<String, String>> deptNameList = smartwellDataMapper.getDeptNameList();
        Map<String, Object> deptNameMap = deptNameList.stream().collect(
                Collectors.toMap(e -> String.valueOf(e.get("id")), e -> String.valueOf(e.get("name")))
        );
        List<Map<String, Object>> deptIndicatorList = new ArrayList<>();
        deviceDeptNumberList.forEach(
                deptNameNumberMap -> {
                    Map<String, Object> deptIndicatorMap = new HashMap<>();
                    int deviceNumber = Integer.valueOf(String.valueOf(deptNameNumberMap.get("counts")));
                    String alarmDeviceNumber = alarmDeptMap.get(deptNameNumberMap.get("deptid"));
                    int alarmDevice = StringUtils.isEmpty(alarmDeviceNumber) ? 0 : Integer.valueOf(String.valueOf(alarmDeviceNumber));
                    deptIndicatorMap.put("typeName", deptNameMap.get(String.valueOf(deptNameNumberMap.get("deptid"))).toString());
                    deptIndicatorMap.put("count", FormatUtil.DF.format((deviceNumber - alarmDevice) / deviceNumber));
                    deptIndicatorList.add(deptIndicatorMap);
                }
        );
        return deptIndicatorList;
    }
}