package com.casic.service.impl;

import com.casic.dao.cms.CmsDataMapper;
import com.casic.dao.smartwell.SmartwellDataMapper;
import com.casic.dao.spantilt.TiltDataMapper;
import com.casic.model.ResponseData;
import com.casic.service.ScreenDataService;
import com.casic.util.FormatUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.Calendar;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
@AllArgsConstructor
public class ScreenDataManger implements ScreenDataService {

    private final DeviceBuilder deviceBuilder;
    private final AlarmBulider alarmBulider;
    private final HealthIndexBuilder healthIndexBuilder;
    private final DeptTimeSpanBuilder deptTimeSpanBuilder;
    private final OperationalBuilder operationalBuilder;
    private final SmartwellDataMapper smartwellDataMapper;
    private final CmsDataMapper cmsDataMapper;
    private final TiltDataMapper tiltDataMapper;


    public Object getInstalledDevice(String beginTime, String endTime) {
        List<Map<String, Object>> installedDeviceList = null;
        try {
            installedDeviceList = deviceBuilder.InstalledDeviceManger();
        } catch (DataAccessException dex) {
            log.error("主题：查询已安装设备的类型和个数出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return installedDeviceList;
    }

    public Object getKindsAlarmRate(String beginTime, String endTime) {
        List<Map<String, String>> rateDeviceList = null;
        try {
            rateDeviceList = alarmBulider.alarmTypeManger(beginTime, endTime);
        } catch (DataAccessException dex) {
            log.error("主题：统计汇总各管线权属单位下的燃气管线总长度出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return rateDeviceList;
    }

    public Object getAlarmRecordsByStation(String beginTime, String endTime) {
        List<Map<String, Object>> recordsRoadList = null;
        try {
            recordsRoadList = tiltDataMapper.countColudAlarmRecords(beginTime, endTime);
        } catch (DataAccessException dex) {
            log.error("主题：显示云台的报警信息出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return recordsRoadList;
    }

    public Object getHealthIndicatorByRoad(String isSort, String limitNum, String beginTime, String endTime) {
        List<Map<String, Object>> healthRoadIndtorMap = null;
        try {
            healthRoadIndtorMap = healthIndexBuilder.healthRoadIndicatorProvider(isSort, limitNum, beginTime, endTime);
        } catch (DataAccessException dex) {
            log.error("主题：以道路维度查看健康指数出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return healthRoadIndtorMap;
    }

    public Object getDeptTimeSpan(String beginTime, String endTime) {
        List<Map<String, String>> deptTimeSpanList = null;
        try {
            deptTimeSpanList = deptTimeSpanBuilder.deptTimeSpanProvider(beginTime, endTime);
        } catch (DataAccessException dex) {
            log.error("主题：按权属单位来汇总，各个权属单位下的燃气管线连续正常运行的时长出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return deptTimeSpanList;
    }

    public Object getHealthIndicator(String beginTime, String endTime) {
        List<Map<String, Object>> healthIndictorList = null;
        try {
            healthIndictorList = healthIndexBuilder.healthIndicatorProvider(beginTime, endTime);
        } catch (DataAccessException dex) {
            log.error("主题：场地、燃气健康指数出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return healthIndictorList;
    }

    public Object getDeptIndicator(String beginTime, String endTime) {
        List<Map<String, Object>> healthIndictorList = null;
        try {
            healthIndictorList = healthIndexBuilder.deptIndicatorProvider(beginTime, endTime);
        } catch (DataAccessException dex) {
            log.error("主题：权属单位维度健康指数出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return healthIndictorList;
    }

    public Object getDeviceList(String beginTime, String endTime) {
        List<Map<String, Object>> alarmDeviceList = null;
        try {
            alarmDeviceList = smartwellDataMapper.getAlarmDeviceList();
            List<Map<String, String>> deptNameList = smartwellDataMapper.getDeptNameList();
            Map<String, Object> deptNameMap = deptNameList.stream().collect(
                    Collectors.toMap(e -> String.valueOf(e.get("id")), e -> String.valueOf(e.get("name")))
            );
            alarmDeviceList.forEach(
                    alarmDevice -> {
                        alarmDevice.put("isAlarm", alarmDevice.containsKey("isAlarm") ? "1" : "0");
                        alarmDevice.put("responsibleDept", deptNameMap.get(String.valueOf(alarmDevice.get("responsibleDept"))));
                    }
            );
        } catch (DataAccessException dex) {
            log.error("主题：场地、燃气健康指数出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return alarmDeviceList;
    }

    public Object getOperationalStatus(String beginTime, String endTime) {

        ResponseData responseData = new ResponseData();
        try {
            List<Map<String, String>> operaStatusList = operationalBuilder.OperationalStatusProvider(beginTime, endTime);
            responseData.setSuccess(true);
            responseData.setCode(200);
            responseData.setMessage("查询成功");
            responseData.setData(operaStatusList);
        } catch (DataAccessException dex) {
            log.error("主题：运维情况查询出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
            responseData.setCode(500);
            responseData.setMessage("查询异常");
        }
        return responseData;
    }


    public Object getAlarmRecordsByRoad(String beginTime, String endTime) {
        List<Map<String, String>> rateDeviceList = null;
        try {
            //默认统计本年度的所有报警次数，开始时间默认本年度第一天
            beginTime =  FormatUtil.getYearFirst();
            rateDeviceList = smartwellDataMapper.countAlarmByRoad("'"+beginTime+"'", endTime);
        } catch (DataAccessException dex) {
            log.error("主题：以道路的维度统计燃气管线监控中的报警情况出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return rateDeviceList;
    }

    public Object getInspectRoad(String beginTime, String endTime) {
        List<Map<String, String>> rateDeviceList = null;
        try {
            rateDeviceList = cmsDataMapper.countElectronicTask();
        } catch (DataAccessException dex) {
            log.error("主题：汇总显示个道路的巡检运维次数出现数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return rateDeviceList;
    }

    public Object getAlarmNum() {
        List<Map<String, Object>> alarmNumList = null;
        try {
            alarmNumList = alarmBulider.alarmsByDay();
        } catch (DataAccessException dex) {
            log.error("主题：七天报警出现数据异常,异常信息{}", dex);
        }
        return alarmNumList;
    }

    public Object getJobByDay(String beginTime, String endTime) {
        List<Map<String, Object>> jobList = null;
        try {
            jobList = alarmBulider.jobsByDeptManger(beginTime, endTime);
        } catch (DataAccessException dex) {
            log.error("主题：30天工单数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return jobList;
    }

    public Object getDeviceNum(String beginTime, String endTime) {
        List<Map<String, String>> deviceNumList = null;
        try {
            deviceNumList = deviceBuilder.DeviceNumMangger();
        } catch (DataAccessException dex) {
            log.error("主题：各权属单位设备数据异常,开始时间{},结束时间{},异常信息{}", beginTime, endTime, dex);
        }
        return deviceNumList;
    }
}