package com.qianwen.smartman.modules.report.service.impl;

import cn.hutool.cache.CacheUtil;
import cn.hutool.cache.impl.TimedCache;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.core.tool.utils.BeanUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.cps.dto.ShiftInfoDTO;
import com.qianwen.smartman.modules.cps.mapper.CalendarMapper;
import com.qianwen.smartman.modules.cps.mapper.WorkstationMapper;
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateOutput;
import com.qianwen.smartman.modules.mdc.enums.OpenTypeEnums;
import com.qianwen.smartman.modules.mdc.enums.StatisticalMethodEnum;
import com.qianwen.smartman.modules.mdc.mapper.SuperAggregateOutputMapper;
import com.qianwen.smartman.modules.mdc.utils.FilterOffUtils;
import com.qianwen.smartman.modules.report.dto.WorkstationDataDTO;
import com.qianwen.smartman.modules.report.dto.WorkstationShiftDTO;
import com.qianwen.smartman.modules.report.mapper.CommonMapper;
import com.qianwen.smartman.modules.report.service.IOutputStatisticsReportService;
import com.qianwen.smartman.modules.report.utils.CommonUtil;
import com.qianwen.smartman.modules.report.utils.DateCycleUtil;
import com.qianwen.smartman.modules.report.utils.ResultUtil;
import com.qianwen.smartman.modules.report.utils.ThreadPoolUtil;
import com.qianwen.smartman.modules.report.vo.OutputResultVO;
import com.qianwen.smartman.modules.report.vo.OutputShiftResultVO;
import com.qianwen.smartman.modules.report.vo.StatisticsQueryVO;
import org.springframework.stereotype.Service;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/report/service/impl/OutputStatisticsReportServiceImpl.class */
public class OutputStatisticsReportServiceImpl implements IOutputStatisticsReportService {
    private final SuperAggregateOutputMapper aggregateOutputMapper;
    private final WorkstationMapper workstationMapper;
    private final CalendarMapper calendarMapper;
    private final CommonMapper commonMapper;
    private static final String TIME_CONDITION = "timeCondition";
    private static final String OUTPUT_TABLE_NAME = "aggregate_output";
    private static final int TIMEOUT = 1800000;
    private static final String SHIFT_KYE = "shift-";
    private static final String DATE_KYE = "date-";
    private static final Logger log = LoggerFactory.getLogger(OutputStatisticsReportServiceImpl.class);
    private static final TimedCache<String, OutputShiftResultVO> RESULT_TIMED_CACHE = CacheUtil.newTimedCache(1800000);

    public OutputStatisticsReportServiceImpl(final SuperAggregateOutputMapper aggregateOutputMapper, final WorkstationMapper workstationMapper, final CalendarMapper calendarMapper, final CommonMapper commonMapper) {
        this.aggregateOutputMapper = aggregateOutputMapper;
        this.workstationMapper = workstationMapper;
        this.calendarMapper = calendarMapper;
        this.commonMapper = commonMapper;
    }

