package com.tofly.xrtygis.controller.home;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tofly.api.UserTaskClient;
import com.tofly.common.core.entity.ResultRespone;
import com.tofly.common.core.util.StringUtil;
import com.tofly.common.oauth.util.SecurityUtils;
import com.tofly.pojo.message.Usertask;
import com.tofly.xrtygis.custom.util.DateTimeUtil;
import com.tofly.xrtygis.em.Constant;
import com.tofly.xrtygis.em.UserTaskTypeEnum;
import com.tofly.xrtygis.entity.dto.MeterReadingNumberDto;
import com.tofly.xrtygis.entity.dto.WarnInfoDto;
import com.tofly.xrtygis.entity.vo.*;
import com.tofly.xrtygis.service.WarnService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 首页-接口信息
 *
 * @author BZ-DJJ
 */
@RestController
@RequestMapping("/homeInformation")
@Api(tags = "首页接口信息")
@Slf4j
public class HomeInformationController {
    @Autowired
    private UserTaskClient userTaskClient;
    @Autowired
    private WarnService warnService;

    /**
     * 调用BASE模块 提供待办事项待完成数量统计 及 待办事项未开始的数量统计(根据时间范围处理) 及超时统计
     *
     * @return
     */
    @ApiOperation(value = "获取待办事项统计信息(所有)")
    @GetMapping("/getCommissionStatisticalInfo")
    public ResultRespone<TodoStatisticalInfoVo> getCommissionStatisticalInfo() {
        ResultRespone<TodoStatisticalInfoVo> resultRespone = new ResultRespone<>();
        // 获取传入用户下 任务
        Usertask dto = new Usertask();
        dto.setHandleUser(SecurityUtils.getUserId());

        List<Usertask> list = userTaskClient.getUserTaskInfo(dto).getResult();
        if (null != list && list.size() > 0) {
            // 巡检超时去掉
            List<Usertask> collect = list.stream()
                    .filter(u-> StringUtil.isNotBlank(u.getTkty()))
                    .filter(u -> !(u.getTkty().equals("2") && u.getIshandle().equals("3"))).collect(Collectors.toList());
            // 区分出未开始对象数量
            long count = collect.stream().filter(info -> "2".equals(info.getIshandle())).count();
            // 超时工单发现有3和4的情况
            //long count1 = collect.stream().filter(info -> "4".equals(info.getIshandle()) || "3".equals(info.getIshandle())).count();
            long count1 = collect.stream().filter(info -> "4".equals(info.getIshandle())).count();

            long count2 = collect.stream().filter(info -> "0".equals(info.getIshandle())).count();
            TodoStatisticalInfoVo vo = new TodoStatisticalInfoVo();
            vo.setNotStartedNum(count);
            vo.setOverTimeNum(count1);
            vo.setPendingNum(count2);
            resultRespone.setResult(vo);
            resultRespone.setCode(1);
        }

        return resultRespone;
    }

