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

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.tool.utils.CollectionUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.cache.cps.WorkstationCache;
import com.qianwen.smartman.common.constant.DateConstant;
import com.qianwen.smartman.common.enums.GlobalWcsTypeEnum;
import com.qianwen.smartman.common.utils.LocalDateTimeUtils;
import com.qianwen.smartman.modules.cps.dto.WorkstationWcsDmpDTO;
import com.qianwen.smartman.modules.cps.entity.GlobalWcs;
import com.qianwen.smartman.modules.cps.entity.Workstation;
import com.qianwen.smartman.modules.cps.enums.TrayEnum;
import com.qianwen.smartman.modules.cps.enums.WorkstationTypeEnum;
import com.qianwen.smartman.modules.cps.mapper.WorkstationMapper;
import com.qianwen.smartman.modules.cps.message.dto.TelemetryDataResponseDTO;
import com.qianwen.smartman.modules.cps.service.IGlobalWcsService;
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
import com.qianwen.smartman.modules.mdc.entity.WorkstationCollectData;
import com.qianwen.smartman.modules.mdc.mapper.SuperAggregateStateMapper;
import com.qianwen.smartman.modules.mdc.mapper.SuperAlarmMapper;
import com.qianwen.smartman.modules.mdc.mapper.SuperProcessParameterMapper;
import com.qianwen.smartman.modules.mdc.service.IWorkstationAnalysisService;
import com.qianwen.smartman.modules.mdc.vo.AlarmAnalysisWorkstationVO;
import com.qianwen.smartman.modules.mdc.vo.DeviceStatusStatisticsVO;
import com.qianwen.smartman.modules.mdc.vo.StatusAnalysisWorkstationVO;
import com.qianwen.smartman.modules.mdc.vo.StatusTimeTotalDetailVO;
import com.qianwen.smartman.modules.mdc.vo.StatusTimeTotalVO;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/mdc/service/impl/WorkstationAnalysisServiceImpl.class */
public class WorkstationAnalysisServiceImpl implements IWorkstationAnalysisService {
    private static final Logger log = LoggerFactory.getLogger(WorkstationAnalysisServiceImpl.class);
    public static final String STATUS = "STATUS";
    private final SuperAggregateStateMapper superAggregateStateMapper;
    private final SuperAlarmMapper superAlarmMapper;
    private final IGlobalWcsService globalWcsService;
    private final WorkstationMapper workstationMapper;
    private final SuperProcessParameterMapper superProcessParameterMapper;
    private final IWorkstationService workstationService;


    public WorkstationAnalysisServiceImpl(final SuperAggregateStateMapper superAggregateStateMapper, final SuperAlarmMapper superAlarmMapper, final IGlobalWcsService globalWcsService, final WorkstationMapper workstationMapper, final SuperProcessParameterMapper superProcessParameterMapper, final IWorkstationService workstationService) {
        this.superAggregateStateMapper = superAggregateStateMapper;
        this.superAlarmMapper = superAlarmMapper;
        this.globalWcsService = globalWcsService;
        this.workstationMapper = workstationMapper;
        this.superProcessParameterMapper = superProcessParameterMapper;
        this.workstationService = workstationService;
    }

    @Override // org.springblade.modules.mdc.service.IWorkstationAnalysisService
    public List<StatusAnalysisWorkstationVO> statusByWorkstation(String workstationId) {
        String startTime = LocalDateTimeUtils.formatTime(LocalDateTime.of(LocalDate.now(), LocalTime.MIN), DateConstant.PATTERN_DATE_TIME);
        String endTime = LocalDateTimeUtils.formatTime(LocalDateTime.of(LocalDate.now(), LocalTime.MAX), DateConstant.PATTERN_DATE_TIME);
        List<StatusAnalysisWorkstationVO> result = new ArrayList<>();
        try {
            List<StatusAnalysisWorkstationVO> result1 = this.superAggregateStateMapper.statusByWorkstation(workstationId, startTime, endTime);
            List<StatusAnalysisWorkstationVO> result2 = this.superAggregateStateMapper.statusByWorkstationByNull(workstationId, startTime);
            result.addAll(result1);
            result.addAll(result2);
        } catch (Exception e) {
            result = new ArrayList<>();
        }
        result.forEach(i -> {
            i.setStartTime(timeStamp2Date(i.getStartDate(), DateConstant.PATTERN_DATE_TIME));
            i.setEndTime(timeStamp2Date(i.getEndDate(), DateConstant.PATTERN_DATE_TIME));
        });
        return result;
    }

