package com.zd.security.controller;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zd.common.core.annotation.Log;
import com.zd.common.core.annotation.PreAuthorize;
import com.zd.common.core.log.BusinessType;
import com.zd.common.core.utils.BeanUtils;
import com.zd.common.core.web.controller.AbstractController;
import com.zd.model.domain.ResultData;
import com.zd.model.domain.per.PerFun;
import com.zd.model.domain.per.PerPrefix;
import com.zd.security.api.bo.CheckManageBo;
import com.zd.security.api.bo.QueryCheckManageListParam;
import com.zd.security.api.bo.QueryManageListParam;
import com.zd.security.api.vo.CheckHazardInfoVo;
import com.zd.security.api.vo.CheckManageListVo;
import com.zd.security.api.vo.CheckManageVo;
import com.zd.security.entity.*;
import com.zd.security.scope.DataPermission;
import com.zd.security.scope.DataPermissionAspect;
import com.zd.security.service.*;
import com.zd.security.service.impl.WordService;
import com.zd.system.api.feign.RemoteUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.Nullable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import java.util.stream.Collectors;

/**
 * <p>
 * 检查管理表 前端控制器
 * </p>
 *
 * @author hzw
 * @since 2023-04-21
 */
@Api(tags = "检查管理")
@RestController
@RequestMapping("/checkManage")
public class CheckManageController extends AbstractController {

    private Lock lock = new ReentrantLock();
    @Autowired
    private CheckManageService checkManageService;

    @Autowired
    private CheckHazardService checkHazardService;

    @Autowired
    private WordService wordService;

    @Autowired
    private CheckPlanService checkPlanService;

    @Autowired
    private CheckMemberService checkMemberService;

    @Autowired
    private CheckStaffUserService checkStaffUserService;

    @Autowired
    private RemoteUserService remoteUserService;

