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

import java.util.List;
import java.util.Map;
import org.apache.commons.compress.utils.Lists;
import com.qianwen.smartman.common.cache.cps.EmployeeCache;
import com.qianwen.smartman.common.cache.cps.WorkstationCache;
import com.qianwen.smartman.common.utils.ListUtils;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.smartman.modules.cps.dto.EmployeeDTO;
import com.qianwen.smartman.modules.cps.dto.WorkstationDTO;
import com.qianwen.smartman.modules.cps.vo.EmployeeVO;
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateOutput;
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateState;
import com.qianwen.smartman.modules.mdc.enums.OpenTypeEnums;
import com.qianwen.smartman.modules.mdc.service.ISuperAggregateOutputService;
import com.qianwen.smartman.modules.mdc.service.ISuperAggregateStateService;
import com.qianwen.smartman.modules.mdc.utils.FilterOffUtils;
import com.qianwen.smartman.modules.perf.dto.EmployeePerfDTO;
import com.qianwen.smartman.modules.perf.dto.WorkstationBO;
import com.qianwen.smartman.modules.perf.enums.QueryPerfEnum;
import com.qianwen.smartman.modules.perf.enums.QueryTimeEnum;
import com.qianwen.smartman.modules.perf.service.IEmployeeOnOffWorkService;
import com.qianwen.smartman.modules.perf.service.IEmployeePerfService;
import com.qianwen.smartman.modules.perf.vo.SearchEmployeeWorkVO;
import com.qianwen.smartman.modules.perf.vo.SearchPerfVO;
import com.qianwen.smartman.modules.perf.vo.SearchWorkEmployeeVO;
import com.qianwen.smartman.modules.perf.wrapper.PerfWrapper;
import org.springframework.stereotype.Service;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/perf/service/impl/EmployeePerfServiceImpl.class */
public class EmployeePerfServiceImpl implements IEmployeePerfService {
    private final IEmployeeOnOffWorkService workService;
    private final ISuperAggregateStateService stateService;
    private final ISuperAggregateOutputService outputService;

    public EmployeePerfServiceImpl(final IEmployeeOnOffWorkService workService, final ISuperAggregateStateService stateService, final ISuperAggregateOutputService outputService) {
        this.workService = workService;
        this.stateService = stateService;
        this.outputService = outputService;
    }

    @Override // org.springblade.modules.perf.service.IEmployeePerfService
    public List<Map<String, Object>> search(SearchPerfVO vo) {
        QueryPerfEnum perfEnum = vo.getPerfEnum();
        switch (perfEnum) {
            case EMPLOYEE_WORK:
                return employeeWork(vo);
            case EMPLOYEE_TIME:
                return employeeTime(vo);
            case WORK_EMPLOYEE:
                return workEmployee(vo);
            case WORK_TIME:
                return workTime(vo);
            default:
                return Lists.newArrayList();
        }
    }

    private List<Map<String, Object>> employeeWork(SearchPerfVO vo) {
        QueryTimeEnum timeEnum = vo.getTimeEnum();
        switch (timeEnum) {
            case DAY:
            case SHIFT:
                return queryPerfByEwDay(vo);
            case WEEK:
                return queryPerfByEwWeek(vo);
            case MONTH:
                return queryPerfByEwMonth(vo);
            default:
                return Lists.newArrayList();
        }
    }

    private List<Map<String, Object>> employeeTime(SearchPerfVO vo) {
        QueryTimeEnum timeEnum = vo.getTimeEnum();
        switch (timeEnum) {
            case DAY:
            case SHIFT:
                return queryPerfByEtDay(vo);
            case WEEK:
                return queryPerfByEtWeek(vo);
            case MONTH:
                return queryPerfByEtMonth(vo);
            default:
                return Lists.newArrayList();
        }
    }

    private List<Map<String, Object>> workEmployee(SearchPerfVO vo) {
        QueryTimeEnum timeEnum = vo.getTimeEnum();
        switch (timeEnum) {
            case DAY:
            case SHIFT:
                return queryPerfByWeDay(vo);
            case WEEK:
                return queryPerfByWeWeek(vo);
            case MONTH:
                return queryPerfByWeMonth(vo);
            default:
                return Lists.newArrayList();
        }
    }