    @Override // org.springblade.modules.mdc.service.IWorkstationAnalysisService
    public IPage<AlarmAnalysisWorkstationVO> alarmByWorkstation(String workstationId, Query query) {
        List<AlarmAnalysisWorkstationVO> result;
        Integer total;
        IPage<AlarmAnalysisWorkstationVO> page = Condition.getPage(query);
        new ArrayList();
        try {
            result = this.superAlarmMapper.alarmByWorkstation(workstationId, Integer.valueOf((query.getCurrent().intValue() - 1) * query.getSize().intValue()), query.getSize());
            total = this.superAlarmMapper.alarmByWorkstationTotal(workstationId);
        } catch (Exception e) {
            result = new ArrayList<>();
            total = 0;
        }
        page.setRecords(result);
        page.setTotal(total == null ? 0L : total.intValue());
        return page;
    }

    @Override // org.springblade.modules.mdc.service.IWorkstationAnalysisService
    public StatusTimeTotalVO statusTimeTotalByGroupId(String groupId, String groupName) {
        Long total;
        StatusTimeTotalVO result = new StatusTimeTotalVO();
        result.setGroupId(groupId);
        result.setGroupName(groupName);
        List<Workstation> workstationList = this.workstationMapper.listWorkStationByGroupId(Arrays.asList(groupId));
        List<Long> workstationIdList = workstationList.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        Long totalTime = Long.valueOf(new BigDecimal(DateUtil.toDate(LocalDateTime.now()).getTime()).subtract(new BigDecimal(DateUtil.toDate(LocalDateTime.of(LocalDate.now(), LocalTime.MIN)).getTime())).multiply(new BigDecimal(workstationIdList.size())).longValue());
        List<GlobalWcs> list = this.globalWcsService.getGlobalWcsList(GlobalWcsTypeEnum.DEFAULT);
        Map<String, String> dictBizMap =  list.stream().collect(Collectors.toMap((v0) -> {
            return v0.getCode();
        }, (v0) -> {
            return v0.getName();
        }));
        Map<String, Long> initMap = getInitMap(list);
        List<StatusAnalysisWorkstationVO> dataList = new ArrayList<>();
        if (CollectionUtil.isNotEmpty(workstationIdList)) {
            dataList = statusByWorkstationList(workstationIdList);
        }
        if (CollectionUtil.isNotEmpty(dataList)) {
            for (StatusAnalysisWorkstationVO i : dataList) {
                if (Func.isBlank(i.getEndTime())) {
                    total = minusMin(DateUtil.parse(i.getStartTime(), DateConstant.PATTERN_DATE_TIME), new Date());
                } else {
                    total = minusMin(DateUtil.parse(i.getStartTime(), DateConstant.PATTERN_DATE_TIME), DateUtil.parse(i.getEndTime(), DateConstant.PATTERN_DATE_TIME));
                }
                if (initMap.containsKey(i.getStatus())) {
                    initMap.put(i.getStatus(), Long.valueOf(new BigDecimal(initMap.get(i.getStatus()).longValue()).add(new BigDecimal(total.longValue())).longValue()));
                }
            }
        }
        List<StatusTimeTotalDetailVO> resultList = dealData(initMap, totalTime, dictBizMap);
        result.setTotalTime(totalTime);
        result.setList(resultList);
        return result;
    }

