package com.pqs9200.serviceimpl.area;

import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

import javax.annotation.Resource;

import cn.hutool.core.collection.CollectionUtil;
import com.pqs9200.pojo.map.BaseMap;
import com.pqs9200.pojo.map.BaseMapDetail;
import com.pqs9200.pojo.map.BaseMapDetailRVO;
import com.pqs9200.pojo.map.BaseMapProperties;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import com.njcn.mapper.configuration.DicDataMapper;
import com.njcn.mapper.configuration.DicDataTypeMapper;
import com.njcn.mapper.configuration.EventDataMapper;
import com.njcn.mapper.configuration.GDInforMapper;
import com.njcn.mapper.configuration.LineMapper;
import com.njcn.mapper.data.EventAssMapper;
import com.njcn.mapper.data.EventDetailMapper;
import com.njcn.mapper.data.LineMapsMapper;
import com.njcn.pojo.commons.AreaGeneralData;
import com.njcn.pojo.commons.Level;
import com.njcn.pojo.commons.SimpleValue;
import com.njcn.pojo.commons.VoltageData;
import com.njcn.pojo.commons.area.Area;
import com.njcn.pojo.commons.area.AreaGeneral;
import com.njcn.pojo.commons.area.Iec28;
import com.njcn.pojo.commons.area.Interval;
import com.njcn.pojo.commons.area.MdSort;
import com.njcn.pojo.commons.area.Voltage;
import com.njcn.pojo.commons.device.DeviceValue;
import com.njcn.pojo.commons.device.EventCause;
import com.njcn.pojo.commons.device.EventChance;
import com.njcn.pojo.commons.device.EventDataList;
import com.njcn.pojo.commons.device.EventDensity;
import com.njcn.pojo.commons.device.EventTypeList;
import com.njcn.pojo.commons.device.LineInfo;
import com.njcn.pojo.configuration.DicData;
import com.njcn.pojo.configuration.DicType;
import com.njcn.pojo.data.LineMaps;
import com.njcn.pojo.user.Depts;
import com.njcn.utils.UserUtil;
import com.njcn.utils.redis.RedisCacheUtil;
import com.pqs9200.pojo.commons.device.DevMapInfo;
import com.pqs9200.service.area.IAreaService;

/**
 * @author hongawen
 * @Date: 2018/11/2 11:32
 */
@Service
public class AreaServiceImpl implements IAreaService {

    private static final Logger logger = LoggerFactory.getLogger(AreaServiceImpl.class);

    @Autowired
    private EventDetailMapper eventDetailMapper;

    @Autowired
    private UserUtil userUtil;


    @Autowired
    private GDInforMapper gdMapper;

    @Autowired
    private RedisCacheUtil redisCacheUtil;

    @Autowired
    private EventAssMapper eventAssMapper;

    @Autowired
    private LineMapper lineMapper;

    @Autowired
    private LineMapsMapper lineMapsMapper;

    @Autowired
    private EventDataMapper eventdataMapper;

    @Resource
    private DicDataMapper dicDataMapper;

    @Resource
    private DicDataTypeMapper dicDataTypeMapper;


    /**
     * 用户登录后首页展示的区域暂降事件的展示
     * <p>
     * 根据登录用户的身份去查询数据
     */
    @Override
    public AreaGeneral getGeneralDate(Date startTime, Date endTime) {
        AreaGeneral areaGen;
        List<Voltage> vols;
        List<Interval> inters;
        //按区域查询数据
        areaGen = getAreas(startTime, endTime);
        if (null == areaGen) {
            return null;
        }
        List<Integer> devIndexs = new ArrayList<>(areaGen.getDevIndexs());
        //按电压等级查询数据
        vols = getVols(devIndexs, startTime, endTime);
        areaGen.setVol(vols);
        // 按时间间隔查询数据
        inters = getIntervals(areaGen.getLineIndexs(), startTime, endTime);
        areaGen.setInterval(inters);
        return areaGen;
    }