    @ApiOperation(value = "根据代办类型类型获取对应待办事项分组信息(所有)")
    @GetMapping("/getTypeDistributionInfo")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "isHandle", value = "代办类型(0待完成，1已完成,2未开始,3已超时,4已超时待完成)", required = true, dataType = "String"),
    })
    public ResultRespone<List<TypeDistributionVo>> getTypeDistributionInfo(String isHandle) {
        List<TypeDistributionVo> voList = new ArrayList<>();
        ResultRespone<List<TypeDistributionVo>> resultRespone = new ResultRespone<>();
        List<String> isHandleList = Arrays.stream(isHandle.split(Constant.CSV))
                .collect(Collectors.toList());
        isHandleList.forEach(type->{
            Usertask dto = new Usertask();
            dto.setHandleUser(SecurityUtils.getUserId());
            dto.setIshandle(type);
            // 根据传入消息状态 获取对应消息列表数据
            List<Usertask> result = userTaskClient.getUserTaskInfo(dto).getResult();
            if (null != result && result.size() > 0) {
                // 再以消息类型分组
                Map<String, List<Usertask>> collect = result.stream().filter(info->null!=info.getTkty()).collect(Collectors.groupingBy(Usertask::getTkty));
                collect.forEach((k, v) -> {
                    // 若是巡检类型 且超时的需要过滤
                    if(!(k.equals("2") && type.equals("3"))){
                        TypeDistributionVo vo = new TypeDistributionVo();
                        String name = UserTaskTypeEnum.getCodeForValue(k);
                        String route = UserTaskTypeEnum.getCodeForRoute(k);
                        vo.setTypeCode(k);
                        vo.setTypeName(name);
                        vo.setRoute(route);
                        vo.setNum(v.size());
                        voList.add(vo);
                    }
                });
            }
        });

        resultRespone.setCode(1);
        resultRespone.setResult(voList);
        return resultRespone;
    }



    /**
     * 调用GIS模块  调用获取报警列表 分页查询按照报警时间降序排列
     */
    @ApiOperation(value = "获取首页报警分页数据(处理接口已存在大屏展示 /bigScreen/handleWarn)")
    @GetMapping("/getAlarmInformation")
    public ResultRespone<Page<WarnInfoVo>> getAlarmInformation(Page page, @ModelAttribute WarnInfoDto dto) {
        return ResultRespone.success(warnService.getHomeAlarmInformation(page, dto));
    }

    /**
     * 营销 - 抄表
     */
    @ApiOperation(value = "营销 - 抄表(按月统计)")
    @GetMapping("/getMeterReadingMonthNum")
    public ResultRespone<MeterReadingNumberVo> getMeterReadingMonthNum() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
        dto.setEndTime(DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime()))));
//        dto.setUserId(SecurityUtils.getUserId());
        log.info("获取首页抄表数: 统计月份: {}",dto.getStartTime().getMonth()+1);
        return ResultRespone.success(warnService.getMeterReadingMonthNum(dto));
    }

    /**
     * 营销 - 工单
     */
    @ApiOperation(value = "营销 - 工单(按月统计)")
    @GetMapping("/getRepairOrderNum")
    public ResultRespone<RepairOrderNumberVo> getRepairOrderNum() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
        dto.setEndTime(DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime()))));