    @Override // org.springblade.modules.mdc.service.IWorkstationAnalysisService
    public List<StatusAnalysisWorkstationVO> statusByWorkstationList(List<Long> workstationIdList) {
        String startTime = LocalDateTimeUtils.formatTime(LocalDateTime.of(LocalDate.now(), LocalTime.MIN), DateConstant.PATTERN_DATE_TIME);
        String endTime = LocalDateTimeUtils.formatTime(LocalDateTime.of(LocalDate.now(), LocalTime.MAX), DateConstant.PATTERN_DATE_TIME);
        List<StatusAnalysisWorkstationVO> result = new ArrayList<>();
        try {
            List<StatusAnalysisWorkstationVO> result1 = this.superAggregateStateMapper.statusByWorkstationList(workstationIdList, startTime, endTime);
            List<StatusAnalysisWorkstationVO> result2 = this.superAggregateStateMapper.statusByWorkstationListByNull(workstationIdList, startTime);
            result.addAll(result1);
            result.addAll(result2);
        } catch (Exception e) {
            result = new ArrayList<>();
        }
        result.forEach(i -> {
            i.setStartTime(timeStamp2Date(i.getStartDate(), DateConstant.PATTERN_DATE_TIME));
            i.setEndTime(timeStamp2Date(i.getEndDate(), DateConstant.PATTERN_DATE_TIME));
        });
        return result;
    }

