package com.qianwen.smartman.modules.visual.wrapper;

import cn.hutool.core.collection.ListUtil;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import com.qianwen.smartman.common.constant.DateConstant;
import com.qianwen.smartman.common.constant.VisualConstant;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.smartman.modules.cps.entity.Workstation;
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateOutput;
import com.qianwen.smartman.modules.system.entity.SeriesItem;
import com.qianwen.smartman.modules.system.vo.ChartSeriesDataVO;
import com.qianwen.smartman.modules.system.vo.WorkstationChartSeriesDataVO;
import com.qianwen.smartman.modules.visual.dto.DynamicCountDateAggregateDTO;

/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/visual/wrapper/VisualCountPulseWrapper.class */
public class VisualCountPulseWrapper {
   

    public static ChartSeriesDataVO<Long> visualCountDataByHour(DynamicCountDateAggregateDTO countAggregateDataDTO) {
        return visualCountDataByCondition(countAggregateDataDTO, ChronoUnit.HOURS, date -> {
            return date.getDayOfMonth() + "-" + date.getHour();
        });
    }

    public static ChartSeriesDataVO<Long> visualCountDataByDay(DynamicCountDateAggregateDTO countAggregateDataDTO) {
        return visualCountDataByCondition(countAggregateDataDTO, ChronoUnit.DAYS, date -> {
            return DateUtil.format(date, DateConstant.PATTERN_DATE);
        });
    }

    public static ChartSeriesDataVO<Long> visualCountDataByShift(DynamicCountDateAggregateDTO countAggregateDataDTO) {
        Map<Long, Long> aggregateData = countAggregateDataDTO.getList().stream().collect(Collectors.groupingBy((v0) -> {
            return v0.getWorkstationId();
        }, Collectors.summingLong((v0) -> {
            return v0.getOutput();
        })));
        WorkstationChartSeriesDataVO<Long> chartSeriesDataVO = new WorkstationChartSeriesDataVO<>();
        List<Long> data = countAggregateDataDTO.getWorkstationList().stream().map(workstation -> {
            return (Long) aggregateData.getOrDefault(workstation.getId(), 0L);
        }).collect(Collectors.toList());
        SeriesItem<Long> item = new SeriesItem<>(VisualConstant.SHIFT_OUTPUT, data);
        chartSeriesDataVO.generateCategories(countAggregateDataDTO.getWorkstationList(), 3);
        chartSeriesDataVO.setSeries(ListUtil.toList(new SeriesItem[]{item}));
        return chartSeriesDataVO;
    }

    private static ChartSeriesDataVO<Long> visualCountDataByCondition(DynamicCountDateAggregateDTO countAggregateDataDTO, ChronoUnit chronoUnit, Function<LocalDateTime, String> categoriesFormat) {
    	assert countAggregateDataDTO.getStartTime() != null;
        assert countAggregateDataDTO.getEndTime() != null;
        //UnaryOperator<LocalDateTime> unaryOperator;
        
        List<Workstation> workstationList = countAggregateDataDTO.getWorkstationList();
        Map<Long, String> categoriesSuffix = workstationList.stream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, (v0) -> {
            return v0.getName();
        }));
        List<SuperAggregateOutput> list = countAggregateDataDTO.getList();
        LocalDateTime startTime = countAggregateDataDTO.getStartTime();
        LocalDateTime endTime = countAggregateDataDTO.getEndTime();
        long between = chronoUnit.between(startTime, endTime);
        
        UnaryOperator<LocalDateTime> operator = chronoUnit.equals(ChronoUnit.HOURS) ? (date -> date.plusHours(1L)) : (chronoUnit.equals(ChronoUnit.DAYS) ? (date -> date.plusDays(1L)) : null);
        /*
        if (chronoUnit.equals(ChronoUnit.HOURS)) {
            unaryOperator = date -> {
                return date.plusHours(1L);
            };
        } else {
            unaryOperator = chronoUnit.equals(ChronoUnit.DAYS) ? date2 -> {
                return date2.plusDays(1L);
            } : null;
        }
        UnaryOperator<LocalDateTime> operator = unaryOperator;
        */
        assert operator != null;
            
        List<String> categories = Stream.iterate(startTime, operator).limit(between + 1).map(categoriesFormat).collect(Collectors.toList());
        ChartSeriesDataVO<Long> chartSeriesDataVO = new ChartSeriesDataVO<>();
        Map<Long, SeriesItem<Long>> seriesMap = new HashMap<>();
        list.stream().collect(Collectors.groupingBy((v0) -> {
            return v0.getWorkstationId();
        })).forEach((id, aggregateOutputs) -> {
            Map<String, Long> collectMap = aggregateOutputs.stream().collect(Collectors.groupingBy(aggregate -> {
                return (String) categoriesFormat.apply(aggregate.getTs().toLocalDateTime());
            }, Collectors.summingLong((v0) -> {
                return v0.getOutput();
            })));
            seriesMap.put(id, new SeriesItem(categoriesSuffix.get(id), categories.stream().map(it -> {
                return collectMap.getOrDefault(it, 0L);
            }).collect(Collectors.toList())));
        });
        chartSeriesDataVO.setCategories(categories);
        chartSeriesDataVO.setSeries(countAggregateDataDTO.getWorkstationList().stream().map(item -> {
            return seriesMap.get(item.getId());
        }).filter((v0) -> {
            return Objects.nonNull(v0);
        }).collect(Collectors.toList()));
        return chartSeriesDataVO;
    }
}