    /**
     * 添加计划管理
     *
     * @Param [checkManageBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @Log(title = "添加计划管理", businessType = BusinessType.INSERT)
    @ApiOperation("添加计划管理")
    @PostMapping(value = "/add")
    public ResultData add(@RequestBody CheckManageBo checkManageBo) {
        //参数检查
        paramCheck.notNull(checkManageBo).strNotEmpty(checkManageBo.getTitle()).notNull(checkManageBo.getCheckType())
                .notNull(checkManageBo.getCycleStartTime()).notNull(checkManageBo.getCycleEndTime());
        checkManageBo.setLoginUserName(getCurrentUserName());
        checkManageBo.setLoginUserId(getCurrentUserId());
        if (checkManageService.addcheckManage(checkManageBo)) {
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 修改检查管理
     *
     * @Param [checkManageBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @Log(title = "修改检查管理", businessType = BusinessType.UPDATE)
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_MANAGE + PerFun.EDIT,
                                    PerPrefix.SECURITY_CHECK_MANAGE_1 + PerFun.EDIT,
                                    PerPrefix.SECURITY_CHECK_MANAGE_2 + PerFun.EDIT,
                                    PerPrefix.SECURITY_CHECK_MANAGE_3 + PerFun.EDIT,
                                    PerPrefix.SECURITY_CHECK_MANAGE_4 + PerFun.EDIT})
    @ApiOperation("修改检查管理")
    @PutMapping(value = "/update")
    public ResultData update(@RequestBody CheckManageBo checkManageBo) {
        //参数检查
        paramCheck.notNull(checkManageBo).strNotEmpty(checkManageBo.getTitle()).notNull(checkManageBo.getCheckType());
        checkManageBo.setLoginUserName(getCurrentUserName());
        checkManageBo.setLoginUserId(getCurrentUserId());
        if(checkManageService.updateCheckManage(checkManageBo)){
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 小程序修改检查管理
     *
     * @Param [checkManageBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @Log(title = "小程序修改检查管理", businessType = BusinessType.UPDATE)
    @ApiOperation("小程序修改检查管理")
    @PutMapping(value = "/appUpdate")
    public ResultData appUpdate(@RequestBody CheckManageBo checkManageBo) {
        //参数检查
        paramCheck.notNull(checkManageBo).strNotEmpty(checkManageBo.getTitle()).notNull(checkManageBo.getCheckType());
        checkManageBo.setLoginUserName(getCurrentUserName());
        checkManageBo.setLoginUserId(getCurrentUserId());
        if(checkManageService.updateCheckManage(checkManageBo)){
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 通过id查询巡查管理
     *
     * @Param [id 巡查管理id]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("通过id查询巡查管理")
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_MANAGE + PerFun.QUERY,PerPrefix.SECURITY_CHECK_MANAGE_1 + PerFun.QUERY
            ,PerPrefix.SECURITY_CHECK_MANAGE_2 + PerFun.QUERY,PerPrefix.SECURITY_CHECK_MANAGE_3 + PerFun.QUERY})
    @GetMapping(value = "/findCheckManage")
    @ApiImplicitParam(name = "id", value = "巡查管理id", required = true, dataTypeClass = Long.class)
    public ResultData find(@RequestParam("id") Long id) {
        CheckManageVo checkManageVo = checkManageService.findCheckManage(id);
        return ResultData.success(checkManageVo);
    }

    /**
     * 小程序通过id查询巡查管理
     *
     * @Param [id 巡查管理id]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("小程序通过id查询巡查管理")
    @GetMapping(value = "/appFindCheckManage")
    @ApiImplicitParam(name = "id", value = "巡查管理id", required = true, dataTypeClass = Long.class)
    public ResultData appFindCheckManage(@RequestParam("id") Long id) {
        CheckManageVo checkManageVo = checkManageService.findCheckManage(id);
        return ResultData.success(checkManageVo);
    }

    /**
     * 获取巡查计划管理列表(分页)
     *
     * @Param [checkManageBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("获取巡查计划管理列表(分页)")
    //@DataPermission(permissionStr = PerPrefix.SECURITY_CHECK_MANAGE)
    @DataPermission
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_MANAGE + PerFun.LIST,PerPrefix.SECURITY_CHECK_MANAGE_1 + PerFun.LIST})
    @PostMapping(value = "/list")
    public ResultData list(@RequestBody QueryCheckManageListParam queryCheckManageListParam) {
        lock.lock();
        try {
            List<CheckMember> checkMembers = checkMemberService.list(new LambdaQueryWrapper<CheckMember>().eq(CheckMember::getUserId, getCurrentUserId()));
            String checkPlanIds = Optional.ofNullable(checkMembers).orElseGet(Collections::emptyList).stream().map(CheckMember::getCheckPlanId).map(i -> String.valueOf(i)).collect(Collectors.joining(","));

            QueryWrapper <CheckStaffUser> wrapperCheckUser = new QueryWrapper<>();
            wrapperCheckUser.lambda().eq(CheckStaffUser::getStaffType,1)
                    .eq(CheckStaffUser::getUserId,getCurrentUserId());
            List<CheckStaffUser> checkStaffUserList = checkStaffUserService.list(wrapperCheckUser);
            String subIds = Optional.ofNullable(checkStaffUserList).orElseGet(Collections::emptyList).stream().map(CheckStaffUser::getSubId).map(i -> String.valueOf(i)).collect(Collectors.joining(","));

            Page<CheckManage> page = getCheckManagePage(queryCheckManageListParam, checkPlanIds, subIds);
            ResultData<Page<CheckManageListVo>> checkManageListVoPage = getResultData(page);
            if (checkManageListVoPage != null) return checkManageListVoPage;
            return ResultData.success(page);
        }finally {
            lock.unlock();
        }
    }

    /**
     * 小程序获取巡查计划管理列表(分页)
     *
     * @Param [checkManageBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("小程序获取巡查计划管理列表(分页)")
    //@DataPermission(permissionStr = PerPrefix.SECURITY_CHECK_MANAGE)
    @DataPermission
    @PostMapping(value = "/appList")
    public ResultData appList(@RequestBody QueryCheckManageListParam queryCheckManageListParam) {
        lock.lock();
        try {
            queryCheckManageListParam.setMyRelated(1);
            List<CheckMember> checkMembers = checkMemberService.list(new LambdaQueryWrapper<CheckMember>().eq(CheckMember::getUserId, getCurrentUserId()));
            String checkPlanIds = Optional.ofNullable(checkMembers).orElseGet(Collections::emptyList).stream().map(CheckMember::getCheckPlanId).map(i -> String.valueOf(i)).collect(Collectors.joining(","));

            QueryWrapper <CheckStaffUser> wrapperCheckUser = new QueryWrapper<>();
            wrapperCheckUser.lambda().eq(CheckStaffUser::getStaffType,1)
                    .eq(CheckStaffUser::getUserId,getCurrentUserId());
            List<CheckStaffUser> checkStaffUserList = checkStaffUserService.list(wrapperCheckUser);
            String subIds = Optional.ofNullable(checkStaffUserList).orElseGet(Collections::emptyList).stream().map(CheckStaffUser::getSubId).map(i -> String.valueOf(i)).collect(Collectors.joining(","));

            Page<CheckManage> page = getCheckManagePage(queryCheckManageListParam, checkPlanIds, subIds);
            ResultData<Page<CheckManageListVo>> checkManageListVoPage = getResultData(page);
            if (checkManageListVoPage != null) return checkManageListVoPage;
            return ResultData.success(page);
        }finally {
            lock.unlock();
        }
    }


    private Page<CheckManage> getCheckManagePage(QueryCheckManageListParam queryCheckManageListParam, String checkPlanIds, String subIds) {
        LambdaQueryWrapper<CheckManage> queryWrapper = new LambdaQueryWrapper<>();
        if (!Objects.isNull(queryCheckManageListParam.getManageStatus()) && queryCheckManageListParam.getManageStatus() != -1) {
            queryWrapper.eq(CheckManage::getManageStatus, queryCheckManageListParam.getManageStatus());
        }
        if(!Objects.isNull(queryCheckManageListParam.getCheckType()) && queryCheckManageListParam.getCheckType() != 0){
            queryWrapper.eq(CheckManage::getCheckType, queryCheckManageListParam.getCheckType());
        }
        if (!Objects.isNull(queryCheckManageListParam.getDeptId()) && queryCheckManageListParam.getDeptId() != 0) {
            queryWrapper.eq(CheckManage::getDeptId, queryCheckManageListParam.getDeptId());
        }
        if (!Objects.isNull(queryCheckManageListParam.getStartTime()) && !Objects.isNull(queryCheckManageListParam.getEndTime())) {
            queryWrapper.between(CheckManage::getCheckTime, queryCheckManageListParam.getStartTime().atStartOfDay(), queryCheckManageListParam.getEndTime().atTime(LocalTime.MAX));
        }
        if (StringUtils.isNotBlank(queryCheckManageListParam.getSearchValue())) {
            queryWrapper.and(wrapper -> {
                wrapper.like(CheckManage::getTitle, queryCheckManageListParam.getSearchValue())
                        .or().like(CheckManage::getSubjectName, queryCheckManageListParam.getSearchValue())
                        .or().like(CheckManage::getRoomNumber, queryCheckManageListParam.getSearchValue())
                        .or().like(CheckManage::getCheckUser, queryCheckManageListParam.getSearchValue());
            });
        }
        if (Objects.nonNull(queryCheckManageListParam.getCheckTimeSort()) && queryCheckManageListParam.getCheckTimeSort() == 1){
            queryWrapper.orderByAsc(CheckManage::getCheckTime);
        }
        if (Objects.nonNull(queryCheckManageListParam.getCheckTimeSort()) && queryCheckManageListParam.getCheckTimeSort() == 2){
            queryWrapper.orderByDesc(CheckManage::getCheckTime);
        }
        StringBuilder sb = new StringBuilder();
        if (Objects.nonNull(queryCheckManageListParam.getMyRelated()) && queryCheckManageListParam.getMyRelated() == 1) {
            //与我有关
            if (Objects.nonNull(queryCheckManageListParam.getCheckType()) && queryCheckManageListParam.getCheckType() == 0) {
                sb.append("(( check_type = 1 and ( create_by =").append(getCurrentUserId());
                if (StringUtils.isNotBlank(checkPlanIds)) {
                    sb.append(" OR check_plan_id in (").append(checkPlanIds).append(")");
                }
                sb.append(")) ");
                sb.append(" OR ( check_type = 2 and ( create_by = ").append(getCurrentUserId());
                if (StringUtils.isNotBlank(subIds)) {
                    sb.append(" OR sub_id in (").append(subIds).append(") ");
                }
                sb.append(" ))) ");
            } else {
                sb.append(" ( create_by = ").append(getCurrentUserId());
                if (Objects.nonNull(queryCheckManageListParam.getCheckType()) && queryCheckManageListParam.getCheckType() == 1) {
                    if (StringUtils.isNotBlank(checkPlanIds)) {
                        sb.append(" OR check_plan_id in (").append(checkPlanIds).append(") ");
                    }
                }
                if (Objects.nonNull(queryCheckManageListParam.getCheckType()) && queryCheckManageListParam.getCheckType() == 2) {
                    if (StringUtils.isNotBlank(subIds)) {
                        sb.append(" OR sub_id in (").append(subIds).append(") ");
                    }
                }
                sb.append(" ) ");
            }
        }
        if(Objects.nonNull(queryCheckManageListParam.getMyRelated()) && queryCheckManageListParam.getMyRelated() != 1){
            //全部
            sb.append(" ( create_by = ").append(getCurrentUserId());
            if(Objects.nonNull(queryCheckManageListParam.getCheckType()) && queryCheckManageListParam.getCheckType() == 1){
                if(StringUtils.isNotBlank(checkPlanIds)){
                    sb.append(" OR check_plan_id in (").append(checkPlanIds).append(") ");
                }
            }
            if(Objects.nonNull(queryCheckManageListParam.getCheckType()) && queryCheckManageListParam.getCheckType() == 2){
                if(StringUtils.isNotBlank(subIds)){
                    sb.append(" OR sub_id in (").append(subIds).append(") ");
                }
            }
            List<Long> users = DataPermissionAspect.threadLocal.get();
            DataPermissionAspect.threadLocal.remove();
            if(CollectionUtil.isNotEmpty(users)){
                String userStr = users.stream().map(a->a.toString()).collect(Collectors.joining(","));
                sb.append(" or create_by in(" + userStr + ")");
            }
            sb.append(" ) ");
        }
        queryWrapper.apply(sb.toString());
        queryWrapper.orderByDesc(CheckManage::getId);
        return checkManageService.getlist(queryCheckManageListParam,queryWrapper);
    }

    @Nullable
    private ResultData<Page<CheckManageListVo>> getResultData(Page<CheckManage> page) {
        ResultData<Page<CheckManageListVo>> checkManageListVoPage = getPageResultData(page);
        if (checkManageListVoPage != null){
            //获取当前用户巡查计划列表
            List<CheckPlan> checkPlans = checkPlanService.list(new LambdaQueryWrapper<CheckPlan>().and(i -> i.eq(CheckPlan::getCheckStatus, 1).or().eq(CheckPlan::getCheckStatus, 2)));
            List<Long> checkPlanIdList = checkPlans.stream().map(CheckPlan::getId).collect(Collectors.toList());
            if(checkPlanIdList.size()==0){
                checkPlanIdList.add(-99L);
            }
            List<CheckMember> checkMemberList = checkMemberService.list(new LambdaQueryWrapper<CheckMember>().in(CheckMember::getCheckPlanId, checkPlanIdList).eq(CheckMember::getUserId, getCurrentUserId()));
            //获取自查身份
            QueryWrapper <CheckStaffUser> wrapper = new QueryWrapper<>();
            wrapper.lambda().eq(CheckStaffUser::getStaffType,1)
                    .eq(CheckStaffUser::getUserId,getCurrentUserId());
            List<CheckStaffUser> checkStaffUsers = checkStaffUserService.list(wrapper);
            Consumer<List<CheckManageListVo>> consumer = a->Optional.ofNullable(a)
                    .orElseGet(Collections::emptyList)
                    .stream()
                    .forEach(b->{
                        List<Integer> rectifyStatus = new ArrayList <>();
                        rectifyStatus.add(2);
                        rectifyStatus.add(3);
                        List<CheckHazard> checkHazardList = checkHazardService.list(new LambdaQueryWrapper <CheckHazard>()
                                .in(CheckHazard::getRectifyStatus,rectifyStatus).eq(CheckHazard::getCheckManageId,b.getId()));
                        if(b.getManageStatus().intValue()==2){
                            if(checkHazardList==null || checkHazardList.isEmpty()){
                                b.setIsEndProcess(1);
                            }else{
                                b.setIsEndProcess(0);
                            }
                        }else{
                            b.setIsEndProcess(0);
                        }
                        if (b.getCheckType() == 1) {
                            //院校巡查
                            if (checkMemberList!=null && !checkMemberList.isEmpty()) {
                                List<Long> planIds = checkMemberList.stream().map(CheckMember::getCheckPlanId).collect(Collectors.toList());
                                if (planIds.contains(b.getCheckPlanId())){
                                    b.setIsSelfData(1);
                                }else {
                                    b.setIsSelfData(0);
                                }
                            }else {
                                b.setIsSelfData(0);
                            }
                        }else {
                            //实验室自查
                            if(checkStaffUsers!=null && !checkStaffUsers.isEmpty()){
                                List<Long> checkSubIds = checkStaffUsers.stream().map(CheckStaffUser::getSubId).collect(Collectors.toList());
                                if (checkSubIds.contains(b.getSubId())){
                                    b.setIsSelfData(1);
                                }else {
                                    b.setIsSelfData(0);
                                }
                            }else {
                                b.setIsSelfData(0);
                            }
                            //开展检查
                            if(b.getCheckPlanId()!=null && getCurrentUserId().longValue() == b.getCreateBy().longValue()){
                                b.setIsSelfData(1);
                            }
                        }
                    });
            consumer.accept(checkManageListVoPage.getData().getRecords());
            return checkManageListVoPage;
        }
        return null;
    }

    @Nullable
    private ResultData<Page<CheckManageListVo>> getPageResultData(Page<CheckManage> page) {
        List<CheckManage> records = page.getRecords();
        if (page.getTotal() > 0){
            List<CheckManageListVo> checkManageListVos = BeanUtils.copyList2List(records, CheckManageListVo.class);
            checkManageListVos.forEach(checkManageListVo -> {
                if (Objects.nonNull(checkManageListVo.getCycleStartTime())) {
                    LocalDateTime localDateTime = checkManageListVo.getCycleStartTime().atStartOfDay();
                    if (LocalDateTime.now().isAfter(localDateTime)) {
                        checkManageListVo.setIsCheck(1);
                    }
                }
            });
            Page<CheckManageListVo> checkManageListVoPage = new Page<>();
            BeanUtils.copyProperties(page,checkManageListVoPage);
            checkManageListVoPage.setRecords(checkManageListVos);
            return ResultData.success(checkManageListVoPage);
        }
        return null;
    }

    /**
     * 根据检查计划id查询巡查管理列表(分页)
     *
     * @Param [checkManageBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("根据检查计划id查询巡查管理列表(分页)")
    //@DataPermission(permissionStr = PerPrefix.SECURITY_CHECK_MANAGE)
    @PreAuthorize(hasAnyPermi = {
            PerPrefix.SECURITY_CHECK_MANAGE + PerFun.LIST,
            PerPrefix.SECURITY_CHECK_MANAGE_1 + PerFun.LIST,
            PerPrefix.SECURITY_CHECK_MANAGE_2 + PerFun.LIST,
            PerPrefix.SECURITY_CHECK_MANAGE_3 + PerFun.LIST})
    @PostMapping(value = "/findByCheckPlanId")
    public ResultData findByCheckPlanId(@RequestBody QueryManageListParam queryManageListParam) {
        paramCheck.notNull(queryManageListParam.getCheckPlanId());
        LambdaQueryWrapper<CheckManage> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CheckManage::getCheckPlanId, queryManageListParam.getCheckPlanId());
        if (Objects.nonNull(queryManageListParam.getDeptId())) {
            queryWrapper.eq(CheckManage::getDeptId, queryManageListParam.getDeptId());
        }
        if (StringUtils.isNotBlank(queryManageListParam.getSearchValue())) {
            queryWrapper.and(wrapper -> {
                wrapper.like(CheckManage::getTitle, queryManageListParam.getSearchValue())
                        .or().like(CheckManage::getSubjectName, queryManageListParam.getSearchValue())
                        .or().like(CheckManage::getRoomNumber, queryManageListParam.getSearchValue())
                        .or().like(CheckManage::getCheckUser, queryManageListParam.getSearchValue());
            });
        }
        if (!Objects.isNull(queryManageListParam.getStartTime()) && !Objects.isNull(queryManageListParam.getEndTime())) {
            queryWrapper.between(CheckManage::getCheckTime, queryManageListParam.getStartTime().atStartOfDay(), queryManageListParam.getEndTime().atTime(LocalTime.MAX));
        }
        if (Objects.nonNull(queryManageListParam.getManageStatus()) && queryManageListParam.getManageStatus() != -1) {
            queryWrapper.eq(CheckManage::getManageStatus, queryManageListParam.getManageStatus());
        }
        if (Objects.nonNull(queryManageListParam.getCheckTimeSort()) && queryManageListParam.getCheckTimeSort() == 1){
            queryWrapper.orderByAsc(CheckManage::getId);
        }
        if (Objects.nonNull(queryManageListParam.getCheckTimeSort()) && queryManageListParam.getCheckTimeSort() == 2){
            queryWrapper.orderByDesc(CheckManage::getId);
        }
        Page<CheckManage> page = checkManageService.page(new Page<>(queryManageListParam.getPageNum(), queryManageListParam.getPageSize()), queryWrapper);
        ResultData<Page<CheckManageListVo>> checkManageListVoPage = getPageResultData(page);
        if (checkManageListVoPage != null){
            //获取当前用户巡查计划列表
            List<CheckPlan> checkPlans = checkPlanService.list(new LambdaQueryWrapper<CheckPlan>().and(i -> i.eq(CheckPlan::getCheckStatus, 1).or().eq(CheckPlan::getCheckStatus, 2)));
            List<Long> checkPlanIdList = checkPlans.stream().map(CheckPlan::getId).collect(Collectors.toList());
            List<CheckMember> checkMemberList = checkMemberService.list(new LambdaQueryWrapper<CheckMember>().in(CheckMember::getCheckPlanId, checkPlanIdList).eq(CheckMember::getUserId, getCurrentUserId()));
            //获取自查身份
            QueryWrapper <CheckStaffUser> wrapperCheckUser = new QueryWrapper<>();
            wrapperCheckUser.lambda().eq(CheckStaffUser::getStaffType,1)
                    .eq(CheckStaffUser::getUserId,getCurrentUserId());
            List<CheckStaffUser> checkStaffUserList = checkStaffUserService.list(wrapperCheckUser);
            Consumer<List<CheckManageListVo>> consumer = a->Optional.ofNullable(a)
                    .orElseGet(Collections::emptyList)
                    .stream()
                    .forEach(b->{
                        List<Integer> rectifyStatus = new ArrayList <>();
                        rectifyStatus.add(2);
                        rectifyStatus.add(3);
                        List<CheckHazard> checkHazardList = checkHazardService.list(new LambdaQueryWrapper <CheckHazard>()
                                .in(CheckHazard::getRectifyStatus,rectifyStatus).eq(CheckHazard::getCheckManageId,b.getId()));
                        if(b.getManageStatus().intValue()==2){
                            if(checkHazardList==null || checkHazardList.isEmpty()){
                                b.setIsEndProcess(1);
                            }else{
                                b.setIsEndProcess(0);
                            }
                        }else{
                            b.setIsEndProcess(0);
                        }
                        if (b.getCheckType() == 1) {
                            //院校巡查
                            if (checkMemberList!=null && !checkMemberList.isEmpty()) {
                                List<Long> checkPlanIds = checkMemberList.stream().map(CheckMember::getCheckPlanId).collect(Collectors.toList());
                                if (checkPlanIds.contains(b.getCheckPlanId())){
                                    b.setIsSelfData(1);
                                }else {
                                    b.setIsSelfData(0);
                                }
                            }else {
                                b.setIsSelfData(0);
                            }
                        }else {
                            //实验室自查
                            if(checkStaffUserList!=null && !checkStaffUserList.isEmpty()){
                                List<Long> subIds = checkStaffUserList.stream().map(CheckStaffUser::getSubId).collect(Collectors.toList());
                                if (subIds.contains(b.getSubId())){
                                    b.setIsSelfData(1);
                                }else {
                                    b.setIsSelfData(0);
                                }
                            }else {
                                b.setIsSelfData(0);
                            }
                        }
                    });
            consumer.accept(checkManageListVoPage.getData().getRecords());
            return checkManageListVoPage;
        }
        return ResultData.success(page);
    }

    /**
     * 小程序根据检查计划id查询巡查管理列表(分页)
     *
     * @Param [checkManageBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("小程序根据检查计划id查询巡查管理列表(分页)")
    //@DataPermission(permissionStr = PerPrefix.SECURITY_CHECK_MANAGE)
    @PostMapping(value = "/appFindByCheckPlanId")
    public ResultData appFindByCheckPlanId(@RequestBody QueryManageListParam queryManageListParam) {
        paramCheck.notNull(queryManageListParam.getCheckPlanId());
        LambdaQueryWrapper<CheckManage> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CheckManage::getCheckPlanId, queryManageListParam.getCheckPlanId());
        if (Objects.nonNull(queryManageListParam.getDeptId())) {
            queryWrapper.eq(CheckManage::getDeptId, queryManageListParam.getDeptId());
        }
        if (StringUtils.isNotBlank(queryManageListParam.getSearchValue())) {
            queryWrapper.and(wrapper -> {
                wrapper.like(CheckManage::getTitle, queryManageListParam.getSearchValue())
                        .or().like(CheckManage::getSubjectName, queryManageListParam.getSearchValue())
                        .or().like(CheckManage::getRoomNumber, queryManageListParam.getSearchValue())
                        .or().like(CheckManage::getCheckUser, queryManageListParam.getSearchValue());
            });
        }
        if (!Objects.isNull(queryManageListParam.getStartTime()) && !Objects.isNull(queryManageListParam.getEndTime())) {
            queryWrapper.between(CheckManage::getCheckTime, queryManageListParam.getStartTime().atStartOfDay(), queryManageListParam.getEndTime().atTime(LocalTime.MAX));
        }
        if (Objects.nonNull(queryManageListParam.getManageStatus()) && queryManageListParam.getManageStatus() != -1) {
            queryWrapper.eq(CheckManage::getManageStatus, queryManageListParam.getManageStatus());
        }
        if (Objects.nonNull(queryManageListParam.getCheckTimeSort()) && queryManageListParam.getCheckTimeSort() == 1){
            queryWrapper.orderByAsc(CheckManage::getId);
        }
        if (Objects.nonNull(queryManageListParam.getCheckTimeSort()) && queryManageListParam.getCheckTimeSort() == 2){
            queryWrapper.orderByDesc(CheckManage::getId);
        }
        Page<CheckManage> page = checkManageService.page(new Page<>(queryManageListParam.getPageNum(), queryManageListParam.getPageSize()), queryWrapper);
        ResultData<Page<CheckManageListVo>> checkManageListVoPage = getPageResultData(page);
        if (checkManageListVoPage != null){
            //获取当前用户巡查计划列表
            List<CheckPlan> checkPlans = checkPlanService.list(new LambdaQueryWrapper<CheckPlan>().and(i -> i.eq(CheckPlan::getCheckStatus, 1).or().eq(CheckPlan::getCheckStatus, 2)));
            List<Long> checkPlanIdList = checkPlans.stream().map(CheckPlan::getId).collect(Collectors.toList());
            List<CheckMember> checkMemberList = checkMemberService.list(new LambdaQueryWrapper<CheckMember>().in(CheckMember::getCheckPlanId, checkPlanIdList).eq(CheckMember::getUserId, getCurrentUserId()));
            //获取自查身份
            QueryWrapper <CheckStaffUser> wrapperCheckUser = new QueryWrapper<>();
            wrapperCheckUser.lambda().eq(CheckStaffUser::getStaffType,1)
                    .eq(CheckStaffUser::getUserId,getCurrentUserId());
            List<CheckStaffUser> checkStaffUserList = checkStaffUserService.list(wrapperCheckUser);
            Consumer<List<CheckManageListVo>> consumer = a->Optional.ofNullable(a)
                    .orElseGet(Collections::emptyList)
                    .stream()
                    .forEach(b->{
                        List<Integer> rectifyStatus = new ArrayList <>();
                        rectifyStatus.add(2);
                        rectifyStatus.add(3);
                        List<CheckHazard> checkHazardList = checkHazardService.list(new LambdaQueryWrapper <CheckHazard>()
                                .in(CheckHazard::getRectifyStatus,rectifyStatus).eq(CheckHazard::getCheckManageId,b.getId()));
                        if(b.getManageStatus().intValue()==2){
                            if(checkHazardList==null || checkHazardList.isEmpty()){
                                b.setIsEndProcess(1);
                            }else{
                                b.setIsEndProcess(0);
                            }
                        }else{
                            b.setIsEndProcess(0);
                        }
                        if (b.getCheckType() == 1) {
                            //院校巡查
                            if (checkMemberList!=null &&  !checkMemberList.isEmpty()) {
                                List<Long> checkPlanIds = checkMemberList.stream().map(CheckMember::getCheckPlanId).collect(Collectors.toList());
                                if (checkPlanIds.contains(b.getCheckPlanId())){
                                    b.setIsSelfData(1);
                                }else {
                                    b.setIsSelfData(0);
                                }
                            }else {
                                b.setIsSelfData(0);
                            }
                        }else {
                            //实验室自查
                            if(checkStaffUserList!=null && !checkStaffUserList.isEmpty()){
                                List<Long> subIds = checkStaffUserList.stream().map(CheckStaffUser::getSubId).collect(Collectors.toList());
                                if (subIds.contains(b.getSubId())){
                                    b.setIsSelfData(1);
                                }else {
                                    b.setIsSelfData(0);
                                }
                            }else {
                                b.setIsSelfData(0);
                            }
                        }
                    });
            consumer.accept(checkManageListVoPage.getData().getRecords());
            return checkManageListVoPage;
        }
        return ResultData.success(page);
    }

    /**
     * 查询各管理状态数据数量
     * @Return com.zd.model.domain.ResultData
     **/
    @GetMapping(value = "/getManageStatusCount")
    @ApiOperation("查询检查计划各检查状态数据数量")
    public ResultData getManageStatusCount() {
        Map<String,Long> map = new HashMap<>();
        long noCheckNum = checkManageService.count(new LambdaQueryWrapper<CheckManage>().eq(CheckManage::getManageStatus, 0));
        long checkingNum = checkManageService.count(new LambdaQueryWrapper<CheckManage>().eq(CheckManage::getManageStatus,1));
        long applyNum = checkHazardService.count(new LambdaQueryWrapper<CheckHazard>().eq(CheckHazard::getRectifyStatus, 3));
        map.put("noCheck",noCheckNum);
        map.put("checking",checkingNum);
        map.put("applyNum",applyNum);
        return ResultData.success(map);
    }