//        dto.setUserId(SecurityUtils.getUserId());
        log.info("获取首页营销 工单: 统计月份: {}",dto.getStartTime().getMonth()+1);
        return ResultRespone.success(warnService.getRepairOrderNum(dto));
    }

    /**
     * 首页-营销模块 表务管理(不包括水表厂家对应水表数)
     */
    @ApiOperation(value = "首页 - 营销模块 表务管理(不包括水表厂家对应水表数)(所有)")
    @GetMapping("/getWaterMeterNumberNum")
    public ResultRespone<WaterMeterNumberVo> getWaterMeterNumberNum() {
        return ResultRespone.success(warnService.getWaterMeterNumberNum());
    }


    /**
     * 首页-营销模块 表务管理(水表厂家对应水表数)
     */
    @ApiOperation(value = "首页 - 营销模块 水表厂家对应水表数(所有)")
    @GetMapping("/getWaterMeterEnterprise")
    public ResultRespone<List<WaterMeterEnterpriseVo>> getWaterMeterEnterprise() {
        return ResultRespone.success(warnService.getWaterMeterEnterprise());
    }

    /**
     * 首页-营销模块 对应厂家 入库总数
     */
    @ApiOperation(value = "首页 - 营销 对应厂家 入库总数(所有)")
    @GetMapping("/getWaterMeterPut")
    public ResultRespone<List<WaterMeterPutStorageStatisticalVo>> getWaterMeterPutStorageStatistical() {
        return ResultRespone.success(warnService.getWaterMeterPutStorageStatistical());
    }

    /**
     * 首页-营销模块 对应厂家 安装总数
     */
    @ApiOperation(value = "首页 - 营销模块 对应厂家 安装总数(所有)")
    @GetMapping("/getWaterMeterInstall")
    public ResultRespone<List<WaterMeterInstallationStatisticalVo>> getWaterMeterInstallationStatistical() {
        return ResultRespone.success(warnService.getWaterMeterInstallationStatistical());
    }

    /**
     * 首页-营销模块 对应厂家 出库总数
     */
    @ApiOperation(value = "首页 - 营销模块 对应厂家 出库总数(所有)")
    @GetMapping("/getWaterMeterOutbound")
    public ResultRespone<List<WaterMeterOutboundStatisticalVo>> getWaterMeterOutboundStatistical() {
        return ResultRespone.success(warnService.getWaterMeterOutboundStatistical());
    }

    /**
     * 首页-营销模块 对应厂家 报废总数(旧表移交算报废)
     */
    @ApiOperation(value = "首页 - 营销模块 对应厂家 报废总数(旧表移交算报废)(所有)")
    @GetMapping("/getWaterMeterOld")
    public ResultRespone<List<WaterMeterOldTransferStatisticalVo>> getWaterMeterOldTransferStatistical() {
        return ResultRespone.success(warnService.getWaterMeterOldTransferStatistical());
    }

    /**
     * 首页-营销模块 对应厂家 故障拆检
     */
    @ApiOperation(value = "首页 - 营销模块 对应厂家 故障拆检(所有)")
    @GetMapping("/getWaterMeteFault")
    public ResultRespone<List<WaterMeteFaultTableStatisticalVo>> getWaterMeteFaultTableStatistical() {
        return ResultRespone.success(warnService.getWaterMeteFaultTableStatistical());
    }

    /**
     * 首页-营销模块 对应厂家 周检总数
     */
    @ApiOperation(value = "首页 - 营销模块 对应厂家 周检总数(所有)")
    @GetMapping("/getWaterMeteWeekly")
    public ResultRespone<List<WaterMeteWeeklyCheckStatisticalVo>> getWaterMeteWeeklyCheckStatistical() {
        return ResultRespone.success(warnService.getWaterMeteWeeklyCheckStatistical());
    }

    /**
     * 首页 - 管线模块 当月巡检统计数据
     */
    @ApiOperation(value = "首页 - 管线模块 当月巡检统计数据(除抢维修)(按月统计)")
    @GetMapping("/getNowMonthInspectionStatistical")
    public ResultRespone<List<InspectionTypeStatisticalVo>> getNowMonthInspectionStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
        dto.setEndTime(DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime()))));
        log.info("获取当月巡检统计数据(除抢维修): 统计月份: {}",dto.getStartTime().getMonth()+1);
        return ResultRespone.success(warnService.getNowMonthInspectionStatistical(dto));
    }

    /**
     * 首页 - 管线模块 巡检统计所有隐患/工地数据
     */
    @ApiOperation(value = "首页 - 管线模块 巡检统计所有隐患/工地数据(所有)")
    @GetMapping("/getAllInspectionStatistical")
    public ResultRespone<InspectionStatisticalVo> getAllInspectionStatistical() {
        return ResultRespone.success(warnService.getInspectionStatistical());
    }

    /**
     * 首页 - 管线模块 当日巡检统计数据
     */
    @ApiOperation(value = "首页 - 管线模块 当日巡检统计数据(除抢维修)(按日统计)")
    @GetMapping("/getNowMonthInspectionDayStatistical")
    public ResultRespone<List<InspectionTypeStatisticalVo>> getNowMonthInspectionDayStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayBeginTime()));
        dto.setEndTime(DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayEndTime()));
        log.info("获取当日巡检统计数据(除抢维修): 统计日期: {}",dto.getStartTime().getDay());
        return ResultRespone.success(warnService.getNowMonthInspectionDayStatistical(dto));
    }

    /**
     * 首页 - 管线模块 巡检统计人数相关数据
     */
    @ApiOperation(value = "首页 - 管线模块 巡检统计人数相关数据")
    @GetMapping("/getInspectionUserStateNum")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "flag", value = "不传则默认为日统计,传1为月统计", required = false, dataType = "String"),
    })
    public ResultRespone<InspectionUserStateStatisticalVo> getInspectionUserStateNum(String flag) {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        if(StringUtils.isEmpty(flag)){
            dto.setStartTime(DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayBeginTime()));
            dto.setEndTime(DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayEndTime()));
            log.info("巡检统计人数相关数据: 统计日期: {}",dto.getStartTime().getDay());
        }else {
            dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
            dto.setEndTime(DateTimeUtil
                    .convertLDTToDate(DateTimeUtil
                            .getAssignTodayEndTime(DateTimeUtil
                                    .fromLong2LocalDateTime(DateTimeUtil
                                            .localDateToDate(DateTimeUtil
                                                    .getLastDayOfCurrentMonth()).getTime()))));
            log.info("巡检统计人数相关数据: 统计月份: {}",dto.getStartTime().getMonth()+1);
        }
        return ResultRespone.success(warnService.getInspectionUserStateNum(dto));
    }

    /**
     * 首页 - 管线模块抢维修工单统计
     */
    @ApiOperation(value = "首页 - 管线模块 抢维修工单统计(按月统计)")
    @GetMapping("/getRepairOrderStatistical")
    public ResultRespone<List<RepairOrderStatisticalVo>> getRepairOrderStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
        dto.setEndTime(DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime()))));
        log.info("获取抢维修工单统计: 统计月份: {}",dto.getStartTime().getMonth()+1);
        return ResultRespone.success(warnService.getRepairOrderStatistical(dto));
    }

    /**
     * 首页 - 管线模块 各片区管线分布统计数据
     */
    @ApiOperation(value = "首页 - 管线模块 各片区管线分布统计数据(所有)")
    @GetMapping("/getGroupAreaPipeLengthStatistical")
    public ResultRespone<List<GroupAreaPipeLengthStatisticalVo>> getGroupAreaPipeLengthStatistical() {
        return ResultRespone.success(warnService.getGroupAreaPipeLengthStatistical());
    }

    /**
     * 首页-管网 管线材质统计情况
     */
    @ApiOperation(value = "首页-管网 管线材质统计情况(所有)")
    @GetMapping("/getPipeMaterialStatistical")
    public ResultRespone<List<PipeMaterialStatisticalVo>> getPipeMaterialStatistical() {
        return ResultRespone.success(warnService.getPipeMaterialStatistical());
    }

    /**
     *  首页-管网 管线管径统计情况(所有)
     */
    @ApiOperation(value = "首页-管网 管线管径统计情况(所有)")
    @GetMapping("/getPipeCaliberCensus")
    public ResultRespone<List<PipeMaterialStatisticalVo>> getPipeCaliberCensus() {
        return ResultRespone.success(warnService.getPipeCaliberCensus());
    }

    /**
     * 首页-营销 质量管理 按认证类型进行统计(年统计)
     */
    @ApiOperation(value = "首页-营销 质量管理 按认证类型进行统计(年统计)")
    @GetMapping("/getQualityCertification")
    public ResultRespone<List<QualityCertificationStatisticalVo>> getQualityCertificationStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentYear()));
        dto.setEndTime(DateTimeUtil.localDateToDate(DateTimeUtil.getLastDayOfCurrentYear()));
        log.info("质量管理 按认证类型进行统计(年统计): 统计年份: {}",dto.getStartTime().getYear());
        return ResultRespone.success(warnService.getQualityCertificationStatistical(dto));
    }

    /**
     * 首页-营销 质量管理 合格数/合格率-超时数/超时率(年统计)
     */
    @ApiOperation(value = "首页-营销 质量管理 合格数/合格率-超时数/超时率(年统计)")
    @GetMapping("/getQualityQualifiedTimeout")
    public ResultRespone<QualityQualifiedTimeoutStatisticalVo> getQualityQualifiedTimeoutStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentYear()));
        dto.setEndTime(DateTimeUtil.localDateToDate(DateTimeUtil.getLastDayOfCurrentYear()));
        log.info("质量管理 合格数/合格率-超时数/超时率(年统计): 统计年份: {}",dto.getStartTime().getYear());
        return ResultRespone.success(warnService.getQualityQualifiedTimeoutStatistical(dto));
    }

    /**
     * 首页-营销 质量管理 整改成效类别 分组 统计社会/经济效益 (年统计)
     */
    @ApiOperation(value = "首页-营销 质量管理 整改成效类别 分组 统计社会/经济效益 (年统计)")
    @GetMapping("/getQualityBenefit")
    public ResultRespone<List<QualityBenefitStatisticalVo>> getQualityBenefitStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentYear()));
        dto.setEndTime(DateTimeUtil.localDateToDate(DateTimeUtil.getLastDayOfCurrentYear()));
        log.info("质量管理 整改成效类别 分组 统计社会/经济效益 (年统计): 统计年份: {}",dto.getStartTime().getYear());
        return ResultRespone.success(warnService.getQualityBenefitStatistical(dto));
    }

    /**
     * 首页-热线管理系统 呼入呼损(按月统计)
     */
    @ApiOperation(value = "首页-热线管理系统 呼入呼损(按月统计)")
    @GetMapping("/getHotlineTrafficFlow")
    public ResultRespone<HotlineInboundLossStatisticalVo> getHotlineTrafficFlowStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
        dto.setEndTime(DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime()))));
        log.info("热线管理系统 呼入呼损(按月统计) : 统计月份: {}",dto.getStartTime().getMonth()+1);
        return ResultRespone.success(warnService.getHotlineTrafficFlowStatistical(dto));
    }

    /**
     * 首页-热线管理系统 呼出呼损(按月统计)
     */
    @ApiOperation(value = "首页-热线管理系统 呼出呼损(按月统计)")
    @GetMapping("/getHotlineOutLoss")
    public ResultRespone<HotlineOutLossStatisticalVo> getHotlineOutLossStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
        dto.setEndTime(DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime()))));
        log.info("热线管理系统 呼出呼损(按月统计) : 统计月份: {}",dto.getStartTime().getMonth()+1);
        return ResultRespone.success(warnService.getHotlineOutLossStatistical(dto));
    }

    /**
     * 首页-热线管理系统 满意度(按月统计)
     */
    @ApiOperation(value = "首页-热线管理系统 满意度(按月统计)")
    @GetMapping("/getHotlineSatisfaction")
    public ResultRespone<HotlineSatisfactionStatisticalVo> getHotlineSatisfactionStatistical() {
        MeterReadingNumberDto dto = new MeterReadingNumberDto();
        dto.setStartTime(DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth()));
        dto.setEndTime(DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime()))));
        log.info("热线管理系统 满意度(按月统计) : 统计月份: {}",dto.getStartTime().getMonth()+1);
        return ResultRespone.success(warnService.getHotlineSatisfactionStatistical(dto));
    }

    /**
     * 首页-生产运营 产销差 显示本年度累计值与预算值占比饼状图
     */
    @ApiOperation(value = "首页-生产运营 产销差 显示本年度累计值与预算值占比饼状图(按年统计)")
    @GetMapping("/getProductionMarketingPoor")
    public ResultRespone<ProductionMarketingPoorStatisticalVo> getProductionMarketingPoorStatistical() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("生产运营 产销差 显示本年度累计值与预算值占比饼状图 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getProductionMarketingPoorStatistical(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 产销差 显示本年度各月完成累计值/预算值情况
     */
    @ApiOperation(value = "首页-生产运营 产销差 显示本年度各月完成累计值/预算值情况(按年统计)")
    @GetMapping("/getProductionMarketingPoorMonth")
    public ResultRespone<List<ProductionMarketingPoorMonthVo>> getProductionMarketingPoorMonth() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("产销差 显示本年度各月完成累计值/预算值情况 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getProductionMarketingPoorMonth(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 漏损率 显示本年度累计值与预算值占比饼状图
     */
    @ApiOperation(value = "首页-生产运营 漏损率 显示本年度累计值与预算值占比饼状图(按年统计)")
    @GetMapping("/getLeakage")
    public ResultRespone<LeakageStatisticalVo> getLeakageStatistical() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("漏损率 显示本年度累计值与预算值占比饼状图 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getLeakageStatistical(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 漏损率 显示本年度各月完成累计值/预算情况
     */
    @ApiOperation(value = "首页-生产运营 漏损率 显示本年度各月完成累计值/预算情况(按年统计)")
    @GetMapping("/getLeakageMonth")
    public ResultRespone<List<LeakageMonthVo>> getLeakageMonth() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("漏损率 显示本年度各月完成累计值/预算情况 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getLeakageMonth(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 供水量售水量 显示本年度各月完成累计值/预算情况
     */
    @ApiOperation(value = "首页-生产运营 供水量售水量 显示本年度各月完成累计值/预算情况(按年统计)")
    @GetMapping("/getFeedSale")
    public ResultRespone<FeedSaleStatisticalVo> getFeedSaleStatistical() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("供水量售水量 显示本年度各月完成累计值/预算情况 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getFeedSaleStatistical(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 供水量售水量 显示本年度供水量售水量累计值与预算值占比饼状图
     */
    @ApiOperation(value = "首页-生产运营 供水量售水量 显示本年度供水量售水量累计值与预算值占比饼状图(按年统计)")
    @GetMapping("/getFeedSaleMonth")
    public ResultRespone<List<FeedSaleMonthVo>> getFeedSaleMonth() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("供水量售水量 显示本年度供水量售水量累计值与预算值占比饼状图 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getFeedSaleMonth(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 单位变动成本 显示本年度总单位变动成本累计值与预算值
     */
    @ApiOperation(value = "首页-生产运营 单位变动成本 显示本年度总单位变动成本累计值与预算值(按年统计)")
    @GetMapping("/getUnitVariableCost")
    public ResultRespone<UnitVariableCostStatisticalVo> getUnitVariableCostStatistical() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("单位变动成本 显示本年度总单位变动成本累计值与预算值 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getUnitVariableCostStatistical(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 单位变动成本 本年度各月完成累计值/预算值情况
     */
    @ApiOperation(value = "首页-生产运营 单位变动成本 本年度各月完成累计值/预算值情况(按年统计)")
    @GetMapping("/getUnitVariableCostMonth")
    public ResultRespone<List<UnitVariableCostMonthVo>> getUnitVariableCostMonth() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("单位变动成本 本年度各月完成累计值/预算值情况 : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getUnitVariableCostMonth(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 一厂 取供水(统计一年数据按月分组)
     */
    @ApiOperation(value = "首页-生产运营 一厂 取供水(统计一年数据按月分组)")
    @GetMapping("/getOneFactoryTakingWaterSupply")
    public ResultRespone<List<OneFactoryTakingWaterSupplyStatisticalVo>> getOneFactoryTakingWaterSupplyStatistical() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("一厂 取供水(统计一年数据按月分组) : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getOneFactoryTakingWaterSupplyStatistical(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 二厂 取供水(统计一年数据按月分组)
     */
    @ApiOperation(value = "首页-生产运营 二厂 取供水(统计一年数据按月分组)")
    @GetMapping("/getTwoFactoryTakingWaterSupply")
    public ResultRespone<List<TwoFactoryTakingWaterSupplyStatisticalVo>> getTwoFactoryTakingWaterSupplyStatistical() {
        LocalDate firstDayOfCurrentYear = DateTimeUtil.getFirstDayOfCurrentYear();
        log.info("一厂 取供水(统计一年数据按月分组) : 统计年份: {}",firstDayOfCurrentYear.getYear());
        return ResultRespone.success(warnService.getTwoFactoryTakingWaterSupplyStatistical(String.valueOf(firstDayOfCurrentYear.getYear())));
    }

    /**
     * 首页-生产运营 一厂 水质出厂余氯(统计一天数据按数据收集时间分组)
     */
    @ApiOperation(value = "首页-生产运营 一厂 水质出厂余氯(统计一天数据按数据收集时间分组)")
    @GetMapping("/getOneFactoryWaterQualityYL")
    public ResultRespone<List<OneFactoryWaterQualityYLStatisticalVo>> getOneFactoryWaterQualityYLStatistical() {
        // 当前时间 往前推24小时
        LocalDateTime now = LocalDateTime.now();
        Date startTime = DateTimeUtil.convertLDTToDate(now.minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(now);
        log.info("一厂 水质余氯(统计一天数据按数据收集时间分组): 统计日期: {}",startTime.getDay());
        return ResultRespone.success(warnService.getOneFactoryWaterQualityYLStatistical(startTime,endTime));
    }

    /**
     * 首页-生产运营 一厂 水质出厂浊度(统计一天数据按数据收集时间分组)
     */
    @ApiOperation(value = "首页-生产运营 一厂 水质出厂浊度(统计一天数据按数据收集时间分组)")
    @GetMapping("/getOneFactoryWaterQualityZD")
    public ResultRespone<List<OneFactoryWaterQualityZDStatisticalVo>> getOneFactoryWaterQualityZDStatistical() {
        // 当前时间 往前推24小时
        LocalDateTime now = LocalDateTime.now();
        Date startTime = DateTimeUtil.convertLDTToDate(now.minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(now);
        log.info("一厂 水质出厂浊度(统计一天数据按数据收集时间分组): 统计日期: {}",startTime.getDay());
        return ResultRespone.success(warnService.getOneFactoryWaterQualityZDStatistical(startTime,endTime));
    }

    /**
     * 首页-生产运营 二厂 水质出厂余氯(统计一天数据按数据收集时间分组)
     */
    @ApiOperation(value = "首页-生产运营 二厂 水质出厂余氯(统计一天数据按数据收集时间分组)")
    @GetMapping("/getTwoFactoryWaterQualityYL")
    public ResultRespone<List<TwoFactoryWaterQualityYLStatisticalVo>> getTwoFactoryWaterQualityYLStatistical() {
        // 当前时间 往前推24小时
        LocalDateTime now = LocalDateTime.now();
        Date startTime = DateTimeUtil.convertLDTToDate(now.minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(now);
        log.info("二厂 水质出厂余氯(统计一天数据按数据收集时间分组): 统计日期: {}",startTime.getDay());
        return ResultRespone.success(warnService.getTwoFactoryWaterQualityYLStatistical(startTime,endTime));
    }

    /**
     * 首页-生产运营 二厂 水质出厂浊度(统计一天数据按数据收集时间分组)
     */
    @ApiOperation(value = "首页-生产运营 二厂 水质出厂浊度(统计一天数据按数据收集时间分组)")
    @GetMapping("/getTwoFactoryWaterQualityZD")
    public ResultRespone<List<TwoFactoryWaterQualityZDStatisticalVo>> getTwoFactoryWaterQualityZDStatistical() {
        // 当前时间 往前推24小时
        LocalDateTime now = LocalDateTime.now();
        Date startTime = DateTimeUtil.convertLDTToDate(now.minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(now);
        log.info("二厂 水质出厂浊度(统计一天数据按数据收集时间分组): 统计日期: {}",startTime.getDay());
        return ResultRespone.success(warnService.getTwoFactoryWaterQualityZDStatistical(startTime,endTime));
    }

    /**
     * 首页-生产运营 一厂 水压(统计一天数据按数据收集时间分组)
     */
    @ApiOperation(value = "首页-生产运营 一厂 水压(统计一天数据按数据收集时间分组)")
    @GetMapping("/getOneFactoryWaterPressure")
    public ResultRespone<List<OneFactoryWaterPressureStatisticalVo>> getOneFactoryWaterPressureStatistical() {
        // 当前时间 往前推24小时
        LocalDateTime now = LocalDateTime.now();
        Date startTime = DateTimeUtil.convertLDTToDate(now.minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(now);
        log.info("一厂 水压(统计一天数据按数据收集时间分组): 统计日期: {}",startTime.getDay());
        return ResultRespone.success(warnService.getOneFactoryWaterPressureStatistical(startTime,endTime));
    }

    /**
     * 首页-生产运营 一厂 水压(统计一天数据按数据收集时间分组)
     */
    @ApiOperation(value = "首页-生产运营 二厂 水压(统计一天数据按数据收集时间分组)")
    @GetMapping("/getTwoFactoryWaterPressure")
    public ResultRespone<List<TwoFactoryWaterPressureStatisticalVo>> getTwoFactoryWaterPressureStatistical() {
        // 当前时间 往前推24小时
        LocalDateTime now = LocalDateTime.now();
        Date startTime = DateTimeUtil.convertLDTToDate(now.minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(now);
        log.info("二厂 水压(统计一天数据按数据收集时间分组): 统计日期: {}",startTime.getDay());
        return ResultRespone.success(warnService.getTwoFactoryWaterPressureStatistical(startTime,endTime));
    }


    /**
     * 首页-生产运营 一厂关键指标(取水量、供水量按上一天数据累计值，出厂水压、水质指标取瞬时值，加药耗量、制水电耗取上一天填报数据)
     */
    @ApiOperation(value = "首页-生产运营 一厂关键指标(取水量、供水量按上一天数据累计值，出厂水压、水质指标取瞬时值，加药耗量、制水电耗取上一天填报数据)")
    @GetMapping("/getOneFactoryKeyIndex")
    public ResultRespone<OneFactoryKeyIndexStatisticalVo> getOneFactoryKeyIndexStatistical() {
        Date startTime = DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayBeginTime().minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayEndTime().minusDays(1));
        log.info("一厂关键指标: 统计日期: {}",startTime);
        return ResultRespone.success(warnService.getOneFactoryKeyIndexStatistical(startTime,endTime));
    }

    /**
     * 首页-生产运营 二厂关键指标(取水量、供水量按上一天数据累计值，出厂水压、水质指标取瞬时值，加药耗量、制水电耗取上一天填报数据)
     */
    @ApiOperation(value = "首页-生产运营 二厂关键指标(取水量、供水量按上一天数据累计值，出厂水压、水质指标取瞬时值，加药耗量、制水电耗取上一天填报数据)")
    @GetMapping("/getTwoFactoryKeyIndex")
    public ResultRespone<TwoFactoryKeyIndexStatisticalVo> getTwoFactoryKeyIndexStatistical() {
        Date startTime = DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayBeginTime().minusDays(1));
        Date endTime = DateTimeUtil.convertLDTToDate(DateTimeUtil.getTodayEndTime().minusDays(1));
        log.info("二厂关键指标: 统计日期: {}",startTime);
        return ResultRespone.success(warnService.getTwoFactoryKeyIndexStatistical(startTime,endTime));
    }

    /**
     * 这里查询的主要是热线派单的，并且还有人员时间限制，所以看到页面没有数据，只是部分人员没有
     * @return
     */
    @ApiOperation(value = "首页-个人排行 (好评率/个人排行/呼入数/呼出数/派单数/回访数)")
    @GetMapping("/getIndividualRanking")
    public ResultRespone<Object> getIndividualRanking(){
        Date startTime = DateTimeUtil.localDateToDate(DateTimeUtil.getFirstDayOfCurrentMonth());
        Date endTime = DateTimeUtil
                .convertLDTToDate(DateTimeUtil
                        .getAssignTodayEndTime(DateTimeUtil
                                .fromLong2LocalDateTime(DateTimeUtil
                                        .localDateToDate(DateTimeUtil
                                                .getLastDayOfCurrentMonth()).getTime())));

        log.info("个人排行 : {},统计月份: {}",SecurityUtils.getUserName(),startTime.getMonth()+1);
        return ResultRespone.success(warnService.getIndividualRanking(startTime,endTime,SecurityUtils.getUserName(),SecurityUtils.getUserId()));
    }

    @ApiOperation(value = "首页-管网 管龄预警报表统计")
    @GetMapping("/getPipeReport")
    public ResultRespone<Object> getPipeReport() {
        return ResultRespone.success(warnService.getPipeReport());
    }

}