    @Override // org.springblade.modules.mdc.service.IWorkstationAnalysisService
    public List<DeviceStatusStatisticsVO> deviceStatusStatistics() {
        List<GlobalWcs> wcsList = WorkstationCache.getDefaultWcs();
        List<Workstation> workstationList = this.workstationService.list(Wrappers.<Workstation>lambdaQuery()
                .eq(Workstation::getType, WorkstationTypeEnum.MACHINE.getCode())
                .eq(Workstation::getStatus, TrayEnum.StatusEnum.ACTIVATING.getStatus()));
        /*
        List<Workstation> workstationList = this.workstationService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getType();
        }, WorkstationTypeEnum.MACHINE.getCode())).eq((v0) -> {
            return v0.getStatus();
        }, TrayEnum.StatusEnum.ACTIVATING.getStatus()));*/
        if (Func.isEmpty(workstationList)) {
            return wcsList.stream().map(c -> {
                return DeviceStatusStatisticsVO.builder().status(c.getCode()).statusName(c.getName()).deviceNum(0L).build();
            }).collect(Collectors.toList());
        }
        Set<String> wIds =  workstationList.stream().map((v0) -> {
            return v0.getId();
        }).map((v0) -> {
            return String.valueOf(v0);
        }).collect(Collectors.toSet());
        Map<String, Long> deviceMap = wIds.stream().map(wId -> {
            Map<String, Object> realTimeData = WorkstationCache.getWorkstationAllCollect(wId);
            WorkstationWcsDmpDTO dmpDTO = WorkstationCache.getDmpStatus(wId);
            if (Func.isNotEmpty(realTimeData) && Func.notNull(dmpDTO) && realTimeData.containsKey(dmpDTO.getName())) {
                TelemetryDataResponseDTO dto = (TelemetryDataResponseDTO) realTimeData.get(dmpDTO.getName());
                return dto.getV();
            }
            List<WorkstationCollectData> workstationCollectData = this.superProcessParameterMapper.queryLastParameter(wId);
            if (Func.isNotEmpty(workstationCollectData)) {
                Map<String, Object> resultMapping = workstationCollectData.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getN();
                }, item -> {
                    TelemetryDataResponseDTO result = new TelemetryDataResponseDTO();
                    result.setT(item.getTs());
                    result.setV(item.getV());
                    return result;
                }));
                if (Func.isNotEmpty(resultMapping) && Func.notNull(dmpDTO) && resultMapping.containsKey(dmpDTO.getName())) {
                    TelemetryDataResponseDTO dto2 = (TelemetryDataResponseDTO) resultMapping.get(dmpDTO.getName());
                    return dto2.getV();
                }
                return null;
            }
            return null;
        }).filter((v0) -> {
            return Func.notNull(v0);
        }).collect(Collectors.groupingBy(c2 -> {
            return c2;
        }, Collectors.counting()));
        return wcsList.stream().map(w -> {
            return DeviceStatusStatisticsVO.builder().status(w.getCode()).statusName(w.getName()).deviceNum((Long) deviceMap.getOrDefault(w.getCode(), 0L)).build();
        }).collect(Collectors.toList());
    }

    private Map<String, Long> getInitMap(List<GlobalWcs> list) {
        Map<String, Long> initMap = new HashMap<>(list.size());
        list.forEach(i -> {
            initMap.put(i.getCode(), 0L);
        });
        return initMap;
    }

    public static String timeStamp2Date(Timestamp seconds, String format) {
        if (seconds == null) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format((Date) seconds);
    }

    private String formatTime(Long minuteStr) {
        String resultStr;
        if (!Func.isEmpty(minuteStr)) {
            if (minuteStr.longValue() != 0) {
                if (minuteStr.longValue() / 60 == 0) {
                    resultStr = (minuteStr.longValue() % 60) + "分";
                } else if (minuteStr.longValue() % 60 == 0) {
                    resultStr = (minuteStr.longValue() / 60) + "小时";
                } else {
                    resultStr = (minuteStr.longValue() / 60) + "小时" + (minuteStr.longValue() % 60) + "分";
                }
            } else {
                resultStr = "0时0分";
            }
        } else {
            resultStr = "0时0分";
        }
        return resultStr;
    }

    private List<StatusTimeTotalDetailVO> dealData(Map<String, Long> initMap, Long totalTime, Map<String, String> dictBizMap) {
        List<StatusTimeTotalDetailVO> resultList = new ArrayList<>();
        for (Map.Entry<String, Long> entry : initMap.entrySet()) {
            StatusTimeTotalDetailVO vo = new StatusTimeTotalDetailVO();
            vo.setStatus(entry.getKey());
            vo.setStatusTotalTime(entry.getValue());
            if (dictBizMap.containsKey(entry.getKey())) {
                vo.setStatusName(dictBizMap.get(entry.getKey()));
            }
            if (totalTime.compareTo((Long) 0L) == 0) {
                vo.setProportion(new BigDecimal("0"));
            } else {
                vo.setProportion(new BigDecimal(entry.getValue().longValue()).divide(new BigDecimal(totalTime.longValue()), 2, 4).multiply(new BigDecimal(100)));
            }
            vo.setShowTotalTime(formatTime(entry.getValue()));
            resultList.add(vo);
        }
        return resultList;
    }

    private List<DeviceStatusStatisticsVO> dealData(Map<String, Long> initMap, Map<String, String> dictBizMap) {
        List<DeviceStatusStatisticsVO> resultList = new ArrayList<>();
        for (Map.Entry<String, Long> entry : initMap.entrySet()) {
            DeviceStatusStatisticsVO vo = new DeviceStatusStatisticsVO();
            vo.setStatus(entry.getKey());
            vo.setDeviceNum(entry.getValue());
            if (dictBizMap.containsKey(entry.getKey())) {
                vo.setStatusName(dictBizMap.get(entry.getKey()));
            }
            resultList.add(vo);
        }
        return resultList;
    }

    private Long minusMin(Date startTime, Date endTime) {
        Long start = Long.valueOf(startTime.getTime());
        Long end = Long.valueOf(endTime.getTime());
        Long min = Long.valueOf(((end.longValue() - start.longValue()) / 1000) / 60);
        return min;
    }
}