    /**
     * 根据实验室id查询该实验室有关计划
     * @Return com.zd.model.domain.ResultData
     **/
    @GetMapping(value = "/getCheckPlanBySubId")
    @ApiOperation("根据实验室id查询该实验室有关计划")
    public ResultData getCheckPlanBySubId(@RequestParam("subId") Long subId) {
        List<CheckManage> list = checkManageService.list(new LambdaQueryWrapper<CheckManage>().eq(CheckManage::getSubId, subId)
                .le(CheckManage::getCycleStartTime, LocalDate.now())
                .and(checkManage -> checkManage.eq(CheckManage::getManageStatus, 0).or().eq(CheckManage::getManageStatus, 1))
                .orderByDesc(CheckManage::getId));
        List<CheckManageListVo> checkManageListVos = BeanUtils.copyList2List(list, CheckManageListVo.class);
        if (checkManageListVos != null && !checkManageListVos.isEmpty()){
            permissionData(checkManageListVos);
        }
        return ResultData.success(checkManageListVos);
    }

    private void permissionData(List<CheckManageListVo> checkManageListVos) {
        //权限
        boolean adminGentle = Boolean.FALSE;
        boolean applyGentle = Boolean.FALSE;
        boolean myApplyGentle = Boolean.FALSE;
        //获取管理员身份
        ResultData<Boolean> postInfo = remoteUserService.selectPostInfo(getCurrentUserId());
        if(Boolean.valueOf(postInfo.getData())){
            adminGentle = Boolean.TRUE;
        }else{
            adminGentle = Boolean.FALSE;
        }
        //获取巡查组身份
        List<CheckPlan> checkPlans = checkPlanService.list(new LambdaQueryWrapper<CheckPlan>().and(i -> i.eq(CheckPlan::getCheckStatus, 1).or().eq(CheckPlan::getCheckStatus, 2)));
        List<Long> checkPlanIdList = checkPlans.stream().map(CheckPlan::getId).collect(Collectors.toList());
        LambdaQueryWrapper<CheckMember> queryWrapper = new LambdaQueryWrapper<>();
        if(CollectionUtil.isNotEmpty(checkPlanIdList)){
            queryWrapper.in(CheckMember::getCheckPlanId, checkPlanIdList);
        }
        queryWrapper.eq(CheckMember::getUserId,getCurrentUserId());
        List<CheckMember> memberList = checkMemberService.list(queryWrapper);
        if(CollectionUtil.isNotEmpty(memberList)){
            applyGentle = Boolean.TRUE;
        }else{
            applyGentle = Boolean.FALSE;
        }
        //获取自查身份
        QueryWrapper <CheckStaffUser> wrapperCheckUser = new QueryWrapper<>();
        wrapperCheckUser.lambda().eq(CheckStaffUser::getStaffType,1)
                .eq(CheckStaffUser::getUserId,getCurrentUserId());
        List<CheckStaffUser> checkStaffUserList = checkStaffUserService.list(wrapperCheckUser);
        if(checkStaffUserList!=null && !checkStaffUserList.isEmpty()){
            myApplyGentle = Boolean.TRUE;
        }else{
            myApplyGentle = Boolean.FALSE;
        }
        if (!adminGentle) {
            if(applyGentle && myApplyGentle){
                checkManageListVos.forEach(i->{
                    if(i.getCheckType() == 1){
                        List<Long> collect = memberList.stream().map(CheckMember::getCheckPlanId).collect(Collectors.toList());
                        if (collect.contains(i.getCheckPlanId())) {
                            i.setIsSelfData(1);
                        }else {
                            i.setIsSelfData(0);
                        }
                    }else {
                        List<Long> subIds = checkStaffUserList.stream().map(CheckStaffUser::getSubId).collect(Collectors.toList());
                        if (subIds.contains(i.getSubId())) {
                            i.setIsSelfData(1);
                        }else {
                            i.setIsSelfData(0);
                        }
                    }
                });
            } else if (!applyGentle && myApplyGentle) {
                //无巡查有自查    检查类型(1校院巡查 2实验室自查)
                checkManageListVos = checkManageListVos.stream().filter(i -> i.getCheckType() == 2).collect(Collectors.toList());
                checkManageListVos.forEach(i->{
                    List<Long> subIds = checkStaffUserList.stream().map(CheckStaffUser::getSubId).collect(Collectors.toList());
                    if (subIds.contains(i.getSubId())) {
                        i.setIsSelfData(1);
                    }else {
                        i.setIsSelfData(0);
                    }
                });
            } else if (applyGentle && !myApplyGentle) {
                //有巡查无自查
                checkManageListVos = checkManageListVos.stream().filter(i -> i.getCheckType() == 1).collect(Collectors.toList());
                checkManageListVos.forEach(i->{
                    List<Long> collect = Optional.ofNullable(memberList).orElseGet(Collections::emptyList).stream().map(CheckMember::getCheckPlanId).collect(Collectors.toList());
                    if (collect.contains(i.getCheckPlanId())) {
                        i.setIsSelfData(1);
                    }else {
                        i.setIsSelfData(0);
                    }
                });
            } else if (!applyGentle && !myApplyGentle) {
                //均无
                checkManageListVos = new ArrayList<>();
            }
        }else {
            checkManageListVos.forEach(i->{
                i.setIsSelfData(1);
            });
        }
    }

