package org.jeecg.modules.lims.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.DateUtils;
import org.jeecg.modules.lims.api.JeecgSystemClient;
import org.jeecg.modules.lims.entity.*;
import org.jeecg.modules.lims.service.*;
import org.jeecg.modules.lims.vo.LimsInsUseStatVo;
import org.jeecg.modules.lims.vo.LimsInspectionRecordVo;
import org.jeecgframework.poi.excel.def.MapExcelConstants;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.params.ExcelExportEntity;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.jeecgframework.poi.excel.view.JeecgMapExcelView;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
 * 数据统计
 */
@RestController
@RequestMapping("/lims/stat")
@Slf4j
public class LimsStatController {
    @Autowired
    private ILimsUsageRecordService limsUsageRecordService;

    @Autowired
    private ILimsInstrumentService instrumentService;

    @Autowired
    private JeecgSystemClient jeecgSystemClient;

    @Autowired
    private ILimsInspectionService limsInspectionService;
    @Autowired
    private ILimsInspectionDetailService detailService;


    @Autowired
    private ILimsAppointmentOptionService appointmentOptionService;

    @Autowired
    private ILimsRepairRecordService repairRecordService;



    @GetMapping(value = "/insUse")
    public Result<List<Map<String, Object>>> queryInstrumentUse(LimsUsageRecord limsUsageRecord,
                                                                HttpServletRequest req) {
        Result<List<Map<String, Object>>> result = new Result<>();
        List<Map<String, Object>> res = new ArrayList<>();
        QueryWrapper<LimsUsageRecord> queryWrapper = QueryGenerator.initQueryWrapper(limsUsageRecord, req.getParameterMap());
        //根据自定义使用状态查询
        if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 1) {
            queryWrapper.lambda().isNull(LimsUsageRecord::getAppointment);
        } else if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 2) {
            queryWrapper.lambda().isNotNull(LimsUsageRecord::getAppointment);
        }
        List<LimsUsageRecord> list = limsUsageRecordService.list(queryWrapper);
        //过滤未完成数据
        List<LimsUsageRecord> useList = list.stream().filter(item -> item.getStatus() != null && item.getStatus() == 2).collect(Collectors.toList());
        useList.stream().forEach(i -> {
            //计算使用时间
            calcUseTime(i);
            //查询设备
            LimsInstrument instrument = instrumentService.getById(i.getInstrument());
            i.setLimsInstrument(instrument);
            //是否预约使用
            if (i.getAppointment() != null) {
                //设置为预约使用
                i.setUseType(2);
            }
        });
        //过滤没有使用时间的异常数据
        useList = useList.stream().filter(item -> item.getSecond() > 0).collect(Collectors.toList());
        //根据设备分组
        Map<String, List<LimsUsageRecord>> gList = useList.stream().collect(Collectors.groupingBy(i -> i.getInstrument()));
        gList.forEach((insName, insList) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("id", insName);
            //设备名称
            map.put("instrument", insList.get(0).getLimsInstrument().getName());
            //预约使用总数
            long appoUse = insList.stream().filter(i -> i.getUseType() != null && i.getUseType() == 2).count();
            map.put("appoUse", appoUse);
            //临时使用
            map.put("tempUse", insList.size() - appoUse);

            //预约使用时间
            Double appoUseTime = insList.stream().filter(i -> i.getUseType() != null && i.getUseType() == 2).mapToDouble(LimsUsageRecord::getSecond).sum();
            map.put("appoUseTime", appoUseTime);
            map.put("appoUseTimeStr", DateUtils.secToTime(appoUseTime.intValue()));

            //临时使用时间
            Double tempUseTime = insList.stream().filter(i -> i.getUseType() == null).mapToDouble(LimsUsageRecord::getSecond).sum();

            map.put("tempUseTime", tempUseTime);
            map.put("tempUseTimeStr", DateUtils.secToTime(tempUseTime.intValue()));

            //总使用时间
            Double useTime = insList.stream().mapToDouble(LimsUsageRecord::getSecond).sum();
            map.put("useTime", useTime);
            map.put("useTimeStr", DateUtils.secToTime(useTime.intValue()));
            res.add(map);

        });
        result.setResult(res);

        return result.success("查询成功!");
    }


    @GetMapping(value = "/userUse")
    public Result<List<Map<String, Object>>> queryUserUse(LimsUsageRecord limsUsageRecord,
                                                          HttpServletRequest req) {
        Result<List<Map<String, Object>>> result = new Result<>();
        List<Map<String, Object>> res = new ArrayList<>();
        QueryWrapper<LimsUsageRecord> queryWrapper = QueryGenerator.initQueryWrapper(limsUsageRecord, req.getParameterMap());
        //根据自定义使用状态查询
        if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 1) {
            queryWrapper.lambda().isNull(LimsUsageRecord::getAppointment);
        } else if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 2) {
            queryWrapper.lambda().isNotNull(LimsUsageRecord::getAppointment);
        }
        List<LimsUsageRecord> list = limsUsageRecordService.list(queryWrapper);
        //过滤未完成数据
        list = list.stream().filter(item -> item.getStatus() != null && item.getStatus() == 2).collect(Collectors.toList());
        list.stream().forEach(i -> {
            //计算使用时间
            calcUseTime(i);
            //查询设备
            LimsInstrument instrument = instrumentService.getById(i.getInstrument());
            i.setLimsInstrument(instrument);
            i.setInstrument(instrument.getName());
            //是否预约使用
            if (i.getAppointment() != null) {
                //设置为预约使用
                i.setUseType(2);
            }
            SysUser user = jeecgSystemClient.queryByUserName(i.getCreateBy()).getResult();
            //设置用户名为真实姓名
            if (!StringUtils.isEmpty(user.getRealname())) {
                i.setCreateBy(user.getRealname());
            }

        });
        //列出所有仪器
        Map<String, List<LimsUsageRecord>> allInsMap = list.stream().collect(Collectors.groupingBy(i -> i.getInstrument()));


        //根据用户、设备分组
        Map<String, Map<String, List<LimsUsageRecord>>> userMap = list.stream().collect(Collectors.groupingBy(i -> i.getCreateBy(), Collectors.groupingBy(t -> t.getInstrument())));


        AtomicReference<Integer> id = new AtomicReference<>(0);

        //制作table colmuns
        List<Map<String, Object>> colmuns = new ArrayList<>();
        allInsMap.forEach((name, alist) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("name", name);
            map.put("useTime", name + "time");
            colmuns.add(map);
        });

        userMap.forEach((user, insMap) -> {
            Map<String, Object> item = new HashMap<>();
            item.put("id", id.getAndSet(id.get() + 1));
            item.put("user", user);
            allInsMap.forEach((allIns, allInsValue) -> {
//                insMap.forEach((ins,ilist)->{
//                });

                if (insMap.containsKey(allIns)) {
                    Double sum = insMap.get(allIns).stream().mapToDouble(LimsUsageRecord::getSecond).sum();
                    item.put(allIns, sum);
                    String useTime = DateUtils.secToTime(sum.intValue());
                    item.put(allIns + "time", useTime);
                } else {
                    item.put(allIns, 0);
                    item.put(allIns + "time", 0);
                }

            });
            res.add(item);
        });
        result.setResult(res);
        result.setResultExt(colmuns);
        return result;
    }


    @GetMapping(value = "/spot")
    public Result<?> querySpotList(LimsInspection limsInspection,
                                   HttpServletRequest req) {

        QueryWrapper<LimsInspection> queryWrapper = QueryGenerator.initQueryWrapper(limsInspection, req.getParameterMap());

        List<LimsInspection> pageList = limsInspectionService.list(queryWrapper);
        List<LimsInspectionRecordVo> listVo = new ArrayList<>();
        pageList.stream().forEach(i -> {
            LimsInspectionRecordVo vo = new LimsInspectionRecordVo();
            BeanUtils.copyProperties(i, vo);
            listVo.add(vo);
        });

        Set<String> ids = listVo.stream().map(LimsInspectionRecordVo::getId).collect(Collectors.toSet());
        Set<String> instrumentIds = listVo.stream().map(LimsInspectionRecordVo::getInstrumentId).collect(Collectors.toSet());
        if (ids != null && ids.size() > 0) {
            List<LimsInspectionDetail> list = detailService.list(new LambdaQueryWrapper<LimsInspectionDetail>().in(LimsInspectionDetail::getPid, ids));
            Map<String, List<LimsInspectionDetail>> listMap = list.stream().collect(Collectors.groupingBy(LimsInspectionDetail::getPid, Collectors.toList()));
            listVo.stream().map(item -> {
                item.setItems(listMap.get(item.getId()));
                //计算点检结果
                List<LimsInspectionDetail> items = item.getItems();
                if (items != null && items.size() > 0) {
                    int result = 1;
                    for (int i = 0; i < items.size(); i++) {
                        LimsInspectionDetail detail = items.get(i);
                        if (detail.getResult() == null || detail.getResult() == 0) {
                            result = 0;
                        }
                    }
                    item.setResult(result);
                } else {
                    item.setResult(0);
                }

                return item;
            }).collect(Collectors.toList());
        }
        //查询设备名称
        if (instrumentIds != null && instrumentIds.size() > 0) {
            List<LimsInstrument> list = instrumentService.list(new LambdaQueryWrapper<LimsInstrument>().in(LimsInstrument::getId, instrumentIds));
            Map<String, String> map = list.stream().collect(Collectors.toMap(LimsInstrument::getId, LimsInstrument::getName));
            listVo.stream().map(item -> {
                item.setInstrument(map.get(item.getInstrumentId()));
                return item;
            }).collect(Collectors.toList());
        }
        //按照设备分组，统计设备点检成功和失败次数
        Map<String, List<LimsInspectionRecordVo>> insMap = listVo.stream().collect(Collectors.groupingBy(i -> i.getInstrument()));
        List<Map<String, Object>> result = new ArrayList<>();
        AtomicInteger id = new AtomicInteger();
        insMap.forEach((k, v) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("instrument", k);
            Long count = v.stream().filter(i -> i.getResult() != null && i.getResult() == 1).count();
            map.put("ok", count.intValue());
            map.put("un", v.size() - count);
            map.put("total", count);
            map.put("id", id.getAndIncrement());
            result.add(map);
        });

        return Result.OK(result);
    }


    @GetMapping(value = "/repair")
    public Result<?> queryPageList(LimsRepairRecord limsRepairRecord, HttpServletRequest req) {
        QueryWrapper<LimsRepairRecord> queryWrapper = QueryGenerator.initQueryWrapper(limsRepairRecord, req.getParameterMap());
        List<LimsRepairRecord> pageList = repairRecordService.list(queryWrapper);

        Set<String> instrumentIds = pageList.stream().map(LimsRepairRecord::getInstrument).collect(Collectors.toSet());
        if (instrumentIds != null && instrumentIds.size() > 0) {
            LambdaUpdateWrapper<LimsInstrument> qw = new LambdaUpdateWrapper<>();
            qw.in(LimsInstrument::getId, instrumentIds);
            List<LimsInstrument> list = instrumentService.list(qw);
            Map<String, String> instrments = list.stream().collect(Collectors.toMap(item -> item.getId(), item -> item.getName()));
            for (LimsRepairRecord r : pageList) {
                r.setInstrumentName(instrments.get(r.getInstrument()));
                //设置报修人部门
               /* List<DepartIdModel> departs = jeecgSystemClient.getUserDepartsListByName(r.getCreateBy()).getResult();
                if(departs!=null && departs.size() > 0){
                    String depart = departs.get(0).getTitle();
                    r.setDepart(depart);
                }*/
            }
        }

        Map<String, List<LimsRepairRecord>> collect = pageList.stream().collect(Collectors.groupingBy(i -> i.getInstrumentName()));
        List<Map<String, Object>> result = new ArrayList<>();
        AtomicInteger id = new AtomicInteger();
        collect.forEach((k, v) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("instrument", k);
            map.put("total", v.size());
            map.put("id", id.getAndIncrement());
            result.add(map);
        });
        return Result.OK(result);
    }


    /**
     * 小数点保留两位
     *
     * @param t
     * @return
     */
    private double scale(double t) {
        BigDecimal bigDecimal = new BigDecimal(t);
        double useTime = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        return useTime;
    }


    /**
     * 计算使用时间
     */
    private void calcUseTime(LimsUsageRecord item) {
        if (item.getCreateTime() != null && item.getUpdateTime() != null) {
            //使用时间
            long smillis = DateUtils.getMillis(item.getCreateTime());
            long emillis = DateUtils.getMillis(item.getUpdateTime());
            int sec = (int) ((emillis - smillis) / 1000);
            String useTime = DateUtils.secToTime(sec);
            item.setUseTimeStr(useTime);
            double t = sec / 60.0;
            BigDecimal bigDecimal = new BigDecimal(t);
            double time = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            item.setSecond(sec);
        }
    }


    @RequestMapping(value = "/exportInsXls")
    public ModelAndView exportInsXls(HttpServletRequest request, LimsUsageRecord limsUsageRecord) {
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        QueryWrapper<LimsUsageRecord> queryWrapper = QueryGenerator.initQueryWrapper(limsUsageRecord, request.getParameterMap());
        //根据自定义使用状态查询
        if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 1) {
            queryWrapper.lambda().isNull(LimsUsageRecord::getAppointment);
        } else if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 2) {
            queryWrapper.lambda().isNotNull(LimsUsageRecord::getAppointment);
        }
        List<LimsUsageRecord> list = limsUsageRecordService.list(queryWrapper);
        //过滤未完成数据
        List<LimsUsageRecord> useList = list.stream().filter(item -> item.getStatus() != null && item.getStatus() == 2).collect(Collectors.toList());
        useList.stream().forEach(i -> {
            //计算使用时间
            calcUseTime(i);
            //查询设备
            LimsInstrument instrument = instrumentService.getById(i.getInstrument());
            i.setLimsInstrument(instrument);
            //是否预约使用
            if (i.getAppointment() != null) {
                //设置为预约使用
                i.setUseType(2);
            }
        });
        //过滤没有使用时间的异常数据
        useList = useList.stream().filter(item -> item.getSecond() > 0).collect(Collectors.toList());
        //根据设备分组
        Map<String, List<LimsUsageRecord>> gList = useList.stream().collect(Collectors.groupingBy(i -> i.getInstrument()));
        List<LimsInsUseStatVo> result = new ArrayList<>();
        gList.forEach((insName, insList) -> {
            LimsInsUseStatVo vo = new LimsInsUseStatVo();
            Map<String, Object> map = new HashMap<>();
            map.put("id", insName);
            vo.setInstrument(insList.get(0).getLimsInstrument().getName());
            //设备名称
            map.put("instrument", insList.get(0).getLimsInstrument().getName());
            //预约使用总数
            Long appoUse = insList.stream().filter(i -> i.getUseType() != null && i.getUseType() == 2).count();
            map.put("appoUse", appoUse);
            vo.setAppoUse(appoUse.intValue());
            //临时使用
            map.put("tempUse", insList.size() - appoUse);
            vo.setTempUse((int) (insList.size() - appoUse));
            //预约使用时间
            Double appoUseTime = insList.stream().filter(i -> i.getUseType() != null && i.getUseType() == 2).mapToDouble(LimsUsageRecord::getSecond).sum();
            map.put("appoUseTime", appoUseTime);
            map.put("appoUseTimeStr", DateUtils.secToTime(appoUseTime.intValue()));
            vo.setAppoUseTime(DateUtils.secToTime(appoUseTime.intValue()));

            //临时使用时间
            Double tempUseTime = insList.stream().filter(i -> i.getUseType() == null).mapToDouble(LimsUsageRecord::getSecond).sum();

            map.put("tempUseTime", tempUseTime);
            map.put("tempUseTimeStr", DateUtils.secToTime(tempUseTime.intValue()));
            vo.setTempUseTime(DateUtils.secToTime(tempUseTime.intValue()));

            //总使用时间
            Double useTime = insList.stream().mapToDouble(LimsUsageRecord::getSecond).sum();
            map.put("useTime", useTime);
            map.put("useTimeStr", DateUtils.secToTime(useTime.intValue()));
            vo.setUseTime(DateUtils.secToTime(useTime.intValue()));
            result.add(vo);

        });


        String title = "仪器使用统计";

        //导出文件名称
        mv.addObject(NormalExcelConstants.FILE_NAME, title);
        //注解对象Class
        mv.addObject(NormalExcelConstants.CLASS, LimsInsUseStatVo.class);

        //自定义表格参数
        ExportParams exportParams = new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title);

        mv.addObject(NormalExcelConstants.PARAMS, exportParams);
        //导出数据列表
        mv.addObject(NormalExcelConstants.DATA_LIST, result);
        return mv;
    }


    @RequestMapping(value = "/exportUserXls")
    public ModelAndView exportUserXls(HttpServletRequest req, LimsUsageRecord limsUsageRecord) {

        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        List<Map<String, Object>> res = new ArrayList<>();
        QueryWrapper<LimsUsageRecord> queryWrapper = QueryGenerator.initQueryWrapper(limsUsageRecord, req.getParameterMap());
        //根据自定义使用状态查询
        if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 1) {
            queryWrapper.lambda().isNull(LimsUsageRecord::getAppointment);
        } else if (limsUsageRecord.getUseType() != null && limsUsageRecord.getUseType() == 2) {
            queryWrapper.lambda().isNotNull(LimsUsageRecord::getAppointment);
        }
        List<LimsUsageRecord> list = limsUsageRecordService.list(queryWrapper);
        //过滤未完成数据
        list = list.stream().filter(item -> item.getStatus() != null && item.getStatus() == 2).collect(Collectors.toList());
        list.stream().forEach(i -> {
            //计算使用时间
            calcUseTime(i);
            //查询设备
            LimsInstrument instrument = instrumentService.getById(i.getInstrument());
            i.setLimsInstrument(instrument);
            i.setInstrument(instrument.getName());
            //是否预约使用
            if (i.getAppointment() != null) {
                //设置为预约使用
                i.setUseType(2);
            }
            SysUser user = jeecgSystemClient.queryByUserName(i.getCreateBy()).getResult();
            //设置用户名为真实姓名
            if (!StringUtils.isEmpty(user.getRealname())) {
                i.setCreateBy(user.getRealname());
            }

        });
        //列出所有仪器
        Map<String, List<LimsUsageRecord>> allInsMap = list.stream().collect(Collectors.groupingBy(i -> i.getInstrument()));


        //根据用户、设备分组
        Map<String, Map<String, List<LimsUsageRecord>>> userMap = list.stream().collect(Collectors.groupingBy(i -> i.getCreateBy(), Collectors.groupingBy(t -> t.getInstrument())));


        AtomicReference<Integer> id = new AtomicReference<>(0);

        //制作table colmuns
        List<Map<String, Object>> colmuns = new ArrayList<>();
        allInsMap.forEach((name, alist) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("name", name);
            map.put("useTime", name + "time");
            colmuns.add(map);
        });
        // 设置表头样式
        List<ExcelExportEntity> filedsList = new ArrayList<>();
        filedsList.add(new ExcelExportEntity("姓名", "user"));


        userMap.forEach((user, insMap) -> {
            Map<String, Object> item = new HashMap<>();
            item.put("id", id.getAndSet(id.get() + 1));
            item.put("user", user);
            allInsMap.forEach((allIns, allInsValue) -> {
//                insMap.forEach((ins,ilist)->{
//                });

                if (insMap.containsKey(allIns)) {
                    Double sum = insMap.get(allIns).stream().mapToDouble(LimsUsageRecord::getSecond).sum();
                    item.put(allIns, sum);
                    String useTime = DateUtils.secToTime(sum.intValue());
                    item.put(allIns + "time", useTime);
                    filedsList.add(new ExcelExportEntity(allIns, allIns+ "time"));

                } else {
                    item.put(allIns, 0);
                    item.put(allIns + "time", 0);
                }

            });
            res.add(item);
        });

        String title = "用户使用统计";
        ModelAndView mv = new ModelAndView(new JeecgMapExcelView());
        //导出文件名称
        mv.addObject(MapExcelConstants.FILE_NAME, title);
        //自定义表格参数
        ExportParams exportParams = new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title);
        mv.addObject(NormalExcelConstants.PARAMS, exportParams);
        //导出数据列表
        mv.addObject(MapExcelConstants.MAP_LIST, res);
        mv.addObject(MapExcelConstants.ENTITY_LIST, filedsList);
        return mv;
    }


    @RequestMapping(value = "/exportSpotXls")
    public ModelAndView exportSpotXls(LimsInspection limsInspection,
                                      HttpServletRequest req) {
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        QueryWrapper<LimsInspection> queryWrapper = QueryGenerator.initQueryWrapper(limsInspection, req.getParameterMap());

        List<LimsInspection> pageList = limsInspectionService.list(queryWrapper);
        List<LimsInspectionRecordVo> listVo = new ArrayList<>();
        pageList.stream().forEach(i -> {
            LimsInspectionRecordVo vo = new LimsInspectionRecordVo();
            BeanUtils.copyProperties(i, vo);
            listVo.add(vo);
        });

        Set<String> ids = listVo.stream().map(LimsInspectionRecordVo::getId).collect(Collectors.toSet());
        Set<String> instrumentIds = listVo.stream().map(LimsInspectionRecordVo::getInstrumentId).collect(Collectors.toSet());
        if (ids != null && ids.size() > 0) {
            List<LimsInspectionDetail> list = detailService.list(new LambdaQueryWrapper<LimsInspectionDetail>().in(LimsInspectionDetail::getPid, ids));
            Map<String, List<LimsInspectionDetail>> listMap = list.stream().collect(Collectors.groupingBy(LimsInspectionDetail::getPid, Collectors.toList()));
            listVo.stream().map(item -> {
                item.setItems(listMap.get(item.getId()));
                //计算点检结果
                List<LimsInspectionDetail> items = item.getItems();
                if (items != null && items.size() > 0) {
                    int result = 1;
                    for (int i = 0; i < items.size(); i++) {
                        LimsInspectionDetail detail = items.get(i);
                        if (detail.getResult() == null || detail.getResult() == 0) {
                            result = 0;
                        }
                    }
                    item.setResult(result);
                } else {
                    item.setResult(0);
                }

                return item;
            }).collect(Collectors.toList());
        }
        //查询设备名称
        if (instrumentIds != null && instrumentIds.size() > 0) {
            List<LimsInstrument> list = instrumentService.list(new LambdaQueryWrapper<LimsInstrument>().in(LimsInstrument::getId, instrumentIds));
            Map<String, String> map = list.stream().collect(Collectors.toMap(LimsInstrument::getId, LimsInstrument::getName));
            listVo.stream().map(item -> {
                item.setInstrument(map.get(item.getInstrumentId()));
                return item;
            }).collect(Collectors.toList());
        }
        //按照设备分组，统计设备点检成功和失败次数
        Map<String, List<LimsInspectionRecordVo>> insMap = listVo.stream().collect(Collectors.groupingBy(i -> i.getInstrument()));
        List<Map<String, Object>> result = new ArrayList<>();
        AtomicInteger id = new AtomicInteger();
        insMap.forEach((k, v) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("instrument", k);
            Long count = v.stream().filter(i -> i.getResult() != null && i.getResult() == 1).count();
            map.put("ok", count.intValue());
            map.put("un", v.size() - count);
            map.put("total", count);
            map.put("id", id.getAndIncrement());
            result.add(map);
        });


        String title = "点检统计";
        ModelAndView mv = new ModelAndView(new JeecgMapExcelView());
        //导出文件名称
        mv.addObject(MapExcelConstants.FILE_NAME, title);
        //自定义表格参数
        ExportParams exportParams = new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title);
        mv.addObject(NormalExcelConstants.PARAMS, exportParams);
        //导出数据列表
        mv.addObject(MapExcelConstants.MAP_LIST, result);
        // 设置表头样式
        List<ExcelExportEntity> filedsList = new ArrayList<>();
        filedsList.add(new ExcelExportEntity("仪器", "instrument"));
        filedsList.add(new ExcelExportEntity("点检总数", "total"));
        filedsList.add(new ExcelExportEntity("点检正常", "ok"));
        filedsList.add(new ExcelExportEntity("点检异常", "un"));

        mv.addObject(MapExcelConstants.ENTITY_LIST, filedsList);
        return mv;
    }


    @RequestMapping(value = "/exportRepairXls")
    public ModelAndView exportRepairXls(LimsRepairRecord limsRepairRecord,
                                      HttpServletRequest req) {
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        QueryWrapper<LimsRepairRecord> queryWrapper = QueryGenerator.initQueryWrapper(limsRepairRecord, req.getParameterMap());
        List<LimsRepairRecord> pageList = repairRecordService.list(queryWrapper);

        Set<String> instrumentIds = pageList.stream().map(LimsRepairRecord::getInstrument).collect(Collectors.toSet());
        if (instrumentIds != null && instrumentIds.size() > 0) {
            LambdaUpdateWrapper<LimsInstrument> qw = new LambdaUpdateWrapper<>();
            qw.in(LimsInstrument::getId, instrumentIds);
            List<LimsInstrument> list = instrumentService.list(qw);
            Map<String, String> instrments = list.stream().collect(Collectors.toMap(item -> item.getId(), item -> item.getName()));
            for (LimsRepairRecord r : pageList) {
                r.setInstrumentName(instrments.get(r.getInstrument()));
                //设置报修人部门
               /* List<DepartIdModel> departs = jeecgSystemClient.getUserDepartsListByName(r.getCreateBy()).getResult();
                if(departs!=null && departs.size() > 0){
                    String depart = departs.get(0).getTitle();
                    r.setDepart(depart);
                }*/
            }
        }

        Map<String, List<LimsRepairRecord>> collect = pageList.stream().collect(Collectors.groupingBy(i -> i.getInstrumentName()));
        List<Map<String, Object>> result = new ArrayList<>();
        AtomicInteger id = new AtomicInteger();
        collect.forEach((k, v) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("instrument", k);
            map.put("total", v.size());
            map.put("id", id.getAndIncrement());
            result.add(map);
        });


        String title = "点检统计";
        ModelAndView mv = new ModelAndView(new JeecgMapExcelView());
        //导出文件名称
        mv.addObject(MapExcelConstants.FILE_NAME, title);
        //自定义表格参数
        ExportParams exportParams = new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title);
        mv.addObject(NormalExcelConstants.PARAMS, exportParams);
        //导出数据列表
        mv.addObject(MapExcelConstants.MAP_LIST, result);
        // 设置表头样式
        List<ExcelExportEntity> filedsList = new ArrayList<>();
        filedsList.add(new ExcelExportEntity("仪器", "instrument"));
        filedsList.add(new ExcelExportEntity("报修次数", "total"));

        mv.addObject(MapExcelConstants.ENTITY_LIST, filedsList);
        return mv;
    }

}