package com.whyc.service;

import com.whyc.dto.AlarmDaoFactory;
import com.whyc.dto.Response;
import com.whyc.mapper.CommonMapper;
import com.whyc.mapper.CustomMapper;
import com.whyc.pojo.BattalarmDataHistory;
import com.whyc.pojo.DevalarmDataHistory;
import com.whyc.pojo.PwrdevAlarmHistory;
import com.whyc.util.DateUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.ParseException;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class AlarmHistoryService {

    @Autowired
    private BattalarmDataHistoryService battAlarmService;
    @Autowired
    private DevalarmDataHistoryService deviceAlarmService;
    @Autowired
    private PwrdevAlarmHistoryService powerAlarmService;

    @Resource
    private CommonMapper commonMapper;

    public Response getAlarmStatistics(Date startTime, Date endTime, String stationId) throws ParseException {
        Map<String,Object> resMap = new HashMap<>();
        //电池/设备专用-按月分表
        Map<String, List<Date>> tableMap = DateUtil.getQueryTimeForSubTablesByMonthDesc(startTime, endTime);
        Set<String> monthSet = tableMap.keySet();
        //电源专用-按年分表
        Map<String, List<Date>> powerTableMap = DateUtil.getQueryTimeForSubTablesDesc(startTime, endTime);
        Set<String> powerYearSet = powerTableMap.keySet();
        List<BattalarmDataHistory> battList = new LinkedList<>();
        List<DevalarmDataHistory> deviceList =  new LinkedList<>();
        List<PwrdevAlarmHistory> powerList =  new LinkedList<>();
        //电池/设备
        for (String month : monthSet) {
            String battTableName;
            String deviceTableName;
            if(month.equals("default")){
                battTableName = "tb_battalarm_data_history";
                deviceTableName = "tb_devalarm_data_history";
            }else{
                battTableName = "tb_battalarm_data_history_"+month;
                deviceTableName = "tb_devalarm_data_history_"+month;
            }
            List<Date> dates = tableMap.get(month);
            String existTableNameBatt = commonMapper.existTable("db_alarm", battTableName);
            if(existTableNameBatt != null){
                List<BattalarmDataHistory> battTemp =  battAlarmService.getListByStationId(dates.get(0),dates.get(1),stationId,battTableName);
                battList.addAll(battTemp);
            }
            String existTableNameDevice = commonMapper.existTable("db_alarm", deviceTableName);
            if(existTableNameDevice != null){
                List<DevalarmDataHistory> deviceTemp =  deviceAlarmService.getListByStationId(dates.get(0),dates.get(1),stationId,deviceTableName);
                deviceList.addAll(deviceTemp);
            }

        }
        //电源
        for (String year : powerYearSet) {
            String powerTableName;
            if(year.equals("default")){
                powerTableName = "tb_pwrdev_alarm_history";
            }else{
                powerTableName = "tb_pwrdev_alarm_history_"+year;
            }
            List<Date> dates = powerTableMap.get(year);
            String existTableNamePower= commonMapper.existTable("db_pwrdev_alarm", powerTableName);
            if(existTableNamePower != null){
                List<PwrdevAlarmHistory> powerTemp =  powerAlarmService.getListByStationId(dates.get(0),dates.get(1),stationId,powerTableName);
                powerList.addAll(powerTemp);
            }

        }
        if(battList.size()!=0) {
            Map<String, Map<Integer, BattalarmDataHistory>> battResMap = new HashMap<>();
            battList.forEach(t->{
                if(t.getAlmSeverity()==null){ //查询为空,默认为0-重要
                    t.setAlmSeverity(0);
                }
            });
            Map<Integer, List<BattalarmDataHistory>> battMap = battList.stream().collect(Collectors.groupingBy(BattalarmDataHistory::getAlmSignalId));
            Set<Integer> battAlarmSignalIdSet = battMap.keySet();

            //电池告警id
            for (Integer battAlarmSignalId : battAlarmSignalIdSet) {
                //告警紧急程度
                List<BattalarmDataHistory> battAlarmList = battMap.get(battAlarmSignalId);
                Map<Integer, List<BattalarmDataHistory>> battListMap = battAlarmList.stream().collect(Collectors.groupingBy(BattalarmDataHistory::getAlmSeverity));
                Set<Integer> severitySet = battListMap.keySet();
                Map<Integer, BattalarmDataHistory> batt2Map = new HashMap<>();
                for (Integer severity : severitySet) {
                    List<BattalarmDataHistory> temp = battListMap.get(severity);
                    int size = temp.size();
                    Integer almLevel = temp.get(0).getAlmLevel();
                    Integer almSeverity = temp.get(0).getAlmSeverity();

                    BattalarmDataHistory history = new BattalarmDataHistory();
                    history.setAlmLevel(almLevel);
                    history.setAlmSeverity(almSeverity);
                    history.setNum((long) size);
                    batt2Map.put(severity,history);

                }
                battResMap.put(AlarmDaoFactory.getAllAlarmName(battAlarmSignalId), batt2Map);
            }

            resMap.put("batt", battResMap);
        }else{
            resMap.put("batt",null);
        }

        if(deviceList.size()!=0) {
            Map<String, Map<Integer, DevalarmDataHistory>> deviceResMap = new HashMap<>();
            deviceList.forEach(t->{
                if(t.getAlmSeverity()==null){ //查询为空,默认为0-重要
                    t.setAlmSeverity(0);
                }
            });
            Map<Integer, List<DevalarmDataHistory>> deviceMap = deviceList.stream().collect(Collectors.groupingBy(DevalarmDataHistory::getAlmType));
            Set<Integer> deviceAlarmTypeSet = deviceMap.keySet();

            //告警type
            for (Integer deviceAlarmType : deviceAlarmTypeSet) {
                List<DevalarmDataHistory> deviceAlarmList = deviceMap.get(deviceAlarmType);
                Map<Integer, List<DevalarmDataHistory>> deviceListMap = deviceAlarmList.stream().collect(Collectors.groupingBy(DevalarmDataHistory::getAlmSeverity));
                Set<Integer> severitySet = deviceListMap.keySet();
                Map<Integer,DevalarmDataHistory> deviceMap2 = new HashMap<>();
                for (Integer severity : severitySet) {
                    List<DevalarmDataHistory> temp = deviceListMap.get(severity);
                    int size = temp.size();
                    Integer almLevel = temp.get(0).getAlmLevel();
                    Integer almSeverity = temp.get(0).getAlmSeverity();
                    DevalarmDataHistory history = new DevalarmDataHistory();
                    history.setAlmLevel(almLevel);
                    history.setAlmSeverity(almSeverity);
                    history.setNum((long) size);

                    deviceMap2.put(severity,history);
                }
                deviceResMap.put(AlarmDaoFactory.getAllAlarmName(deviceAlarmType), deviceMap2);

            }

            resMap.put("device", deviceResMap);
        }else{
            resMap.put("device",null);
        }

        if(powerList.size()!=0) {
            Map<String, Map<Integer, PwrdevAlarmHistory>> powerResMap = new HashMap<>();
            powerList.forEach(t->{
                if(t.getAlmSeverity()==null){ //查询为空,默认为0-重要
                    t.setAlmSeverity(0);
                }
            });
            Map<Integer, List<PwrdevAlarmHistory>> powerMap = powerList.stream().collect(Collectors.groupingBy(PwrdevAlarmHistory::getAlmType));
            Set<Integer> powerAlarmTypeSet = powerMap.keySet();

            for (Integer powerAlarmType : powerAlarmTypeSet) {
                List<PwrdevAlarmHistory> powerAlarmList = powerMap.get(powerAlarmType);
                Map<Integer, List<PwrdevAlarmHistory>> powerListMap = powerAlarmList.stream().collect(Collectors.groupingBy(PwrdevAlarmHistory::getAlmSeverity));
                Set<Integer> severityMap = powerListMap.keySet();
                Map<Integer,PwrdevAlarmHistory> powerMap2 = new HashMap<>();
                for (Integer severity : severityMap) {
                    List<PwrdevAlarmHistory> temp = powerListMap.get(severity);
                    int size = temp.size();
                    Integer almLevel = temp.get(0).getAlmLevel();
                    Integer almSeverity = temp.get(0).getAlmSeverity();

                    PwrdevAlarmHistory history = new PwrdevAlarmHistory();
                    history.setAlmLevel(almLevel);
                    history.setAlmSeverity(almSeverity);
                    history.setNum((long) size);
                    powerMap2.put(severity,history);
                }

                powerResMap.put(AlarmDaoFactory.getAllAlarmName(powerAlarmType), powerMap2);

            }

            resMap.put("power", powerResMap);
        }else{
            resMap.put("power",null);
        }
        return new Response().set(1,resMap);

    }
}