    /**
     * 实验室id，危险源ids 查询开展检查检查项
     */
    @GetMapping("/getHazardInfo")
    @ApiOperation(value = "实验室id，危险源ids 查询开展检查检查项")
    public ResultData getHazardInfo(@RequestParam("subId") Long subId,@RequestParam("hazardIds") String hazardIds) {
        List<CheckHazardInfoVo> checkHazardDtoList = checkManageService.getHazardInfo(subId,hazardIds);
        return ResultData.success(checkHazardDtoList);

    }

    /**
     * 根据关联ids查询开展检查检查项
     */
    @GetMapping("/getHazardInfoByJoinIds")
    @ApiOperation(value = "根据关联ids查询开展检查检查项")
    public ResultData getHazardInfoByJoinIds(@RequestParam("joinHazardIds") String joinHazardIds) {
        List<CheckHazardInfoVo> checkHazardDtoList = checkManageService.getHazardInfoByJoinIds(joinHazardIds);
        return ResultData.success(checkHazardDtoList);

    }

    /**
     * 生成整改通知书
     * @Param [id, response]
     * @Return void
     **/
    @ApiOperation(value = "生成整改通知书")
    @GetMapping("/getRectifyAdviceNoteView/{checkMangeId}")
    public ResultData getRectifyAdviceNoteView(@PathVariable("checkMangeId") Long checkMangeId) {
        return ResultData.success(checkManageService.getRectifyAdviceNoteView(checkMangeId));
    }

    /**
     * 生成整改通知书
     * @Param [id, response]
     * @Return void
     **/
    @ApiOperation(value = "生成整改通知书")
    @RequestMapping("/getRectifyAdviceNote/{checkMangeId}")
    public void getRectifyAdviceNote(@PathVariable("checkMangeId") Long checkMangeId, HttpServletResponse response) {
        wordService.getRectifyAdviceNote(checkMangeId, response);
    }

    /**
     * 生成整改告知书
     * @Param [id, response]
     * @Return void
     **/
    @ApiOperation(value = "生成整改告知书")
    @RequestMapping("/getRectifyNotificationView/{checkMangeId}")
    public ResultData getRectifyNotificationView(@PathVariable("checkMangeId") Long checkMangeId) {
        return ResultData.success(checkManageService.getRectifyNotificationView(checkMangeId));
    }

    /**
     * 生成整改告知书
     * @Param [id, response]
     * @Return void
     **/
    @ApiOperation(value = "生成整改告知书")
    @RequestMapping("/getRectifyNotification/{checkMangeId}")
    public void getRectifyNotification(@PathVariable("checkMangeId") Long checkMangeId, HttpServletResponse response) {
        wordService.getRectifyNotification(checkMangeId, response);
    }
}