    private List<Map<String, Object>> workTime(SearchPerfVO vo) {
        QueryTimeEnum timeEnum = vo.getTimeEnum();
        switch (timeEnum) {
            case DAY:
            case SHIFT:
                return queryPerfByWtDay(vo);
            case WEEK:
                return queryPerfByWtWeek(vo);
            case MONTH:
                return queryPerfByWtMonth(vo);
            default:
                return Lists.newArrayList();
        }
    }

    private EmployeePerfDTO queryPerfByDay(SearchPerfVO vo) {
        String startTime = DateUtil.formatDate(vo.getStartTime()).replaceAll("-", "");
        String endTime = DateUtil.formatDate(vo.getEndTime()).replaceAll("-", "");
        Long employeeId = vo.getEmployeeId();
        Long workstationId = vo.getWorkstationId();
        List<SuperAggregateState> states = this.stateService.queryPerfByDay(workstationId, startTime, endTime, employeeId);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByDay(workstationId, startTime, endTime, employeeId);
        return EmployeePerfDTO.builder().states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
    }

    private List<Map<String, Object>> queryPerfByEwDay(SearchPerfVO vo) {
        EmployeePerfDTO build = queryPerfByDay(vo);
        return PerfWrapper.build().ewDay(build, vo.getStartTime(), vo.getEndTime());
    }

    private List<Map<String, Object>> queryPerfByWeDay(SearchPerfVO vo) {
        EmployeePerfDTO build = queryPerfByDay(vo);
        return PerfWrapper.build().ewDay(build, vo.getStartTime(), vo.getEndTime());
    }

    private EmployeePerfDTO queryPerfByWeek(SearchPerfVO vo) {
        Long employeeId = vo.getEmployeeId();
        List<Integer> weeks = vo.getWeeks();
        Long workstationId = vo.getWorkstationId();
        List<SuperAggregateState> states = this.stateService.queryPerfByWeek(workstationId, weeks, employeeId);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByWeek(workstationId, weeks, employeeId);
        return EmployeePerfDTO.builder().states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
    }

    private List<Map<String, Object>> queryPerfByEwWeek(SearchPerfVO vo) {
        EmployeePerfDTO build = queryPerfByWeek(vo);
        return PerfWrapper.build().ewWeek(build, vo.getWeeks());
    }

    private List<Map<String, Object>> queryPerfByWeWeek(SearchPerfVO vo) {
        EmployeePerfDTO build = queryPerfByWeek(vo);
        return PerfWrapper.build().ewWeek(build, vo.getWeeks());
    }

    private EmployeePerfDTO queryPerfByMonth(SearchPerfVO vo) {
        Long employeeId = vo.getEmployeeId();
        List<Integer> months = vo.getMonths();
        Long workstationId = vo.getWorkstationId();
        List<SuperAggregateState> states = this.stateService.queryPerfByMonth(workstationId, months, employeeId);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByMonth(workstationId, months, employeeId);
        return EmployeePerfDTO.builder().states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
    }

    private List<Map<String, Object>> queryPerfByEwMonth(SearchPerfVO vo) {
        EmployeePerfDTO build = queryPerfByMonth(vo);
        return PerfWrapper.build().ewMonth(build, vo.getMonths());
    }

    private List<Map<String, Object>> queryPerfByWeMonth(SearchPerfVO vo) {
        EmployeePerfDTO build = queryPerfByMonth(vo);
        return PerfWrapper.build().ewMonth(build, vo.getMonths());
    }

    private List<Map<String, Object>> queryPerfByEtDay(SearchPerfVO vo) {
        String time = DateUtil.formatDate(vo.getTime()).replaceAll("-", "");
        Long employeeId = vo.getEmployeeId();
        Map<String, WorkstationDTO> workstations = WorkstationCache.getWorkstations();
        List<SuperAggregateState> states = this.stateService.queryPerfByEtDay(employeeId, time);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByEtDay(employeeId, time);
        EmployeePerfDTO build = EmployeePerfDTO.builder().works(workstations).states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
        return PerfWrapper.build().etBuild(build);
    }