    /**
     * 获取区域概况的所有数据
     */
    @Override
    public AreaGeneral getGeneralDate(String area, Date startTime, Date endTime) {
        AreaGeneral areaGen;
        List<Voltage> vols;
        List<Interval> inters;
        Depts deptsArea;
        if ("overview".equalsIgnoreCase(area)) {
            deptsArea = userUtil.getCurrentDept();
        } else {
            deptsArea = userUtil.getDeptsByIndex(area);
        }
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);
        List<Integer> devIndexs = new ArrayList<>(areaGen.getDevIndexs());
        //按电压等级查询数据
        vols = getVols(devIndexs, startTime, endTime);
        areaGen.setVol(vols);
        // 按时间间隔查询数据
        List<Integer> lineIndex = new ArrayList<>(areaGen.getLineIndexs());
        inters = getIntervals(lineIndex, startTime, endTime);
        areaGen.setInterval(inters);
        return areaGen;
    }


    /**
     * @param startTime 起始时间
     * @param endTime   截止时间
     */
    public AreaGeneral getAreas(Date startTime, Date endTime) {
        AreaGeneral areaGen = new AreaGeneral();
        // 按区域获取暂降次数
        List<Area> areas = new ArrayList<>();
        //初始化所有地市级的事件总数
        Integer totalTimes = 0;
        List<AreaGeneralData> areaGeneral = userUtil.getAreaGeneralRun();
        if (CollectionUtils.isEmpty(areaGeneral)) {
            return null;
        }
        DecimalFormat df = new DecimalFormat("0.00");
        List<Integer> devIndexs = new ArrayList<>();
        List<Integer> lineIndexs = new ArrayList<>();
        List<Integer> monitorList = new ArrayList<>();
        areaGen.setCityName(userUtil.getCurrentDept().getAreaName());
        for (AreaGeneralData areaGeneralData : areaGeneral) {
            //获取所有监测点
            monitorList.addAll(areaGeneralData.getLineIndexs());
            Area areaTemp = new Area();
            areaTemp.setCity(areaGeneralData.getName());
            areaTemp.setAmounts(areaGeneralData.getMonitors());
            List<Integer> lineIndexsTemp = areaGeneralData.getLineIndexs();
            Integer counts;
            if (CollectionUtils.isEmpty(lineIndexsTemp)) {
                counts = 0;
                areaTemp.setDicIndex("0.0");
            } else {
                counts = getEventCoutsByLineIndex(lineIndexsTemp, startTime, endTime);
                areaTemp.setDicIndex(df.format(Float.valueOf(counts) / Float.valueOf(lineIndexsTemp.size())));
            }
            if (null == counts) {
                counts = 0;
            }
            //暂降事件次数
            areaTemp.setTimes(counts);
            totalTimes = totalTimes + counts;
            areas.add(areaTemp);
            lineIndexs.addAll(lineIndexsTemp);
            devIndexs.addAll(areaGeneralData.getDeviceIndexs());
        }
        //总监测点的暂降数量之和
        Integer totalByMonitor = getSuspendByMonitor(startTime,endTime,monitorList);
        if (totalTimes.equals(totalByMonitor)){
            areaGen.setTotalTimes(totalTimes);
            areaGen.setStatus(0);
        } else {
            areaGen.setTotalTimes(totalByMonitor);
            areaGen.setStatus(1);
        }
        areaGen.setDevIndexs(devIndexs);
        areaGen.setLineIndexs(lineIndexs);
        areas = sortArea(areas);
        areaGen.setArea(areas);
        areaGen.setPro(userUtil.getPro(userUtil.getCurrentDept().getDeptsIndex()));
        areaGen.setCityName(userUtil.getCurrentDept().getArea());
        return areaGen;
    }


    /**
     * 区域根据暂降次数进行排序
     */
    private List<Area> sortArea(List<Area> areas) {
        Collections.sort(areas, new Comparator<Area>() {
            @Override
            public int compare(Area p1, Area p2) {
                if (p2.getTimes() > p1.getTimes()) {
                    return 1;
                }
                if (p2.getTimes().equals(p1.getTimes())) {
                    return 0;
                }
                return -1;
            }
        });
        return areas;
    }

    /**
     * 区域--》区域概况--》区域统计
     *
     * @param startTime 起始时间
     * @param endTime   截止时间
     * @param deptsArea 前台传来的区域对应的部门
     */
    private AreaGeneral getAreas(Date startTime, Date endTime, Depts deptsArea) {
        AreaGeneral areaGen = new AreaGeneral();
        List<Area> areas = new ArrayList<>();
        Integer totalTimes = 0;
        List<Integer> lineIndexs = new ArrayList<>();
        List<Integer> devIndexs = new ArrayList<>();
        DecimalFormat df = new DecimalFormat("0.00");
        List<AreaGeneralData> areaGeneral = userUtil.getAreaDataByInfoRun(deptsArea.getDeptsIndex());
        List<Integer> monitorList = new ArrayList<>();
        for (AreaGeneralData areaGeneralData : areaGeneral) {
            //获取所有监测点
            monitorList.addAll(areaGeneralData.getLineIndexs());
            Area areaTemp = new Area();
            areaTemp.setCity(areaGeneralData.getName());
            areaTemp.setAmounts(areaGeneralData.getMonitors());
            List<Integer> lineIndexsTemp = areaGeneralData.getLineIndexs();
            Integer counts;
            if (CollectionUtils.isEmpty(lineIndexsTemp)) {
                counts = 0;
                areaTemp.setDicIndex("0.0");
            } else {
                counts = getEventCoutsByLineIndex(lineIndexsTemp, startTime, endTime);
                areaTemp.setDicIndex(df.format(Float.valueOf(counts) / Float.valueOf(lineIndexsTemp.size())));
            }
            if (null == counts) {
                counts = 0;
            }
            if (deptsArea.getDeptsIndex().equalsIgnoreCase(areaGeneralData.getDeptIndex())) {
                areaGen.setTotalTimes(counts);
            }
            //暂降事件次数
            areaTemp.setTimes(counts);
            //各区域暂降数量之和
            totalTimes = totalTimes + counts;
            areas.add(areaTemp);
            lineIndexs.addAll(lineIndexsTemp);
            devIndexs.addAll(areaGeneralData.getDeviceIndexs());
        }
        areas = sortArea(areas);
        areaGen.setArea(areas);
        //当前用户部门与前端传递的部门一致，表示查询省级数据
        areaGen.setCityName(deptsArea.getAreaName());
        //总监测点的暂降数量之和
        Integer totalByMonitor = getSuspendByMonitor(startTime,endTime,monitorList);
        if (totalTimes.equals(totalByMonitor)){
            areaGen.setTotalTimes(totalTimes);
            areaGen.setStatus(0);
        } else {
            areaGen.setTotalTimes(totalByMonitor);
            areaGen.setStatus(1);
        }
        areaGen.setLineIndexs(lineIndexs);
        areaGen.setDevIndexs(devIndexs);
        //判断是否可点击进入下层
        areaGen.setPro(userUtil.getPro(deptsArea.getDeptsIndex()));
        //判断是否可以点击返回上一级   1 最上级不需要显示 2 当前身份为最下级时，不要显示
        areaGen.setRoot(userUtil.getRoot(deptsArea.getDeptsIndex()));
        areaGen.setCityName(deptsArea.getArea());
        return areaGen;
    }


    /**
     * 区域--》区域概况--》按电压等级统计
     *
     * @param devIndexs 终端索引
     * @param startTime 起始时间
     * @param endTime   截止时间
     */
    List<Voltage> getVols(List<Integer> devIndexs, Date startTime, Date endTime) {
        List<Voltage> vols = new ArrayList<>();
        if (CollectionUtils.isEmpty(devIndexs)) {
            return vols;
        } else {
            List<VoltageData> voltageDatas = userUtil.getVoltageData(devIndexs);
            for (VoltageData voltageData : voltageDatas) {
                Voltage voltage = new Voltage();
                voltage.setVoltageValue(voltageData.getVol());
                if (CollectionUtils.isEmpty(voltageData.getLineIndexs())) {
                    continue;
                } else {
                    voltage.setAmounts(voltageData.getLineIndexs().size());
                    voltage.setTimes(getEventCoutsByLineIndex(voltageData.getLineIndexs(), startTime, endTime));
                }
                vols.add(voltage);
            }
        }
        return vols;
    }

    /**
     * 根据时间/监测点索引获取暂降次数
     */
    private Integer getEventCoutsByLineIndex(List<Integer> lineIndexs, Date startTime, Date endTime) {
        Integer counts = 0;
        //根据监测点去查询暂降次数
        List<Integer> lineIndexsTemp = new ArrayList<>(lineIndexs);
        if (lineIndexsTemp.size() > 1000) {
            int size = lineIndexsTemp.size() / 1000 + 1;
            for (int i = 0; i < size; i++) {
                if (lineIndexsTemp.size() > 1000) {
                    List<Integer> tempLineIndexs = lineIndexsTemp.subList(0, 1000);
                    Integer temp = eventDetailMapper.queryVoltageCountsByLineIndexs(tempLineIndexs, startTime, endTime);
                    if (null != temp) {
                        counts = counts + temp;
                    }
                    tempLineIndexs.clear();
                } else {
                    Integer temp = eventDetailMapper.queryVoltageCountsByLineIndexs(lineIndexsTemp, startTime, endTime);
                    if (null != temp) {
                        counts = counts + temp;
                    }
                }
            }
        } else {
            Integer temp = eventDetailMapper.queryVoltageCountsByLineIndexs(lineIndexsTemp, startTime, endTime);
            if (null != temp) {
                counts = counts + temp;
            }
        }
        return counts;
    }


    /**
     * 区域--》区域概况--》时间间隔统计
     *
     * @param lineIndex 监测点索引
     * @param startTime 起始时间
     * @param endTime   截止时间
     */
    List<Interval> getIntervals(List<Integer> lineIndex, Date startTime, Date endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        List<String> intervalTime = getIntervalTime(sdf.format(startTime), sdf.format(endTime));
        // 按时间间隔获取暂降次数
        List<Interval> inters = new ArrayList<>();
        if (CollectionUtils.isEmpty(lineIndex)) {
            for (String interTime : intervalTime) {
                Interval inter = new Interval();
                inter.setMonth(interTime.substring(5));
                inter.setYear(interTime.substring(0, 4));
                inter.setTimes(0);
                inters.add(inter);
            }
            return inters;
        } else {
            //获取两个时间的之间的月份
            for (String interTime : intervalTime) {
                List<Integer> lineIndexTemp = new ArrayList<>(lineIndex);
                Interval inter = new Interval();
                inter.setMonth(interTime.substring(5));
                inter.setYear(interTime.substring(0, 4));
                //从事件总汇表获取对应时间的所有事件数量
                Integer count = 0;
                //分片1000个监测点
                int length = lineIndexTemp.size();
                if (length > 1000) {
                    //需要循环的次数
                    int times = length / 1000 + 1;
                    for (int i = 1; i <= times; i++) {
                        if (length > 1000) {
                            List<Integer> temp = lineIndexTemp.subList(0, 999);
                            Integer countT = eventDetailMapper.getCountsByInterval(interTime, temp);
                            if (null != countT) {
                                count = count + countT;
                            }
                            temp.clear();
                            length = length - 1000;
                        } else {
                            Integer countT = eventDetailMapper.getCountsByInterval(interTime, lineIndexTemp);
                            if (null != countT) {
                                count = count + countT;
                            }
                        }
                    }
                } else {
                    count = eventDetailMapper.getCountsByInterval(interTime, lineIndexTemp);
                }
                if (null == count) {
                    count = 0;
                }
                //获取当前月的事件总数
                inter.setTimes(count);
                //从事件关联表获取对应时间的所有事件数量（已经关联后处理的事件）
                Integer handledTimes = eventAssMapper.getCountsByInterval(interTime);
                if (null == handledTimes) {
                    handledTimes = 0;
                }
                //只有省级专职用户才可以查询
                inter.setHandledTimes(handledTimes);
                inters.add(inter);
            }
            return inters;
        }
    }


    /**
     * 根据用户选择的时间区间返回月份日期
     *
     * @throws ParseException
     */
    private static List<String> getIntervalTime(String startTime, String endTime) {
        List<String> times = new ArrayList<>();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        Date start = null;
        Date end = null;
        try {
            start = sdf.parse(startTime);
            end = sdf.parse(endTime);
            // 同月
            if (start.getTime() == end.getTime()) {
                String time = startTime.substring(0, 7);
                times.add(time);
            } else if (start.getYear() == end.getYear()) {
                // 同年
                int startM = start.getMonth() + 1;
                int endM = end.getMonth() + 1;
                int temp = endM - startM;
                for (int i = 0; i <= temp; i++) {
                    String time = start.getYear() + 1900 + "";
                    int month = startM + i;
                    if (month < 10) {
                        time = time + "-0" + month;
                    } else {
                        time = time + "-" + month;
                    }
                    times.add(time);
                }
            } else {
                // 不同年!!!!这里忽略了年份之间跨年的情况
                int startY = start.getYear() + 1900;
                int startM = start.getMonth() + 1;
                int endY = end.getYear() + 1900;
                int endM = end.getMonth() + 1;
                int tempS = 12 - startM;
                // 连续的年份
                if (endY - startY == 1) {
                    // 第一年的时间获取
                    for (int i = 0; i <= tempS; i++) {
                        int month = startM + i;
                        String time = startY + "-";
                        if (month < 10) {
                            time = time + "0" + month;
                        } else {
                            time = time + month;
                        }
                        times.add(time);
                    }
                    // 第二年的时间获取

                    for (int i = 1; i <= endM; i++) {
                        String time = endY + "-";
                        if (i < 10) {
                            time = time + "0" + i;
                        } else {
                            time = time + i;
                        }
                        times.add(time);
                    }
                } else {
                    // 不连续的年份
                    // 第一年的时间获取
                    for (int i = 0; i <= tempS; i++) {
                        int month = startM + i;
                        String time = startY + "-";
                        if (month < 10) {
                            time = time + "0" + month;
                        } else {
                            time = time + month;
                        }
                        times.add(time);
                    }
                    int tempY = endY - startY;
                    // 中间年份的时间
                    for (int i = 1; i < tempY; i++) {
                        for (int j = 1; j <= 12; j++) {
                            String time = startY + i + "-";
                            if (j < 10) {
                                time = time + "0" + j;
                            } else {
                                time = time + j;
                            }
                            times.add(time);
                        }
                    }
                    // 最后一年的时间获取
                    for (int i = 1; i <= endM; i++) {
                        String time = endY + "-";
                        if (i < 10) {
                            time = time + "0" + i;
                        } else {
                            time = time + i;
                        }
                        times.add(time);
                    }
                }

            }
        } catch (ParseException e) {
            logger.error(e.getMessage());
        }
        return times;
    }


    /**
     * 需要返回区域、变电站、监测点的严重度分析结果
     * 目前版本的严重度通过暂降次数描述
     */
    @Override
    public Level queryLevel(String area, Date sTime, Date eTime) {
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        DecimalFormat df = new DecimalFormat("0.00");
        //区域数据
        List<SimpleValue> areaList = new ArrayList<>();
        //变电站数据
        List<SimpleValue> subList = new ArrayList<>();
        //监测点数据
        List<SimpleValue> monitorList = new ArrayList<>();
        List<AreaGeneralData> areaGeneral = userUtil.getAreaDataByInfo(area);
        if (CollectionUtils.isEmpty(areaGeneral)) {
            return null;
        }
        List<Integer> lineIndex = new ArrayList<>();
        //获取所有区域以及变电站的数据
        for (AreaGeneralData areaGeneralData : areaGeneral) {
            SimpleValue sim = new SimpleValue();
            sim.setName(areaGeneralData.getName());
            List<Integer> subIndexs = areaGeneralData.getSubIndexs();
            List<Integer> lineIndexTemp = areaGeneralData.getLineIndexs();
            int eventCounts = 0;
            for (Integer integer : subIndexs) {
                //通过
                SimpleValue simSub = eventDetailMapper.querySubLevel(sTime, eTime, integer, lineIndexTemp);
                if (null != simSub && !simSub.getValue().equalsIgnoreCase("0")) {
                    eventCounts = eventCounts + Integer.parseInt(simSub.getValue());
                }
                subList.add(simSub);
            }
            int monitors = areaGeneralData.getMonitors();
            if (monitors == 0) {
                sim.setNode("0.00");
            } else {
                sim.setNode(df.format(Float.valueOf(eventCounts) / Float.valueOf(monitors)));
            }
            sim.setValue(String.valueOf(eventCounts));
            sim.setCountAll(areaGeneralData.getMonitors());
            areaList.add(sim);
            lineIndex.addAll(lineIndexTemp);
        }
        //监测点
        monitorList.addAll(getLineLevelData(sTime, eTime, lineIndex));
        Level level = new Level();
        level.setAreaList(areaList);
        level.setMonitorList(monitorList);
        level.setSubList(subList);
        return level;
    }

    /**
     * 根据监测点获取对应的暂降数据
     *
     * @param sTime     起始时间
     * @param eTime     截止时间
     * @param lineIndex 监测点
     */
    private List<SimpleValue> getLineLevelData(Date sTime, Date eTime, List<Integer> lineIndex) {
        if (CollectionUtils.isEmpty(lineIndex)) {
            return new ArrayList<>();
        }
        List<SimpleValue> sims = eventDetailMapper.queryLineLevel(sTime, eTime, lineIndex);
        if (CollectionUtils.isEmpty(sims)) {
            sims = new ArrayList<>();
            for (Integer index : lineIndex) {
                SimpleValue sim = new SimpleValue();
                sim.setName(lineMapper.selectLineName(String.valueOf(index)));
                sim.setValue("0");
                sims.add(sim);
                if (sims.size() > 29) {
                    break;
                }
            }
        } else {
            for (SimpleValue simpleValue : sims) {
                simpleValue.setName(lineMapper.selectLineName(simpleValue.getName()));
            }
        }
        return sims;
    }


    /**
     * 概览--》区域严重度
     *
     * @param sTime 起始时间
     * @param eTime 截止时间
     */
    @Override
    public Level queryLevel(Date sTime, Date eTime) {
        List<AreaGeneralData> areaGeneral = userUtil.getAreaGeneralRun();
        if (CollectionUtils.isEmpty(areaGeneral)) {
            return null;
        }
        List<Integer> devIndexs = new ArrayList<>();
        List<Integer> allline = new ArrayList<>();
        //区域数据
        List<SimpleValue> areaList = new ArrayList<>();
        List<SimpleValue> monitorList = new ArrayList<>();
        List<Voltage> vols;
        int events = 0;
        int points = 0;
        //获取所有区域以及变电站的数据
        for (AreaGeneralData areaGeneralData : areaGeneral) {
            SimpleValue sim = new SimpleValue();
            //地市名称
            sim.setName(areaGeneralData.getName());
            //监测点数
            int monitors = areaGeneralData.getLineIndexs().size();
            sim.setNode(String.valueOf(monitors));
            List<Integer> lineIndexs = areaGeneralData.getLineIndexs();
            Integer eventCounts = 0;
            if (!CollectionUtils.isEmpty(lineIndexs)) {
                allline.addAll(lineIndexs);
                eventCounts = getEventCoutsByLineIndex(lineIndexs, sTime, eTime);
            }
            points = points + monitors;
            //暂降次数
            if (monitors == 0) {
                sim.setValue("3.1415");
            } else if (eventCounts == null || eventCounts == 0) {
                sim.setValue("3.14159");
            } else {
                sim.setValue(String.valueOf(eventCounts));
                events = events + eventCounts;
            }
            areaList.add(sim);
            devIndexs.addAll(areaGeneralData.getDeviceIndexs());
        }
        vols = getVols(devIndexs, sTime, eTime);

        //处理超过1000个监测点情况
        if(allline.size()>1000){
            Integer count = allline.size()/1000+1;
            for(int i=0;i<count;i++){
                List<SimpleValue> temp=null;
                if(allline.size()>1000){
                    List<Integer> temLine = allline.subList(0,1000);
                    temp = eventDetailMapper.queryLineEvents(temLine, sTime, eTime);
                    temLine.clear();
                }else{
                    temp = eventDetailMapper.queryLineEvents(allline, sTime, eTime);
                }
                if(CollectionUtil.isNotEmpty(temp)){
                    monitorList.addAll(temp);
                }
            }
        }else{
            monitorList = eventDetailMapper.queryLineEvents(allline, sTime, eTime);
        }


        Collections.sort(areaList, new Comparator<SimpleValue>() {
            /*
             * int compare(Person p1, Person p2) 返回一个基本类型的整型，
             * 返回负数表示：p1 小于p2，
             * 返回0 表示：p1和p2相等，
             * 返回正数表示：p1大于p2
             */
            @Override
            public int compare(SimpleValue p1, SimpleValue p2) {
                if (p1.getValue() == "3.1415" || p1.getValue() == "3.14159") {
                    return 1;
                }
                if (p2.getValue() == "3.1415" || p2.getValue() == "3.14159") {
                    return -1;
                }
                if (Integer.parseInt(p2.getValue()) > Integer.parseInt(p1.getValue())) {
                    return 1;
                }
                if (Integer.parseInt(p2.getValue()) == Integer.parseInt(p1.getValue())) {
                    return 0;
                }
                return -1;
            }
        });
        SimpleValue total = new SimpleValue();
        total.setName("总计");
        total.setNode(String.valueOf(points));
        total.setValue(String.valueOf(events));
        areaList.add(0, total);

        Level level = new Level();
        level.setAreaList(areaList);
        level.setVol(vols);
        level.setMonitorList(monitorList);
        return level;
    }


    @Override
    public List<LineInfo> getEventMaps(Date startTime, Date endTime) {
        List<LineInfo> result = new ArrayList<>();

        List<LineMaps> vdLists = new ArrayList<>();
        List<Integer> linelist = userUtil.listLineRun();
        int total = 0;
        if (!linelist.isEmpty()) {
            List<Integer> lineIndexsTemp = new ArrayList<>(linelist);
            if (lineIndexsTemp.size() > 100) {
                int size = lineIndexsTemp.size() / 100 + 1;
                for (int i = 0; i < size; i++) {
                    if (lineIndexsTemp.size() > 100) {
                        List<Integer> tempLineIndexs = lineIndexsTemp.subList(0, 100);
                        List<LineMaps> tmplist = lineMapsMapper.queryLineMapsForAll(tempLineIndexs);//返回的监测点的地理信息
                        vdLists.addAll(tmplist);
                        tempLineIndexs.clear();
                    } else {
                        List<LineMaps> tmplist = lineMapsMapper.queryLineMapsForAll(lineIndexsTemp);//返回的监测点的地理信息
                        vdLists.addAll(tmplist);
                    }
                }
            } else {
                vdLists = lineMapsMapper.queryLineMapsForAll(lineIndexsTemp);//返回的监测点的地理信息
            }

            if (!vdLists.isEmpty() && vdLists.size() != 0) {
                for (int i = 0; i < vdLists.size(); i++) {
                    LineInfo info = new LineInfo();
                    info.setLatitude(vdLists.get(i).getLatitude());
                    info.setLongitude(vdLists.get(i).getLongitude());
                    info.setGdName(vdLists.get(i).getGdname());
                    info.setSubName(vdLists.get(i).getSubname());
                    info.setName(vdLists.get(i).getLinename());

                    Integer count = eventdataMapper.getCountByIndex(vdLists.get(i).getLineindex(), startTime, endTime);
                    info.setEventcount(count);

                    result.add(info);
                    total = total + count;
                }
                Collections.sort(result, new Comparator<LineInfo>() {
                    /*
                     * int compare(Person p1, Person p2) 返回一个基本类型的整型，
                     * 返回负数表示：p1 小于p2，
                     * 返回0 表示：p1和p2相等，
                     * 返回正数表示：p1大于p2
                     */
                    @Override
                    public int compare(LineInfo p1, LineInfo p2) {
                        //按照Person的年龄进行升序排列
                        if (p2.getEventcount() > p1.getEventcount()) {
                            return 1;
                        }
                        if (p2.getEventcount() == p1.getEventcount()) {
                            return 0;
                        }
                        return -1;
                    }
                });
            }
        }
        LineInfo all = new LineInfo();
        all.setGdName("总计");
        all.setSubName("/");
        all.setName("/");
        all.setEventcount(total);
        result.add(0, all);
        return result;
    }

    @Override
    public List<LineInfo> getGdcounts(Date startTime, Date endTime) {
        List<LineInfo> result = new ArrayList<>();

        List<Integer> gdlist = userUtil.listGD();
        if (!gdlist.isEmpty()) {
            for (int i = 0; i < gdlist.size(); i++) {
                LineInfo info = new LineInfo();
                Integer count = eventdataMapper.getGdcounts(gdlist.get(i), startTime, endTime);
                if (count > 0) {
                    info.setEventcount(count);
                    String name = gdMapper.getGdName(Long.valueOf(gdlist.get(i)));
                    info.setGdName(name);

                    result.add(info);
                }
            }
        }
        return result;
    }

    @Override
    public List<EventDensity> getEventDensity(Date startTime, Date endTime, String area) {
        List<EventDensity> result = new ArrayList<>();
        List<EventDataList> info;
        AreaGeneral areaGen;
        //判断用户是否拥有省级权限
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);
        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());

        if (lineIndexs.size() == 0) {
            return null;
        }
        info = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);

        EventDensity a0 = new EventDensity();
        a0.setX(0);
        a0.setY(0);
        a0.setZ(0);
        result.add(a0);
        EventDensity a1 = new EventDensity();
        a1.setX(0);
        a1.setY(1);
        a1.setZ(0);
        result.add(a1);
        EventDensity a2 = new EventDensity();
        a2.setX(0);
        a2.setY(2);
        a2.setZ(0);
        result.add(a2);
        EventDensity a3 = new EventDensity();
        a3.setX(0);
        a3.setY(3);
        a3.setZ(0);
        result.add(a3);
        EventDensity a4 = new EventDensity();
        a4.setX(0);
        a4.setY(4);
        a4.setZ(0);
        result.add(a4);
        EventDensity a5 = new EventDensity();
        a5.setX(0);
        a5.setY(5);
        a5.setZ(0);
        result.add(a5);
        EventDensity a6 = new EventDensity();
        a6.setX(0);
        a6.setY(6);
        a6.setZ(0);
        result.add(a6);
        EventDensity a7 = new EventDensity();
        a7.setX(0);
        a7.setY(7);
        a7.setZ(0);
        result.add(a7);
        EventDensity a8 = new EventDensity();
        a8.setX(0);
        a8.setY(8);
        a8.setZ(0);
        result.add(a8);

        EventDensity b0 = new EventDensity();
        b0.setX(1);
        b0.setY(0);
        b0.setZ(0);
        result.add(b0);
        EventDensity b1 = new EventDensity();
        b1.setX(1);
        b1.setY(1);
        b1.setZ(0);
        result.add(b1);
        EventDensity b2 = new EventDensity();
        b2.setX(1);
        b2.setY(2);
        b2.setZ(0);
        result.add(b2);
        EventDensity b3 = new EventDensity();
        b3.setX(1);
        b3.setY(3);
        b3.setZ(0);
        result.add(b3);
        EventDensity b4 = new EventDensity();
        b4.setX(1);
        b4.setY(4);
        b4.setZ(0);
        result.add(b4);
        EventDensity b5 = new EventDensity();
        b5.setX(1);
        b5.setY(5);
        b5.setZ(0);
        result.add(b5);
        EventDensity b6 = new EventDensity();
        b6.setX(1);
        b6.setY(6);
        b6.setZ(0);
        result.add(b6);
        EventDensity b7 = new EventDensity();
        b7.setX(1);
        b7.setY(7);
        b7.setZ(0);
        result.add(b7);
        EventDensity b8 = new EventDensity();
        b8.setX(1);
        b8.setY(8);
        b8.setZ(0);
        result.add(b8);

        EventDensity c0 = new EventDensity();
        c0.setX(2);
        c0.setY(0);
        c0.setZ(0);
        result.add(c0);
        EventDensity c1 = new EventDensity();
        c1.setX(2);
        c1.setY(1);
        c1.setZ(0);
        result.add(c1);
        EventDensity c2 = new EventDensity();
        c2.setX(2);
        c2.setY(2);
        c2.setZ(0);
        result.add(c2);
        EventDensity c3 = new EventDensity();
        c3.setX(2);
        c3.setY(3);
        c3.setZ(0);
        result.add(c3);
        EventDensity c4 = new EventDensity();
        c4.setX(2);
        c4.setY(4);
        c4.setZ(0);
        result.add(c4);
        EventDensity c5 = new EventDensity();
        c5.setX(2);
        c5.setY(5);
        c5.setZ(0);
        result.add(c5);
        EventDensity c6 = new EventDensity();
        c6.setX(2);
        c6.setY(6);
        c6.setZ(0);
        result.add(c6);
        EventDensity c7 = new EventDensity();
        c7.setX(2);
        c7.setY(7);
        c7.setZ(0);
        result.add(c7);
        EventDensity c8 = new EventDensity();
        c8.setX(2);
        c8.setY(8);
        c8.setZ(0);
        result.add(c8);

        EventDensity d0 = new EventDensity();
        d0.setX(3);
        d0.setY(0);
        d0.setZ(0);
        result.add(d0);
        EventDensity d1 = new EventDensity();
        d1.setX(3);
        d1.setY(1);
        d1.setZ(0);
        result.add(d1);
        EventDensity d2 = new EventDensity();
        d2.setX(3);
        d2.setY(2);
        d2.setZ(0);
        result.add(d2);
        EventDensity d3 = new EventDensity();
        d3.setX(3);
        d3.setY(3);
        d3.setZ(0);
        result.add(d3);
        EventDensity d4 = new EventDensity();
        d4.setX(3);
        d4.setY(4);
        d4.setZ(0);
        result.add(d4);
        EventDensity d5 = new EventDensity();
        d5.setX(3);
        d5.setY(5);
        d5.setZ(0);
        result.add(d5);
        EventDensity d6 = new EventDensity();
        d6.setX(3);
        d6.setY(6);
        d6.setZ(0);
        result.add(d6);
        EventDensity d7 = new EventDensity();
        d7.setX(3);
        d7.setY(7);
        d7.setZ(0);
        result.add(d7);
        EventDensity d8 = new EventDensity();
        d8.setX(3);
        d8.setY(8);
        d8.setZ(0);
        result.add(d8);

        EventDensity e0 = new EventDensity();
        e0.setX(4);
        e0.setY(0);
        e0.setZ(0);
        result.add(e0);
        EventDensity e1 = new EventDensity();
        e1.setX(4);
        e1.setY(1);
        e1.setZ(0);
        result.add(e1);
        EventDensity e2 = new EventDensity();
        e2.setX(4);
        e2.setY(2);
        e2.setZ(0);
        result.add(e2);
        EventDensity e3 = new EventDensity();
        e3.setX(4);
        e3.setY(3);
        e3.setZ(0);
        result.add(e3);
        EventDensity e4 = new EventDensity();
        e4.setX(4);
        e4.setY(4);
        e4.setZ(0);
        result.add(e4);
        EventDensity e5 = new EventDensity();
        e5.setX(4);
        e5.setY(5);
        e5.setZ(0);
        result.add(e5);
        EventDensity e6 = new EventDensity();
        e6.setX(4);
        e6.setY(6);
        e6.setZ(0);
        result.add(e6);
        EventDensity e7 = new EventDensity();
        e7.setX(4);
        e7.setY(7);
        e7.setZ(0);
        result.add(e7);
        EventDensity e8 = new EventDensity();
        e8.setX(4);
        e8.setY(8);
        e8.setZ(0);
        result.add(e8);

        EventDensity f0 = new EventDensity();
        f0.setX(5);
        f0.setY(0);
        f0.setZ(0);
        result.add(f0);
        EventDensity f1 = new EventDensity();
        f1.setX(5);
        f1.setY(1);
        f1.setZ(0);
        result.add(f1);
        EventDensity f2 = new EventDensity();
        f2.setX(5);
        f2.setY(2);
        f2.setZ(0);
        result.add(f2);
        EventDensity f3 = new EventDensity();
        f3.setX(5);
        f3.setY(3);
        f3.setZ(0);
        result.add(f3);
        EventDensity f4 = new EventDensity();
        f4.setX(5);
        f4.setY(4);
        f4.setZ(0);
        result.add(f4);
        EventDensity f5 = new EventDensity();
        f5.setX(5);
        f5.setY(5);
        f5.setZ(0);
        result.add(f5);
        EventDensity f6 = new EventDensity();
        f6.setX(5);
        f6.setY(6);
        f6.setZ(0);
        result.add(f6);
        EventDensity f7 = new EventDensity();
        f7.setX(5);
        f7.setY(7);
        f7.setZ(0);
        result.add(f7);
        EventDensity f8 = new EventDensity();
        f8.setX(5);
        f8.setY(8);
        f8.setZ(0);
        result.add(f8);

        EventDensity g0 = new EventDensity();
        g0.setX(6);
        g0.setY(0);
        g0.setZ(0);
        result.add(g0);
        EventDensity g1 = new EventDensity();
        g1.setX(6);
        g1.setY(1);
        g1.setZ(0);
        result.add(g1);
        EventDensity g2 = new EventDensity();
        g2.setX(6);
        g2.setY(2);
        g2.setZ(0);
        result.add(g2);
        EventDensity g3 = new EventDensity();
        g3.setX(6);
        g3.setY(3);
        g3.setZ(0);
        result.add(g3);
        EventDensity g4 = new EventDensity();
        g4.setX(6);
        g4.setY(4);
        g4.setZ(0);
        result.add(g4);
        EventDensity g5 = new EventDensity();
        g5.setX(6);
        g5.setY(5);
        g5.setZ(0);
        result.add(g5);
        EventDensity g6 = new EventDensity();
        g6.setX(6);
        g6.setY(6);
        g6.setZ(0);
        result.add(g6);
        EventDensity g7 = new EventDensity();
        g7.setX(6);
        g7.setY(7);
        g7.setZ(0);
        result.add(g7);
        EventDensity g8 = new EventDensity();
        g8.setX(6);
        g8.setY(8);
        g8.setZ(0);
        result.add(g8);

        EventDensity h0 = new EventDensity();
        h0.setX(7);
        h0.setY(0);
        h0.setZ(0);
        result.add(h0);
        EventDensity h1 = new EventDensity();
        h1.setX(7);
        h1.setY(1);
        h1.setZ(0);
        result.add(h1);
        EventDensity h2 = new EventDensity();
        h2.setX(7);
        h2.setY(2);
        h2.setZ(0);
        result.add(h2);
        EventDensity h3 = new EventDensity();
        h3.setX(7);
        h3.setY(3);
        h3.setZ(0);
        result.add(h3);
        EventDensity h4 = new EventDensity();
        h4.setX(7);
        h4.setY(4);
        h4.setZ(0);
        result.add(h4);
        EventDensity h5 = new EventDensity();
        h5.setX(7);
        h5.setY(5);
        h5.setZ(0);
        result.add(h5);
        EventDensity h6 = new EventDensity();
        h6.setX(7);
        h6.setY(6);
        h6.setZ(0);
        result.add(h6);
        EventDensity h7 = new EventDensity();
        h7.setX(7);
        h7.setY(7);
        h7.setZ(0);
        result.add(h7);
        EventDensity h8 = new EventDensity();
        h8.setX(7);
        h8.setY(8);
        h8.setZ(0);
        result.add(h8);

        EventDensity i0 = new EventDensity();
        i0.setX(8);
        i0.setY(0);
        i0.setZ(0);
        result.add(i0);
        EventDensity i1 = new EventDensity();
        i1.setX(8);
        i1.setY(1);
        i1.setZ(0);
        result.add(i1);
        EventDensity i2 = new EventDensity();
        i2.setX(8);
        i2.setY(2);
        i2.setZ(0);
        result.add(i2);
        EventDensity i3 = new EventDensity();
        i3.setX(8);
        i3.setY(3);
        i3.setZ(0);
        result.add(i3);
        EventDensity i4 = new EventDensity();
        i4.setX(8);
        i4.setY(4);
        i4.setZ(0);
        result.add(i4);
        EventDensity i5 = new EventDensity();
        i5.setX(8);
        i5.setY(5);
        i5.setZ(0);
        result.add(i5);
        EventDensity i6 = new EventDensity();
        i6.setX(8);
        i6.setY(6);
        i6.setZ(0);
        result.add(i6);
        EventDensity i7 = new EventDensity();
        i7.setX(8);
        i7.setY(7);
        i7.setZ(0);
        result.add(i7);
        EventDensity i8 = new EventDensity();
        i8.setX(8);
        i8.setY(8);
        i8.setZ(0);
        result.add(i8);

        EventDensity j0 = new EventDensity();
        j0.setX(9);
        j0.setY(0);
        j0.setZ(0);
        result.add(j0);
        EventDensity j1 = new EventDensity();
        j1.setX(9);
        j1.setY(1);
        j1.setZ(0);
        result.add(j1);
        EventDensity j2 = new EventDensity();
        j2.setX(9);
        j2.setY(2);
        j2.setZ(0);
        result.add(j2);
        EventDensity j3 = new EventDensity();
        j3.setX(9);
        j3.setY(3);
        j3.setZ(0);
        result.add(j3);
        EventDensity j4 = new EventDensity();
        j4.setX(9);
        j4.setY(4);
        j4.setZ(0);
        result.add(j4);
        EventDensity j5 = new EventDensity();
        j5.setX(9);
        j5.setY(5);
        j5.setZ(0);
        result.add(j5);
        EventDensity j6 = new EventDensity();
        j6.setX(9);
        j6.setY(6);
        j6.setZ(0);
        result.add(j6);
        EventDensity j7 = new EventDensity();
        j7.setX(9);
        j7.setY(7);
        j7.setZ(0);
        result.add(j7);
        EventDensity j8 = new EventDensity();
        j8.setX(9);
        j8.setY(8);
        j8.setZ(0);
        result.add(j8);

        for (int i = 0; i < info.size(); i++) {
            EventDensity dto = new EventDensity();
            if (info.get(i).getEventvalue() >= 0 && info.get(i).getEventvalue() <= 0.1) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(0).getZ();
                    dto.setX(0);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(0, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(1).getZ();
                    dto.setX(0);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(1, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(2).getZ();
                    dto.setX(0);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(2, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(3).getZ();
                    dto.setX(0);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(3, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(4).getZ();
                    dto.setX(0);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(4, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(5).getZ();
                    dto.setX(0);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(5, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(6).getZ();
                    dto.setX(0);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(6, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(7).getZ();
                    dto.setX(0);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(7, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    // result.get(8).setX(0);
                    // result.get(8).setY(8);
                    // result.get(8).setZ(result.get(8).getZ()+1);
                    int z = result.get(8).getZ();
                    dto.setX(0);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(8, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.1 && info.get(i).getEventvalue() <= 0.2) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(9).getZ();
                    dto.setX(1);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(9, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(10).getZ();
                    dto.setX(1);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(10, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(11).getZ();
                    dto.setX(1);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(11, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(12).getZ();
                    dto.setX(1);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(12, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(13).getZ();
                    dto.setX(1);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(13, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(14).getZ();
                    dto.setX(1);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(14, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(15).getZ();
                    dto.setX(1);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(15, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(16).getZ();
                    dto.setX(1);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(16, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(17).getZ();
                    dto.setX(1);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(17, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.2 && info.get(i).getEventvalue() <= 0.3) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(18).getZ();
                    dto.setX(2);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(18, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(19).getZ();
                    dto.setX(2);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(19, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(20).getZ();
                    dto.setX(2);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(20, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(21).getZ();
                    dto.setX(2);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(21, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(22).getZ();
                    dto.setX(2);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(22, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(23).getZ();
                    dto.setX(2);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(23, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(24).getZ();
                    dto.setX(2);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(24, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(25).getZ();
                    dto.setX(2);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(25, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(26).getZ();
                    dto.setX(2);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(26, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.3 && info.get(i).getEventvalue() <= 0.4) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(27).getZ();
                    dto.setX(3);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(27, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(28).getZ();
                    dto.setX(3);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(28, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(29).getZ();
                    dto.setX(3);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(29, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(30).getZ();
                    dto.setX(3);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(30, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(31).getZ();
                    dto.setX(3);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(31, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(32).getZ();
                    dto.setX(3);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(32, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(33).getZ();
                    dto.setX(3);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(33, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(34).getZ();
                    dto.setX(3);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(34, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(35).getZ();
                    dto.setX(3);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(35, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.4 && info.get(i).getEventvalue() <= 0.5) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(36).getZ();
                    dto.setX(4);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(36, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(37).getZ();
                    dto.setX(4);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(37, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(38).getZ();
                    dto.setX(4);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(38, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(39).getZ();
                    dto.setX(4);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(39, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(40).getZ();
                    dto.setX(4);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(40, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(41).getZ();
                    dto.setX(4);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(41, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(42).getZ();
                    dto.setX(4);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(42, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(43).getZ();
                    dto.setX(4);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(43, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(44).getZ();
                    dto.setX(4);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(44, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.5 && info.get(i).getEventvalue() <= 0.6) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(45).getZ();
                    dto.setX(5);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(45, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(46).getZ();
                    dto.setX(5);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(46, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(47).getZ();
                    dto.setX(5);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(47, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(48).getZ();
                    dto.setX(5);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(48, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(49).getZ();
                    dto.setX(5);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(49, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(50).getZ();
                    dto.setX(5);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(50, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(51).getZ();
                    dto.setX(5);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(51, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(52).getZ();
                    dto.setX(5);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(52, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(53).getZ();
                    dto.setX(5);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(53, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.6 && info.get(i).getEventvalue() <= 0.7) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(54).getZ();
                    dto.setX(6);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(54, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(55).getZ();
                    dto.setX(6);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(55, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(56).getZ();
                    dto.setX(6);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(56, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(57).getZ();
                    dto.setX(6);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(57, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(58).getZ();
                    dto.setX(6);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(58, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(59).getZ();
                    dto.setX(6);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(59, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(60).getZ();
                    dto.setX(6);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(60, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(61).getZ();
                    dto.setX(6);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(61, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(62).getZ();
                    dto.setX(6);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(62, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.7 && info.get(i).getEventvalue() <= 0.8) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(63).getZ();
                    dto.setX(7);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(63, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(64).getZ();
                    dto.setX(7);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(64, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(65).getZ();
                    dto.setX(7);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(65, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(66).getZ();
                    dto.setX(7);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(66, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(67).getZ();
                    dto.setX(7);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(67, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(68).getZ();
                    dto.setX(7);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(68, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(69).getZ();
                    dto.setX(7);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(69, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(70).getZ();
                    dto.setX(7);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(70, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(71).getZ();
                    dto.setX(7);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(71, dto);
                }
            } else if (info.get(i).getEventvalue() > 0.8 && info.get(i).getEventvalue() <= 0.9) {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(72).getZ();
                    dto.setX(8);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(72, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(73).getZ();
                    dto.setX(8);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(73, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(74).getZ();
                    dto.setX(8);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(74, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(75).getZ();
                    dto.setX(8);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(75, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(76).getZ();
                    dto.setX(8);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(76, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(77).getZ();
                    dto.setX(8);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(77, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(78).getZ();
                    dto.setX(8);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(78, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(79).getZ();
                    dto.setX(8);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(79, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(80).getZ();
                    dto.setX(8);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(80, dto);
                }
            } else {
                if (info.get(i).getPersisttime() > 0 && info.get(i).getPersisttime() <= 0.020) {
                    int z = result.get(81).getZ();
                    dto.setX(9);
                    dto.setY(0);
                    dto.setZ(z + 1);
                    result.set(81, dto);
                } else if (info.get(i).getPersisttime() <= 0.040 && info.get(i).getPersisttime() > 0.020) {
                    int z = result.get(82).getZ();
                    dto.setX(9);
                    dto.setY(1);
                    dto.setZ(z + 1);
                    result.set(82, dto);
                } else if (info.get(i).getPersisttime() <= 0.060 && info.get(i).getPersisttime() > 0.040) {
                    int z = result.get(83).getZ();
                    dto.setX(9);
                    dto.setY(2);
                    dto.setZ(z + 1);
                    result.set(83, dto);
                } else if (info.get(i).getPersisttime() <= 0.080 && info.get(i).getPersisttime() > 0.060) {
                    int z = result.get(84).getZ();
                    dto.setX(9);
                    dto.setY(3);
                    dto.setZ(z + 1);
                    result.set(84, dto);
                } else if (info.get(i).getPersisttime() <= 0.120 && info.get(i).getPersisttime() > 0.080) {
                    int z = result.get(85).getZ();
                    dto.setX(9);
                    dto.setY(4);
                    dto.setZ(z + 1);
                    result.set(85, dto);
                } else if (info.get(i).getPersisttime() > 0.120 && info.get(i).getPersisttime() < 0.200) {
                    int z = result.get(86).getZ();
                    dto.setX(9);
                    dto.setY(5);
                    dto.setZ(z + 1);
                    result.set(87, dto);
                } else if (info.get(i).getPersisttime() >= 0.200 && info.get(i).getPersisttime() < 0.400) {
                    int z = result.get(87).getZ();
                    dto.setX(9);
                    dto.setY(6);
                    dto.setZ(z + 1);
                    result.set(87, dto);
                } else if (info.get(i).getPersisttime() >= 0.400 && info.get(i).getPersisttime() < 0.600) {
                    int z = result.get(88).getZ();
                    dto.setX(9);
                    dto.setY(7);
                    dto.setZ(z + 1);
                    result.set(88, dto);
                } else if (info.get(i).getPersisttime() >= 0.600 && info.get(i).getPersisttime() <= 1.200) {
                    int z = result.get(89).getZ();
                    dto.setX(9);
                    dto.setY(8);
                    dto.setZ(z + 1);
                    result.set(89, dto);
                }
            }
        }

        return result;
    }

    /**
     * 获取区域暂降事件点数据
     */
    @Override
    public List<EventDataList> getEventDataList(Date startTime, Date endTime, String area) {
        List<EventDataList> result;
        AreaGeneral areaGen;
        //判断用户是否拥有省级权限
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);
        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());
        if (lineIndexs.size() == 0) {
            return null;
        }
        result = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);
        for (int i = 0; i < result.size(); i++) {
            float per = (float) (Math.round((result.get(i).getPersisttime()) * 100)) / 100;
            float eve = (float) (Math.round(result.get(i).getEventvalue() * 100 * 100)) / 100;
            result.get(i).setEventvalue(eve);
        }

        return result;
    }

    @Override
    public List<List> getEventDisdip(Date startTime, Date endTime, String area) {
        List<List> result = new ArrayList<>();
        List<EventDataList> info;
        AreaGeneral areaGen;
        //判断用户是否拥有省级权限
        Depts deptsArea = deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);
        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());
        if (lineIndexs.size() == 0) {
            return null;
        }
        info = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);

        int a1 = 0, b1 = 0, c1 = 0, d1 = 0, e1 = 0, f1 = 0, g1 = 0, h1 = 0;
        int a2 = 0, b2 = 0, c2 = 0, d2 = 0, e2 = 0, f2 = 0, g2 = 0, h2 = 0;
        int a3 = 0, b3 = 0, c3 = 0, d3 = 0, e3 = 0, f3 = 0, g3 = 0, h3 = 0;
        int a4 = 0, b4 = 0, c4 = 0, d4 = 0, e4 = 0, f4 = 0, g4 = 0, h4 = 0;
        int a5 = 0, b5 = 0, c5 = 0, d5 = 0, e5 = 0, f5 = 0, g5 = 0, h5 = 0;

        for (int i = 0; i < info.size(); i++) {
            float eventvalue = info.get(i).getEventvalue();
            float persisttime = info.get(i).getPersisttime() * 1000;

            if (eventvalue * 100 < 10) {
                if (persisttime < 20) {
                    a5++;
                } else if (persisttime < 100) {
                    b5++;
                } else if (persisttime < 500) {
                    c5++;
                } else if (persisttime < 1000) {
                    d5++;
                } else if (persisttime < 3000) {
                    e5++;
                } else if (persisttime < 20000) {
                    f5++;
                } else if (persisttime < 60000) {
                    g5++;
                } else if (persisttime < 180000) {
                    h5++;
                }
            } else if (eventvalue * 100 < 40) {
                if (persisttime < 20) {
                    a4++;
                } else if (persisttime < 100) {
                    b4++;
                } else if (persisttime < 500) {
                    c4++;
                } else if (persisttime < 1000) {
                    d4++;
                } else if (persisttime < 3000) {
                    e4++;
                } else if (persisttime < 20000) {
                    f4++;
                } else if (persisttime < 60000) {
                    g4++;
                } else if (persisttime < 180000) {
                    h4++;
                }
            } else if (eventvalue * 100 < 70) {
                if (persisttime < 20) {
                    a3++;
                } else if (persisttime < 100) {
                    b3++;
                } else if (persisttime < 500) {
                    c3++;
                } else if (persisttime < 1000) {
                    d3++;
                } else if (persisttime < 3000) {
                    e3++;
                } else if (persisttime < 20000) {
                    f3++;
                } else if (persisttime < 60000) {
                    g3++;
                } else if (persisttime < 180000) {
                    h3++;
                }
            } else if (eventvalue * 100 < 85) {
                if (persisttime < 20) {
                    a2++;
                } else if (persisttime < 100) {
                    b2++;
                } else if (persisttime < 500) {
                    c2++;
                } else if (persisttime < 1000) {
                    d2++;
                } else if (persisttime < 3000) {
                    e2++;
                } else if (persisttime < 20000) {
                    f2++;
                } else if (persisttime < 60000) {
                    g2++;
                } else if (persisttime < 180000) {
                    h2++;
                }
            } else if (eventvalue * 100 <= 90) {
                if (persisttime < 20) {
                    a1++;
                } else if (persisttime < 100) {
                    b1++;
                } else if (persisttime < 500) {
                    c1++;
                } else if (persisttime < 1000) {
                    d1++;
                } else if (persisttime < 3000) {
                    e1++;
                } else if (persisttime < 20000) {
                    f1++;
                } else if (persisttime < 60000) {
                    g1++;
                } else if (persisttime < 180000) {
                    h1++;
                }
            }
        }

        List<String> tmp1 = new ArrayList<>();
        List<String> tmp2 = new ArrayList<>();
        List<String> tmp3 = new ArrayList<>();
        List<String> tmp4 = new ArrayList<>();
        List<String> tmp5 = new ArrayList<>();

        tmp1.add("90%");
        tmp2.add("85%");
        tmp3.add("70%");
        tmp4.add("40%");
        tmp5.add("10%");
        tmp1.add(String.valueOf(a1));
        tmp1.add(String.valueOf(b1));
        tmp1.add(String.valueOf(c1));
        tmp1.add(String.valueOf(d1));
        tmp1.add(String.valueOf(e1));
        tmp1.add(String.valueOf(f1));
        tmp1.add(String.valueOf(g1));
        tmp1.add(String.valueOf(h1));
        tmp2.add(String.valueOf(a2));
        tmp2.add(String.valueOf(b2));
        tmp2.add(String.valueOf(c2));
        tmp2.add(String.valueOf(d2));
        tmp2.add(String.valueOf(e2));
        tmp2.add(String.valueOf(f2));
        tmp2.add(String.valueOf(g2));
        tmp2.add(String.valueOf(h2));
        tmp3.add(String.valueOf(a3));
        tmp3.add(String.valueOf(b3));
        tmp3.add(String.valueOf(c3));
        tmp3.add(String.valueOf(d3));
        tmp3.add(String.valueOf(e3));
        tmp3.add(String.valueOf(f3));
        tmp3.add(String.valueOf(g3));
        tmp3.add(String.valueOf(h3));
        tmp4.add(String.valueOf(a4));
        tmp4.add(String.valueOf(b4));
        tmp4.add(String.valueOf(c4));
        tmp4.add(String.valueOf(d4));
        tmp4.add(String.valueOf(e4));
        tmp4.add(String.valueOf(f4));
        tmp4.add(String.valueOf(g4));
        tmp4.add(String.valueOf(h4));
        tmp5.add(String.valueOf(a5));
        tmp5.add(String.valueOf(b5));
        tmp5.add(String.valueOf(c5));
        tmp5.add(String.valueOf(d5));
        tmp5.add(String.valueOf(e5));
        tmp5.add(String.valueOf(f5));
        tmp5.add(String.valueOf(g5));
        tmp5.add(String.valueOf(h5));

        result.add(tmp1);
        result.add(tmp2);
        result.add(tmp3);
        result.add(tmp4);
        result.add(tmp5);
        return result;
    }

    @Override
    public List<List> getIEC411(Date startTime, Date endTime, String area) {
        List<List> result = new ArrayList<>();
        List<EventDataList> info;
        AreaGeneral areaGen;
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);
        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());
        if (lineIndexs.size() == 0) {
            return null;
        }
        info = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);

        int a1 = 0, b1 = 0, c1 = 0, d1 = 0, e1 = 0, f1 = 0;
        int a2 = 0, b2 = 0, c2 = 0, d2 = 0, e2 = 0, f2 = 0;
        int a3 = 0, b3 = 0, c3 = 0, d3 = 0, e3 = 0, f3 = 0;

        for (int i = 0; i < info.size(); i++) {
            float eventvalue = info.get(i).getEventvalue();
            float persisttime = info.get(i).getPersisttime() * 1000;

            if (eventvalue * 100 < 1) {
                if (persisttime < 20 && persisttime >= 10) {
                    a3++;
                } else if (persisttime < 100) {
                    b3++;
                } else if (persisttime < 200) {
                    c3++;
                } else if (persisttime < 400) {
                    d3++;
                } else if (persisttime < 1000) {
                    e3++;
                } else {
                    f3++;
                }
            } else if (eventvalue * 100 < 40) {
                if (persisttime < 20 && persisttime >= 10) {
                    a2++;
                } else if (persisttime < 100) {
                    b2++;
                } else if (persisttime < 200) {
                    c2++;
                } else if (persisttime < 400) {
                    d2++;
                } else if (persisttime < 1000) {
                    e2++;
                } else {
                    f2++;
                }
            } else if (eventvalue * 100 <= 70) {
                if (persisttime < 20 && persisttime >= 10) {
                    a1++;
                } else if (persisttime < 100) {
                    b1++;
                } else if (persisttime < 200) {
                    c1++;
                } else if (persisttime < 400) {
                    d1++;
                } else if (persisttime < 1000) {
                    e1++;
                } else {
                    f1++;
                }
            }
        }

        List<String> tmp1 = new ArrayList<>();
        List<String> tmp2 = new ArrayList<>();
        List<String> tmp3 = new ArrayList<>();

        tmp1.add("40~70%");
        tmp2.add("1~40%");
        tmp3.add("<1%");
        tmp1.add(String.valueOf(a1));
        tmp1.add(String.valueOf(b1));
        tmp1.add(String.valueOf(c1));
        tmp1.add(String.valueOf(d1));
        tmp1.add(String.valueOf(e1));
        tmp1.add(String.valueOf(f1));
        tmp2.add(String.valueOf(a2));
        tmp2.add(String.valueOf(b2));
        tmp2.add(String.valueOf(c2));
        tmp2.add(String.valueOf(d2));
        tmp2.add(String.valueOf(e2));
        tmp2.add(String.valueOf(f2));
        tmp3.add(String.valueOf(a3));
        tmp3.add(String.valueOf(b3));
        tmp3.add(String.valueOf(c3));
        tmp3.add(String.valueOf(d3));
        tmp3.add(String.valueOf(e3));
        tmp3.add(String.valueOf(f3));

        result.add(tmp1);
        result.add(tmp2);
        result.add(tmp3);
        return result;
    }

    @Override
    public Iec28 getIEC28(Date startTime, Date endTime, String area) {
        Iec28 result = new Iec28();
        List<List> data = new ArrayList<>();
        List<EventDataList> info;
        AreaGeneral areaGen;
        //判断用户是否拥有省级权限
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);

        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());

        if (lineIndexs.size() == 0) {
            return null;
        }
        info = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);

        int a1 = 0, b1 = 0, c1 = 0, d1 = 0, e1 = 0, f1 = 0, g1 = 0, h1 = 0;
        int a2 = 0, b2 = 0, c2 = 0, d2 = 0, e2 = 0, f2 = 0, g2 = 0, h2 = 0;
        int a3 = 0, b3 = 0, c3 = 0, d3 = 0, e3 = 0, f3 = 0, g3 = 0, h3 = 0;
        int a4 = 0, b4 = 0, c4 = 0, d4 = 0, e4 = 0, f4 = 0, g4 = 0, h4 = 0;
        int a5 = 0, b5 = 0, c5 = 0, d5 = 0, e5 = 0, f5 = 0, g5 = 0, h5 = 0;
        int a6 = 0, b6 = 0, c6 = 0, d6 = 0, e6 = 0, f6 = 0, g6 = 0, h6 = 0;
        int a7 = 0, b7 = 0, c7 = 0, d7 = 0, e7 = 0, f7 = 0, g7 = 0, h7 = 0;
        int a8 = 0, b8 = 0, c8 = 0, d8 = 0, e8 = 0, f8 = 0, g8 = 0, h8 = 0;
        int a9 = 0, b9 = 0, c9 = 0, d9 = 0, e9 = 0, f9 = 0, g9 = 0, h9 = 0;

        int m1 = 0, m2 = 0, m3 = 0, m4 = 0, m5 = 0, m6 = 0, m7 = 0, m8 = 0, m9 = 0;
        int n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, n6 = 0, n7 = 0, n8 = 0;
        for (int i = 0; i < info.size(); i++) {
            float eventvalue = info.get(i).getEventvalue();
            float persisttime = info.get(i).getPersisttime() * 1000;

            if (eventvalue * 100 < 10 && eventvalue * 100 >= 0) {
                m9++;
                if (persisttime > 20 && persisttime <= 100) {
                    a9++;
                    n1++;
                } else if (persisttime <= 250) {
                    b9++;
                    n2++;
                } else if (persisttime <= 500) {
                    c9++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d9++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e9++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f9++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g9++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h9++;
                    n8++;
                }
            } else if (eventvalue * 100 < 20) {
                m8++;
                if (persisttime > 20 && persisttime <= 100) {
                    a8++;
                    n1++;
                } else if (persisttime <= 250) {
                    b8++;
                    n2++;
                } else if (persisttime <= 500) {
                    c8++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d8++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e8++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f8++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g8++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h8++;
                    n8++;
                }
            } else if (eventvalue * 100 < 30) {
                m7++;
                if (persisttime > 20 && persisttime <= 100) {
                    a7++;
                    n1++;
                } else if (persisttime <= 250) {
                    b7++;
                    n2++;
                } else if (persisttime <= 500) {
                    c7++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d7++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e7++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f7++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g7++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h7++;
                    n8++;
                }
            } else if (eventvalue * 100 < 40) {
                m6++;
                if (persisttime > 20 && persisttime <= 100) {
                    a6++;
                    n1++;
                } else if (persisttime <= 250) {
                    b6++;
                    n2++;
                } else if (persisttime <= 500) {
                    c6++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d6++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e6++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f6++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g6++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h6++;
                    n8++;
                }
            } else if (eventvalue * 100 < 50) {
                m5++;
                if (persisttime > 20 && persisttime <= 100) {
                    a5++;
                    n1++;
                } else if (persisttime <= 250) {
                    b5++;
                    n2++;
                } else if (persisttime <= 500) {
                    c5++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d5++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e5++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f5++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g5++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h5++;
                    n8++;
                }
            } else if (eventvalue * 100 < 60) {
                m4++;
                if (persisttime > 20 && persisttime <= 100) {
                    a4++;
                    n1++;
                } else if (persisttime <= 250) {
                    b4++;
                    n2++;
                } else if (persisttime <= 500) {
                    c4++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d4++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e4++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f4++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g4++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h4++;
                    n8++;
                }
            } else if (eventvalue * 100 < 70) {
                m3++;
                if (persisttime > 20 && persisttime <= 100) {
                    a3++;
                    n1++;
                } else if (persisttime <= 250) {
                    b3++;
                    n2++;
                } else if (persisttime <= 500) {
                    c3++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d3++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e3++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f3++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g3++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h3++;
                    n8++;
                }
            } else if (eventvalue * 100 < 80) {
                m2++;
                if (persisttime > 20 && persisttime <= 100) {
                    a2++;
                    n1++;
                } else if (persisttime <= 250) {
                    b2++;
                    n2++;
                } else if (persisttime <= 500) {
                    c2++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d2++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e2++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f2++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g2++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h2++;
                    n8++;
                }
            } else if (eventvalue * 100 < 90) {
                m1++;
                if (persisttime > 20 && persisttime <= 100) {
                    a1++;
                    n1++;
                } else if (persisttime <= 250) {
                    b1++;
                    n2++;
                } else if (persisttime <= 500) {
                    c1++;
                    n3++;
                } else if (persisttime <= 1000) {
                    d1++;
                    n4++;
                } else if (persisttime <= 3000) {
                    e1++;
                    n5++;
                } else if (persisttime <= 20000) {
                    f1++;
                    n6++;
                } else if (persisttime <= 60000) {
                    g1++;
                    n7++;
                } else if (persisttime <= 180000) {
                    h1++;
                    n8++;
                }
            }
        }

        List<String> tmp1 = new ArrayList<>();
        List<String> tmp2 = new ArrayList<>();
        List<String> tmp3 = new ArrayList<>();
        List<String> tmp4 = new ArrayList<>();
        List<String> tmp5 = new ArrayList<>();
        List<String> tmp6 = new ArrayList<>();
        List<String> tmp7 = new ArrayList<>();
        List<String> tmp8 = new ArrayList<>();
        List<String> tmp9 = new ArrayList<>();

        tmp1.add("80<=U<90");
        tmp2.add("70<=U<80");
        tmp3.add("60<=U<70");
        tmp4.add("50<=U<60");
        tmp5.add("40<=U<50");
        tmp6.add("30<=U<40");
        tmp7.add("20<=U<30");
        tmp8.add("10<=U<20");
        tmp9.add("0<=U<10");
        tmp1.add(String.valueOf(a1));
        tmp1.add(String.valueOf(b1));
        tmp1.add(String.valueOf(c1));
        tmp1.add(String.valueOf(d1));
        tmp1.add(String.valueOf(e1));
        tmp1.add(String.valueOf(f1));
        tmp1.add(String.valueOf(g1));
        tmp1.add(String.valueOf(h1));
        tmp2.add(String.valueOf(a2));
        tmp2.add(String.valueOf(b2));
        tmp2.add(String.valueOf(c2));
        tmp2.add(String.valueOf(d2));
        tmp2.add(String.valueOf(e2));
        tmp2.add(String.valueOf(f2));
        tmp2.add(String.valueOf(g2));
        tmp2.add(String.valueOf(h2));
        tmp3.add(String.valueOf(a3));
        tmp3.add(String.valueOf(b3));
        tmp3.add(String.valueOf(c3));
        tmp3.add(String.valueOf(d3));
        tmp3.add(String.valueOf(e3));
        tmp3.add(String.valueOf(f3));
        tmp3.add(String.valueOf(g3));
        tmp3.add(String.valueOf(h3));
        tmp4.add(String.valueOf(a4));
        tmp4.add(String.valueOf(b4));
        tmp4.add(String.valueOf(c4));
        tmp4.add(String.valueOf(d4));
        tmp4.add(String.valueOf(e4));
        tmp4.add(String.valueOf(f4));
        tmp4.add(String.valueOf(g4));
        tmp4.add(String.valueOf(h4));
        tmp5.add(String.valueOf(a5));
        tmp5.add(String.valueOf(b5));
        tmp5.add(String.valueOf(c5));
        tmp5.add(String.valueOf(d5));
        tmp5.add(String.valueOf(e5));
        tmp5.add(String.valueOf(f5));
        tmp5.add(String.valueOf(g5));
        tmp5.add(String.valueOf(h5));
        tmp6.add(String.valueOf(a6));
        tmp6.add(String.valueOf(b6));
        tmp6.add(String.valueOf(c6));
        tmp6.add(String.valueOf(d6));
        tmp6.add(String.valueOf(e6));
        tmp6.add(String.valueOf(f6));
        tmp6.add(String.valueOf(g6));
        tmp6.add(String.valueOf(h6));
        tmp7.add(String.valueOf(a7));
        tmp7.add(String.valueOf(b7));
        tmp7.add(String.valueOf(c7));
        tmp7.add(String.valueOf(d7));
        tmp7.add(String.valueOf(e7));
        tmp7.add(String.valueOf(f7));
        tmp7.add(String.valueOf(g7));
        tmp7.add(String.valueOf(h7));
        tmp8.add(String.valueOf(a8));
        tmp8.add(String.valueOf(b8));
        tmp8.add(String.valueOf(c8));
        tmp8.add(String.valueOf(d8));
        tmp8.add(String.valueOf(e8));
        tmp8.add(String.valueOf(f8));
        tmp8.add(String.valueOf(g8));
        tmp8.add(String.valueOf(h8));
        tmp9.add(String.valueOf(a9));
        tmp9.add(String.valueOf(b9));
        tmp9.add(String.valueOf(c9));
        tmp9.add(String.valueOf(d9));
        tmp9.add(String.valueOf(e9));
        tmp9.add(String.valueOf(f9));
        tmp9.add(String.valueOf(g9));
        tmp9.add(String.valueOf(h9));

        data.add(tmp1);
        data.add(tmp2);
        data.add(tmp3);
        data.add(tmp4);
        data.add(tmp5);
        data.add(tmp6);
        data.add(tmp7);
        data.add(tmp8);
        data.add(tmp9);
        result.setData(data);

        List<MdSort> pertime = new ArrayList<>();
        MdSort tmp = new MdSort();
        tmp.setName("0.02~0.1s");
        tmp.setNumber(n1);
        pertime.add(tmp);
        tmp = new MdSort();
        tmp.setName("0.1~0.25s");
        tmp.setNumber(n2);
        pertime.add(tmp);
        tmp = new MdSort();
        tmp.setName("0.25~0.5s");
        tmp.setNumber(n3);
        pertime.add(tmp);
        tmp = new MdSort();
        tmp.setName("0.5~1s");
        tmp.setNumber(n4);
        pertime.add(tmp);
        tmp = new MdSort();
        tmp.setName("1~3s");
        tmp.setNumber(n5);
        pertime.add(tmp);
        tmp = new MdSort();
        tmp.setName("3~20s");
        tmp.setNumber(n6);
        pertime.add(tmp);
        tmp = new MdSort();
        tmp.setName("20~60s");
        tmp.setNumber(n7);
        pertime.add(tmp);
        tmp = new MdSort();
        tmp.setName("60~180s");
        tmp.setNumber(n8);
        pertime.add(tmp);
        Collections.sort(pertime, new Comparator<MdSort>() {
            /*
             * int compare(Person p1, Person p2) 返回一个基本类型的整型，
             * 返回负数表示：p1 小于p2，
             * 返回0 表示：p1和p2相等，
             * 返回正数表示：p1大于p2
             */
            @Override
            public int compare(MdSort p1, MdSort p2) {
                if (p2.getNumber() > p1.getNumber()) {
                    return 1;
                }
                if (p2.getNumber().equals(p1.getNumber())) {
                    return 0;
                }
                return -1;
            }
        });
        result.setPertime(pertime.get(0).getName());

        List<MdSort> eventvalue = new ArrayList<>();
        tmp = new MdSort();
        tmp.setName("80%~90%");
        tmp.setNumber(m1);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("70%~80%");
        tmp.setNumber(m2);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("60%~70%");
        tmp.setNumber(m3);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("50%~60%");
        tmp.setNumber(m4);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("40%~50%");
        tmp.setNumber(m5);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("30%~40%");
        tmp.setNumber(m6);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("20%~30%");
        tmp.setNumber(m7);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("10%~20%");
        tmp.setNumber(m8);
        eventvalue.add(tmp);
        tmp = new MdSort();
        tmp.setName("0~10%");
        tmp.setNumber(m9);
        eventvalue.add(tmp);
        Collections.sort(eventvalue, new Comparator<MdSort>() {
            /*
             * int compare(Person p1, Person p2) 返回一个基本类型的整型，
             * 返回负数表示：p1 小于p2，
             * 返回0 表示：p1和p2相等，
             * 返回正数表示：p1大于p2
             */
            @Override
            public int compare(MdSort p1, MdSort p2) {
                //按照Person的年龄进行升序排列
                if (p2.getNumber() > p1.getNumber()) {
                    return 1;
                }
                if (p2.getNumber() == p1.getNumber()) {
                    return 0;
                }
                return -1;
            }
        });
        result.setEventvalue(eventvalue.get(0).getName());
        return result;
    }

    @Override
    public EventChance getEventChance(Date startTime, Date endTime, String area) {
        EventChance result = new EventChance();
        List<EventDataList> info;
        AreaGeneral areaGen;
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);
        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());
        if (lineIndexs.size() == 0) {
            return null;
        }
        info = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);

        int totalnum = info.size();
        int persist1 = 0;
        int persist2 = 0;
        int persist3 = 0;
        int persist4 = 0;
        int value1 = 0;
        int value2 = 0;
        int value3 = 0;
        int value4 = 0;
        int value5 = 0;
        int value6 = 0;
        int value7 = 0;
        int value8 = 0;
        for (int i = 0; i < totalnum; i++) {
            float persisttime = info.get(i).getPersisttime();
            float eventValue = info.get(i).getEventvalue() * 100;

            if (persisttime < 0.100) {
                persist1++;
                persist2++;
                persist3++;
                persist4++;
            } else if (persisttime < 0.250) {
                persist2++;
                persist3++;
                persist4++;
            } else if (persisttime < 0.500) {
                persist3++;
                persist4++;
            } else if (persisttime < 1.000) {
                persist4++;
            }

            if (eventValue < 10) {
                value1++;
                value2++;
                value3++;
                value4++;
                value5++;
                value6++;
                value7++;
                value8++;
            } else if (eventValue < 20) {
                value2++;
                value3++;
                value4++;
                value5++;
                value6++;
                value7++;
                value8++;
            } else if (eventValue < 30) {
                value3++;
                value4++;
                value5++;
                value6++;
                value7++;
                value8++;
            } else if (eventValue < 40) {
                value4++;
                value5++;
                value6++;
                value7++;
                value8++;
            } else if (eventValue < 50) {
                value5++;
                value6++;
                value7++;
                value8++;
            } else if (eventValue < 60) {
                value6++;
                value7++;
                value8++;
            } else if (eventValue < 70) {
                value7++;
                value8++;
            } else if (eventValue < 80) {
                value8++;
            }
        }

        List<String> per = new ArrayList<>();
        List<String> val = new ArrayList<>();

        DecimalFormat df = new DecimalFormat("#.00");

        per.add(df.format((float) 0));
        per.add(df.format(((float) persist1 / (float) totalnum) * 100));
        per.add(df.format(((float) persist2 / (float) totalnum) * 100));
        per.add(df.format(((float) persist3 / (float) totalnum) * 100));
        per.add(df.format(((float) persist4 / (float) totalnum) * 100));
        per.add(df.format((float) 100));

        val.add(df.format((float) 0));
        val.add(df.format(((float) value1 / (float) totalnum) * 100));
        val.add(df.format(((float) value2 / (float) totalnum) * 100));
        val.add(df.format(((float) value3 / (float) totalnum) * 100));
        val.add(df.format(((float) value4 / (float) totalnum) * 100));
        val.add(df.format(((float) value5 / (float) totalnum) * 100));
        val.add(df.format(((float) value6 / (float) totalnum) * 100));
        val.add(df.format(((float) value7 / (float) totalnum) * 100));
        val.add(df.format(((float) value8 / (float) totalnum) * 100));
        val.add(df.format((float) 100));

        result.setEventvalue(val);
        result.setPersisttime(per);

        return result;
    }

    @Override
    public List<EventCause> getEventCause(Date startTime, Date endTime, String area) {
        List<EventCause> result = new ArrayList<>();
        List<EventDataList> typeresult;
        List<DicData> name;
        DicType type;
        AreaGeneral areaGen;
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);
        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());

        if (lineIndexs.size() == 0) {
            return null;
        }
        typeresult = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);
        String dicTypename = "暂降原因";
        type = dicDataTypeMapper.querybyname(dicTypename);
        name = dicDataMapper.selAll(type.getDicTypeIndex());

//		EventCause t1 = new EventCause();
//		EventCause t2 = new EventCause();
//		EventCause t3 = new EventCause();
//		EventCause t4 = new EventCause();
//
//		t1.setCause(name.get(3).getDicName());
//		t2.setCause(name.get(2).getDicName());
//		t3.setCause(name.get(1).getDicName());
//		t4.setCause(name.get(0).getDicName());

        for (DicData n : name) {
            EventCause t = new EventCause();
            t.setCause(n.getDicName());
            for (EventDataList r : typeresult) {
                if (r.getEventReason().equals(n.getDicName())) {
                    t.setCount(t.getCount() + 1);
                }
            }
            result.add(t);
        }

//		for (int i = 0; i < typeresult.size(); i++) {
//			if (typeresult.get(i).getEventReason() != null) {
//				if (typeresult.get(i).getEventReason().equals(name.get(3).getDicName())) {
//					t1.setCount(t1.getCount() + 1);
//				} else if (typeresult.get(i).getEventReason().equals(name.get(2).getDicName())) {
//					t2.setCount(t2.getCount() + 1);
//				} else if (typeresult.get(i).getEventReason().equals(name.get(1).getDicName())) {
//					t3.setCount(t3.getCount() + 1);
//				} else if (typeresult.get(i).getEventReason().equals(name.get(0).getDicName())) {
//					t4.setCount(t4.getCount() + 1);
//				}
//			}
//		}
//
//		result.add(t1);
//		result.add(t2);
//		result.add(t3);
//		result.add(t4);

        return result;
    }

    @Override
    public List<EventTypeList> getEventType(Date startTime, Date endTime, String area) {
        List<EventTypeList> result = new ArrayList<>();
        List<EventDataList> typeresult;
        List<DicData> name;
        DicType type;

        AreaGeneral areaGen;
        Depts deptsArea = userUtil.getDeptsByIndex(area);
        if (null == deptsArea) {
            return null;
        }
        //按区域查询数据
        areaGen = getAreas(startTime, endTime, deptsArea);

        List<Integer> lineIndexs = new ArrayList<>(areaGen.getLineIndexs());

        if (lineIndexs.size() == 0) {
            return null;
        }
        typeresult = eventdataMapper.areaEventDataList(lineIndexs, startTime, endTime);

        String dicTypename = "暂降类型";
        type = dicDataTypeMapper.querybyname(dicTypename);
        String typrid = type.getDicTypeIndex();
        name = dicDataMapper.selAll(type.getDicTypeIndex());

        EventTypeList t1 = new EventTypeList();
        EventTypeList t2 = new EventTypeList();
        EventTypeList t3 = new EventTypeList();
        EventTypeList t4 = new EventTypeList();

        t1.setType(name.get(3).getDicName());
        t2.setType(name.get(2).getDicName());
        t3.setType(name.get(1).getDicName());
        t4.setType(name.get(0).getDicName());

        for (int i = 0; i < typeresult.size(); i++) {
            if (typeresult.get(i).getEventType() != null) {
                if (typeresult.get(i).getEventType().equals(name.get(3).getDicName())) {
                    t1.setCount(t1.getCount() + 1);
                } else if (typeresult.get(i).getEventType().equals(name.get(2).getDicName())) {
                    t2.setCount(t2.getCount() + 1);
                } else if (typeresult.get(i).getEventType().equals(name.get(1).getDicName())) {
                    t3.setCount(t3.getCount() + 1);
                } else {
                    t4.setCount(t4.getCount() + 1);
                }
            }
        }

        result.add(t1);
        result.add(t2);
        result.add(t3);
        result.add(t4);

        return result;
    }

    @Override
    public DevMapInfo getDevMap(String area) {
        DevMapInfo result = new DevMapInfo();
        List<LineMaps> vdLists = new ArrayList<>();
        List<DeviceValue> devcount = new ArrayList<>();

        List<AreaGeneralData> areaGeneral = userUtil.getAreaDataByInfo(area);
        for (AreaGeneralData areaGeneralData : areaGeneral) {
            int oncount = 0;
            int offcount = 0;
            DeviceValue tmp = new DeviceValue();
            tmp.setName(areaGeneralData.getName());

            List<Integer> indexs = areaGeneralData.getLineIndexs();
            tmp.setAmounts(String.valueOf(indexs.size()));

            for (Integer index : indexs) {
                LineMaps linemap = new LineMaps();
                linemap.setLineindex(index);
                linemap = lineMapsMapper.selectOne(linemap);
                if (null == linemap) {
                    continue;
                }
                vdLists.add(linemap);
                if (linemap.getStatus().equals(1)) {
                    oncount++;
                } else {
                    offcount++;
                }
            }
            tmp.setOncount(oncount);
            tmp.setOffcount(offcount);
            devcount.add(tmp);
        }

        Collections.sort(devcount, new Comparator<DeviceValue>() {
            /*
             * int compare(Person p1, Person p2) 返回一个基本类型的整型，
             * 返回负数表示：p1 小于p2，
             * 返回0 表示：p1和p2相等，
             * 返回正数表示：p1大于p2
             */
            @Override
            public int compare(DeviceValue p1, DeviceValue p2) {
                //按照Person的年龄进行升序排列
                if (Integer.parseInt(p2.getAmounts()) > Integer.parseInt(p1.getAmounts())) {
                    return 1;
                }
                if (Integer.parseInt(p2.getAmounts()) == Integer.parseInt(p1.getAmounts())) {
                    return 0;
                }
                return -1;
            }
        });
        result.setMaps(vdLists);
        result.setOnline(devcount);
        return result;
    }

    @Override
    public BaseMap getBase(String jsonStr) {
        BaseMap baseMap = new BaseMap();
        try {
            //解析json
            JSONObject json_test = JSONObject.fromObject(jsonStr);
            String type = json_test.getString("type");
            String features = json_test.getString("features");
            JSONArray jsonObject = JSONArray.fromObject(features);
            List<BaseMapDetail> baseMapDetails = new ArrayList<>();
            for (int i = 0; i < jsonObject.size(); i++) {
                BaseMapDetail baseMapDetail = new BaseMapDetail();
                BaseMapDetailRVO baseMapDetailRVO = new BaseMapDetailRVO();
                BaseMapProperties baseMapProperties = new BaseMapProperties();
                String jsonDetail = jsonObject.get(i).toString();
                JSONObject jsonObjectDetail = JSONObject.fromObject(jsonDetail);
                String typeDeatil = jsonObjectDetail.getString("type");
                String properties = jsonObjectDetail.getString("properties");
                JSONObject jsonObjectPr = JSONObject.fromObject(properties);
                int childNum = jsonObjectPr.getInt("childNum");
                int id = jsonObjectPr.getInt("id");
                String name = jsonObjectPr.getString("name");
//            int size = jsonObjectPr.getInt("size");
                String[] cp = jsonObjectPr.getString("cp").replace("[", "").replace("]", "").split(",");
                float b[] = new float[cp.length];
                for (int a = 0; a < cp.length; a++) {
                    b[a] = Float.parseFloat(cp[a]);
                }
                baseMapProperties.setId(id);
                baseMapProperties.setName(name);
                baseMapProperties.setCp(b);
//            baseMapProperties.setSize(size);
                baseMapProperties.setChildNum(childNum);
                String geometry = jsonObjectDetail.getString("geometry");
                JSONObject jsonObjectGe = JSONObject.fromObject(geometry);
                String typege = jsonObjectGe.getString("type");
                JSONArray coordinates = jsonObjectGe.getJSONArray("coordinates");
                System.out.println(coordinates.get(0));
                baseMapDetailRVO.setType(typege);
                baseMapDetailRVO.setCoordinates(coordinates.get(0));
                baseMapDetail.setType(typeDeatil);
                baseMapDetail.setProperties(baseMapProperties);
                baseMapDetail.setGeometry(baseMapDetailRVO);
                baseMapDetails.add(baseMapDetail);
            }
            baseMap.setType(type);
            baseMap.setFeatures(baseMapDetails);
        } catch (Exception e) {
            logger.error("获取经纬度信息异常，异常为："+e.toString());
            return null;
        }
        return baseMap;
    }

    /**
     * xuyang
     * 根据监测点获取当前时间段暂降事件总数
     */
    public Integer getSuspendByMonitor(Date startTime, Date endTime, List<Integer> list){
        Integer result = 0;
        if (!list.isEmpty()) {
            if(list.size()>1000){
                int count = list.size()/1000+1;
                for(int i=0;i<count;i++){
                    Integer num = 0;
                    if(list.size()>=1000){
                        List<Integer> subLine = list.subList(0,1000);
                        num = eventDetailMapper.getSuspendByMonitor(startTime,endTime,subLine);
                        subLine.clear();
                    }else {
                        num = eventDetailMapper.getSuspendByMonitor(startTime,endTime,list);
                    }
                    result+=num;

                }
            }else {
                result = eventDetailMapper.getSuspendByMonitor(startTime,endTime,list);
            }

        }
        return result;
    }

}
