package com.qianwen.smartman.modules.report.utils;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletRequest;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.CommonGroupConstant;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.tool.utils.BeanUtil;
import com.qianwen.core.tool.utils.CollectionUtil;
import com.qianwen.smartman.modules.cps.dto.ShiftInfoDTO;
import com.qianwen.smartman.modules.cps.mapper.WorkstationMapper;
import com.qianwen.smartman.modules.report.dto.WorkstationDataDTO;
import com.qianwen.smartman.modules.report.dto.WorkstationShiftDTO;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/report/utils/CommonUtil.class */
public class CommonUtil {
    private static final String SHIFT1 = "班次1";
    private static final String SHIFT2 = "班次2";
    private static final String SHIFT3 = "班次3";
    private static final String SHIFT4 = "班次4";
    private static final String DEFAULT_SHIFT = "未排班";
    public static final String PRINT_ALL_KEY = "printAll";
    public static final String DEFAULT_SHIFT_NAME = "默认系统日历-班次1";
    private static final Log log = LogFactory.get();

    public static String buildShiftName(Integer shiftIndex, Boolean isBlendShiftModel, String shiftName) {
        if (isBlendShiftModel.booleanValue() || StrUtil.isEmpty(shiftName)) {
            return buildShiftName(shiftIndex);
        }
        return shiftName;
    }

    public static String buildShiftName(Integer shiftIndex) {
        switch (shiftIndex.intValue()) {
            case 1:
                return SHIFT1;
            case 2:
                return SHIFT2;
            case 3:
                return SHIFT3;
            case 4:
                return SHIFT4;
            default:
                return DEFAULT_SHIFT;
        }
    }

    public static List<WorkstationShiftDTO> dataMerge(List<WorkstationDataDTO> workstationData, List<ShiftInfoDTO> shiftInfoDtoList) {
        List<WorkstationShiftDTO> workstationShifts = new ArrayList<>();
        workstationData.forEach(workstation -> {
            Boolean isBlendShiftModel = isBlendShiftModel(shiftInfoDtoList, workstation.getWorkstationId());
            List<ShiftInfoDTO> collect = shiftInfoDtoList.parallelStream().filter(shift -> {
                return shift.getWorkstationId().equals(workstation.getWorkstationId());
            }).collect(Collectors.collectingAndThen(Collectors.toCollection(() -> {
                return new TreeSet<>(Comparator.comparing((v0) -> {
                    return v0.getShiftIndex();
                }));
            }), (v1) -> {
                return new ArrayList<>(v1);
            }));
            collect.forEach(c -> {
                WorkstationShiftDTO workstationShiftDTO = WorkstationShiftDTO.of(c.getShiftIndex()).setShiftName(buildShiftName(c.getShiftIndex(), isBlendShiftModel, c.getIndexName()));
                BeanUtil.copyProperties(workstation, workstationShiftDTO);
                workstationShifts.add(workstationShiftDTO);
            });
            workstationShifts.addAll(fillShift(collect, workstation));
        });
        return workstationShifts;
    }

    public static Boolean isBlendShiftModel(List<ShiftInfoDTO> shiftInfos, Long workstationId) {
        int size = ( shiftInfos.parallelStream().filter(s -> {
            return s.getWorkstationId().equals(workstationId);
        }).collect(Collectors.collectingAndThen(Collectors.toCollection(() -> {
            return new TreeSet<>(Comparator.comparing((v0) -> {
                return v0.getModelId();
            }));
        }), (v1) -> {
            return new ArrayList<>(v1);
        }))).size();
        return Boolean.valueOf(size >= 2);
    }

    public static List<WorkstationShiftDTO> fillShift(List<ShiftInfoDTO> collect, WorkstationDataDTO workstationDataDTO) {
        if (collect.size() == 4) {
            return new ArrayList<>();
        }
        List<WorkstationShiftDTO> result = new ArrayList<>();
        if (CollectionUtil.isEmpty(collect)) {
            WorkstationShiftDTO workstationShiftDTO = WorkstationShiftDTO.of(1).setShiftName(DEFAULT_SHIFT_NAME);
            BeanUtil.copyProperties(workstationDataDTO, workstationShiftDTO);
            result.add(workstationShiftDTO);
        }
        return result;
    }

    public static Predicate<? super WorkstationShiftDTO> conditionFilter(String shiftName, List<Integer> shiftIndexList) {
        return shift -> {
            boolean condition1 = true;
            boolean condition2 = true;
            if (StrUtil.isNotEmpty(shiftName) && StrUtil.isNotEmpty(shift.getShiftName())) {
                condition1 = shift.getShiftName().contains(shiftName);
            }
            if (CollectionUtil.isNotEmpty(shiftIndexList)) {
                condition2 = shiftIndexList.contains(shift.getShiftIndex());
            }
            return condition1 && condition2;
        };
    }

    public static void fillWorkStationGroup(IPage<WorkstationDataDTO> source) {
        List<WorkstationDataDTO> list = source.getRecords().parallelStream().peek(w -> {
            if (StrUtil.isEmpty(w.getWorkstationGroup())) {
                w.setWorkstationGroup(CommonGroupConstant.DEFAULT_NAME);
            }
        }).collect(Collectors.toList());
        source.setRecords(list);
    }

    public static <T> T getRequestParameter(String parameterName, Class<T> clazz) {
        HttpServletRequest request = getRequest();
        String parameter = request.getParameter(parameterName);
        if (StrUtil.isEmpty(parameter) || "null".equals(parameter)) {
            log.info("  获取Request中参数{}失败，参数不存在", new Object[]{parameterName});
            return null;
        }
        return (T) Convert.convert(clazz, parameter);
    }

    public static HttpServletRequest getRequest() {
        ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            return request;
        }
        throw new RuntimeException("获取Request失败！");
    }

    public static <T> IPage<T> getIPage(Class<T> clazz, Integer size, Integer pageNo, WorkstationMapper workstationMapper) {
        IPage<T> iPage;
        Boolean isPrintAll = (Boolean) getRequestParameter(PRINT_ALL_KEY, Boolean.class);
        if (!Objects.isNull(isPrintAll) && isPrintAll.booleanValue()) {
            iPage = Condition.getPage(new Query().setSize(Integer.valueOf(Math.toIntExact(workstationMapper.selectCount(null).longValue()))).setCurrent(CommonConstant.ONE));
        } else {
            iPage = Condition.getPage(new Query().setSize(size).setCurrent(pageNo));
        }
        return iPage;
    }
}