    private List<Map<String, Object>> queryPerfByEtWeek(SearchPerfVO vo) {
        Integer week = (Integer) ListUtils.getFirst(vo.getWeeks());
        Long employeeId = vo.getEmployeeId();
        Map<String, WorkstationDTO> workstations = WorkstationCache.getWorkstations();
        List<SuperAggregateState> states = this.stateService.queryPerfByEtWeek(employeeId, week);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByEtWeek(employeeId, week);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        EmployeePerfDTO build = EmployeePerfDTO.builder().works(workstations).states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
        return PerfWrapper.build().etBuild(build);
    }

    private List<Map<String, Object>> queryPerfByEtMonth(SearchPerfVO vo) {
        Integer month = (Integer) ListUtils.getFirst(vo.getMonths());
        Long employeeId = vo.getEmployeeId();
        Map<String, WorkstationDTO> workstations = WorkstationCache.getWorkstations();
        List<SuperAggregateState> states = this.stateService.queryPerfByEtMonth(employeeId, month);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByEtMonth(employeeId, month);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        EmployeePerfDTO build = EmployeePerfDTO.builder().works(workstations).states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
        return PerfWrapper.build().etBuild(build);
    }

    private List<Map<String, Object>> queryPerfByWtDay(SearchPerfVO vo) {
        String time = DateUtil.formatDate(vo.getTime()).replaceAll("-", "");
        Long workstationId = vo.getWorkstationId();
        Map<String, EmployeeDTO> employees = EmployeeCache.getEmployees();
        List<SuperAggregateState> states = this.stateService.queryPerfByWtDay(workstationId, time);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByWtDay(workstationId, time);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        EmployeePerfDTO build = EmployeePerfDTO.builder().employees(employees).states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
        return PerfWrapper.build().wtBuild(build);
    }

    private List<Map<String, Object>> queryPerfByWtWeek(SearchPerfVO vo) {
        Integer week = (Integer) ListUtils.getFirst(vo.getWeeks());
        Long workstationId = vo.getWorkstationId();
        Map<String, EmployeeDTO> employees = EmployeeCache.getEmployees();
        List<SuperAggregateState> states = this.stateService.queryPerfByWtWeek(workstationId, week);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByWtWeek(workstationId, week);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        EmployeePerfDTO build = EmployeePerfDTO.builder().employees(employees).states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
        return PerfWrapper.build().wtBuild(build);
    }

    private List<Map<String, Object>> queryPerfByWtMonth(SearchPerfVO vo) {
        Integer month = (Integer) ListUtils.getFirst(vo.getMonths());
        Long workstationId = vo.getWorkstationId();
        Map<String, EmployeeDTO> employees = EmployeeCache.getEmployees();
        List<SuperAggregateState> states = this.stateService.queryPerfByWtMonth(workstationId, month);
        List<SuperAggregateOutput> outputs = this.outputService.queryPerfByWtMonth(workstationId, month);
        List<SuperAggregateState> states2 = FilterOffUtils.filterOffDay(states, OpenTypeEnums.TIME_USED_ANALYSIS);
        EmployeePerfDTO build = EmployeePerfDTO.builder().employees(employees).states(states2).outputs(FilterOffUtils.filterOffDay(outputs, OpenTypeEnums.OUT_PUT)).build();
        return PerfWrapper.build().wtBuild(build);
    }

    @Override // org.springblade.modules.perf.service.IEmployeePerfService
    public List<WorkstationBO> employeeWork(SearchEmployeeWorkVO vo) {
        return this.workService.employeeWork(vo);
    }

    @Override // org.springblade.modules.perf.service.IEmployeePerfService
    public List<EmployeeVO> workEmployee(SearchWorkEmployeeVO vo) {
        return this.workService.workEmployee(vo);
    }
}