    @Override // org.springblade.modules.report.service.IOutputStatisticsReportService
    public JSONObject outputStatisticsByShift(StatisticsQueryVO queryVO) {
        queryVO.setBeginTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
        queryVO.setEndTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
        StatisticalMethodEnum anEnum = StatisticalMethodEnum.DAY;
        List<String> fillDateCol = DateCycleUtil.fillDateCol(queryVO.getBeginTime(), queryVO.getEndTime(), anEnum);
        IPage<WorkstationDataDTO> iPage = workstations(queryVO);
        List<WorkstationDataDTO> workstationData = iPage.getRecords();
        if (CollectionUtil.isEmpty(workstationData)) {
            return new JSONObject();
        }
        List<Long> ids = (List) workstationData.parallelStream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        List<ShiftInfoDTO> shiftInfoDtoList = this.calendarMapper.listShiftInfo(ids, LocalDate.parse(queryVO.getBeginTime()), LocalDate.parse(queryVO.getEndTime()));
        List<WorkstationShiftDTO> workstationShifts = CommonUtil.dataMerge(workstationData, shiftInfoDtoList);
        List<WorkstationShiftDTO> filter = (List) workstationShifts.parallelStream().filter(CommonUtil.conditionFilter(queryVO.getShiftName(), queryVO.getShiftIndex())).collect(Collectors.toList());
        List<OutputShiftResultVO> result = settingResult(fillDateCol, filter);
        String beginTime = DateCycleUtil.getDateByDateCycle(queryVO.getBeginTime(), anEnum, Boolean.TRUE);
        String endTime = DateCycleUtil.getDateByDateCycle(queryVO.getEndTime(), anEnum, Boolean.FALSE);
        List<SuperAggregateOutput> outputs = multithreadingTask(beginTime, endTime, ids, queryVO.getStatisticsType());
        Map<String, List<SuperAggregateOutput>> workstationOutMap = (Map) outputs.parallelStream().collect(Collectors.groupingBy(s -> {
            return s.getWorkstationId() + "-" + s.getShiftIndex();
        }));
        Map<String, OutputShiftResultVO> voMap = (Map) result.parallelStream().collect(LinkedHashMap::new, map, c -> {
            OutputShiftResultVO outputShiftResultVO = (OutputShiftResultVO) map.put(c.getWorkstationId() + "-" + c.getShiftIndex() + "-" + c.getDateCycle(), c);
        }, (v0, v1) -> {
            v0.putAll(v1);
        });
        resultCount(workstationOutMap, anEnum, voMap);
        return ResultUtil.dataToJsonObject(voMap.values(), Long.valueOf(iPage.getTotal()), queryVO.getPageSize());
    }

    private List<OutputShiftResultVO> settingResult(List<String> fillDateCol, List<? extends WorkstationDataDTO> filter) {
        List<OutputShiftResultVO> result = new ArrayList<>();
        fillDateCol.forEach(f -> {
            filter.forEach(shift -> {
                String key = f + "-" + shift.getWorkstationId();
                String key2 = shift instanceof WorkstationShiftDTO ? SHIFT_KYE + ((WorkstationShiftDTO) shift).getShiftIndex() + key : DATE_KYE + key;
                OutputShiftResultVO resultVO = (OutputShiftResultVO) RESULT_TIMED_CACHE.get(key2);
                if (resultVO == null) {
                    resultVO = new OutputShiftResultVO();
                    RESULT_TIMED_CACHE.put(key2, resultVO);
                }
                BeanUtil.copyProperties(shift, resultVO);
                resultVO.setDateCycle(f);
                resultVO.setOutputCount(0L);
                result.add(resultVO);
            });
        });
        return result;
    }

    private <T, R extends OutputResultVO> void resultCount(Map<T, List<SuperAggregateOutput>> workstationOutMap, StatisticalMethodEnum anEnum, Map<String, R> voMap) {
        workstationOutMap.forEach(outputKey, outputList -> {
            Map<String, Long> output = (Map) outputList.parallelStream().collect(Collectors.groupingBy(groupKey(anEnum), Collectors.mapping((v0) -> {
                return v0.getOutput();
            }, Collectors.reducing(0L, (v0, v1) -> {
                return Long.sum(v0, v1);
            }))));
            output.forEach(k, v -> {
                OutputResultVO vo = (OutputResultVO) voMap.get(outputKey + "-" + k);
                if (!Objects.isNull(vo)) {
                    vo.setOutputCount(v);
                }
            });
        });
    }

    private IPage<WorkstationDataDTO> workstations(StatisticsQueryVO queryVO) {
        IPage<WorkstationDataDTO> workstationData;
        IPage<WorkstationDataDTO> workstationData2 = CommonUtil.getIPage(WorkstationDataDTO.class, queryVO.getPageSize(), queryVO.getPageNo(), this.workstationMapper);
        if (Func.isEmpty(queryVO.getShiftName())) {
            workstationData = this.workstationMapper.getWorkstationData(workstationData2, queryVO.getKeyword(), queryVO.getWorkstationIds());
        } else {
            workstationData = this.workstationMapper.getWorkstationDataWithIndexName(workstationData2, queryVO.getKeyword(), queryVO.getShiftName(), queryVO.getBeginTime(), queryVO.getEndTime(), queryVO.getWorkstationIds());
        }
        CommonUtil.fillWorkStationGroup(workstationData);
        return workstationData;
    }

    @Override // org.springblade.modules.report.service.IOutputStatisticsReportService
    public JSONObject outputStatisticsByDate(StatisticsQueryVO queryVO) {
        queryVO.setBeginTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
        queryVO.setEndTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
        StatisticalMethodEnum anEnum = StatisticalMethodEnum.of(queryVO.getDateCycle());
        List<String> fillDateCol = DateCycleUtil.fillDateCol(queryVO.getBeginTime(), queryVO.getEndTime(), anEnum);
        String beginTime = DateCycleUtil.getDateByDateCycle(queryVO.getBeginTime(), anEnum, Boolean.TRUE);
        String endTime = DateCycleUtil.getDateByDateCycle(queryVO.getEndTime(), anEnum, Boolean.FALSE);
        IPage<WorkstationDataDTO> iPage = workstations(queryVO);
        List<WorkstationDataDTO> workstationData = iPage.getRecords();
        if (CollectionUtil.isEmpty(workstationData)) {
            return new JSONObject();
        }
        List<OutputResultVO> result = Convert.toList(OutputResultVO.class, settingResult(fillDateCol, workstationData));
        Map<String, OutputResultVO> voMap = (Map) result.parallelStream().collect(Collectors.toMap(c -> {
            return c.getWorkstationId() + "-" + c.getDateCycle();
        }, o -> {
            return o;
        }));
        List<Long> ids = (List) workstationData.parallelStream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        List<SuperAggregateOutput> outputs = multithreadingTask(beginTime, endTime, ids, queryVO.getStatisticsType());
        Map<Long, List<SuperAggregateOutput>> workstationOutMap = (Map) outputs.parallelStream().collect(Collectors.groupingBy((v0) -> {
            return v0.getWorkstationId();
        }));
        resultCount(workstationOutMap, anEnum, voMap);
        return ResultUtil.dataToJsonObject(voMap.values(), Long.valueOf(iPage.getTotal()), queryVO.getPageSize());
    }

    private Function<SuperAggregateOutput, String> groupKey(StatisticalMethodEnum statisticalMethodEnum) {
        switch (statisticalMethodEnum) {
            case DAY:
                return output -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output.getFactoryDate()));
                };
            case WEEK:
                return output2 -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output2.getFactoryWeek()));
                };
            case MONTH:
                return output3 -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output3.getFactoryMonth()));
                };
            default:
                return output4 -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output4.getWorkstationId()));
                };
        }
    }

    private List<SuperAggregateOutput> multithreadingTask(String beginTime, String endTime, List<Long> workstationIds, Integer statisticsType) {
        List<String> childOutputTables = this.commonMapper.getItemBySuperTable(OUTPUT_TABLE_NAME, workstationIds);
        if (CollectionUtil.isEmpty(childOutputTables)) {
            return new ArrayList();
        }
        List<Callable<List<SuperAggregateOutput>>> callables = new ArrayList<>();
        workstationIds.forEach(id -> {
            callables.add(() -> {
                if (!childOutputTables.contains("aggregate_output_" + id)) {
                    return new ArrayList();
                }
                List<SuperAggregateOutput> output = this.aggregateOutputMapper.getOutputByDateCycleAndWorkstationId(beginTime, endTime, id, statisticsType);
                return FilterOffUtils.filterOffDay(output, OpenTypeEnums.OUT_PUT);
            });
        });
        return ThreadPoolUtil.createTaskList(callables);
    }
}