package com.zd.security.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
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.CheckPlanBo;
import com.zd.security.api.bo.QueryCheckPlanListParam;
import com.zd.security.api.vo.CheckPlanListVo;
import com.zd.security.api.vo.CheckPlanVo;
import com.zd.security.entity.CheckMember;
import com.zd.security.entity.CheckPlan;
import com.zd.security.scope.DataPermission;
import com.zd.security.service.CheckMemberService;
import com.zd.security.service.CheckPlanService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;

/**
 * <p>
 * 检查计划表 前端控制器
 * </p>
 *
 * @author hzw
 * @since 2023-04-19
 */
@Api(tags = "检查计划")
@RestController
@RequestMapping("/checkPlan")
public class CheckPlanController extends AbstractController {

    private Lock lock = new ReentrantLock();
    @Autowired
    private CheckPlanService checkPlanService;
    @Autowired
    private CheckMemberService checkMemberService;

    /**
     * 添加检查计划
     *
     * @Param [checkPlanBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @Log(title = "添加检查计划", businessType = BusinessType.INSERT)
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_PLAN + PerFun.ADD,PerPrefix.SECURITY_CHECK_PLAN_1 + PerFun.ADD})
    @ApiOperation("添加检查计划")
    @PostMapping(value = "/add")
    public ResultData add(@RequestBody CheckPlanBo checkPlanBo) {
        //参数检查
        paramCheck.notNull(checkPlanBo).strNotEmpty(checkPlanBo.getTitle()).notNull(checkPlanBo.getCheckType()).notNull(checkPlanBo.getCycleStartTime()).notNull(checkPlanBo.getCycleEndTime()).notNull(checkPlanBo.getCheckRange());
        checkPlanBo.setCreateName(getCurrentUserName());
        if (checkPlanService.addCheckPlan(checkPlanBo)) {
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 小程序添加检查计划
     * @param checkPlanBo
     * @return
     */
    @Log(title = "小程序添加检查计划", businessType = BusinessType.INSERT)
    @ApiOperation("小程序添加检查计划")
    @PostMapping(value = "/appAdd")
    public ResultData appAdd(@RequestBody CheckPlanBo checkPlanBo) {
        //参数检查
        paramCheck.notNull(checkPlanBo).strNotEmpty(checkPlanBo.getTitle()).notNull(checkPlanBo.getCheckType()).notNull(checkPlanBo.getCycleStartTime()).notNull(checkPlanBo.getCycleEndTime()).notNull(checkPlanBo.getCheckRange());
        checkPlanBo.setCreateName(getCurrentUserName());
        if (checkPlanService.addCheckPlan(checkPlanBo)) {
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 修改检查计划
     *
     * @Param [checkPlanBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @Log(title = "修改检查计划", businessType = BusinessType.UPDATE)
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_PLAN + PerFun.EDIT,PerPrefix.SECURITY_CHECK_PLAN_1 + PerFun.EDIT})
    @ApiOperation("修改检查计划")
    @PutMapping(value = "/update")
    public ResultData update(@RequestBody CheckPlanBo checkPlanBo) {
        //参数检查
        paramCheck.notNull(checkPlanBo).strNotEmpty(checkPlanBo.getTitle()).notNull(checkPlanBo.getCheckType()).notNull(checkPlanBo.getCycleStartTime()).notNull(checkPlanBo.getCycleEndTime()).notNull(checkPlanBo.getCheckRange());
        checkPlanBo.setUpdateName(getCurrentUserName());
        if (checkPlanService.updateCheckPlan(checkPlanBo)) {
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 小程序修改检查计划
     *
     * @Param [checkPlanBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @Log(title = "小程序修改检查计划", businessType = BusinessType.UPDATE)
    @ApiOperation("小程序修改检查计划")
    @PutMapping(value = "/appUpdate")
    public ResultData appUpdate(@RequestBody CheckPlanBo checkPlanBo) {
        //参数检查
        paramCheck.notNull(checkPlanBo).strNotEmpty(checkPlanBo.getTitle()).notNull(checkPlanBo.getCheckType()).notNull(checkPlanBo.getCycleStartTime()).notNull(checkPlanBo.getCycleEndTime()).notNull(checkPlanBo.getCheckRange());
        checkPlanBo.setUpdateName(getCurrentUserName());
        if (checkPlanService.updateCheckPlan(checkPlanBo)) {
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 根据id查询计划方法
     *
     * @Param [id 检查计划id]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("根据id查询计划方法")
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_PLAN + PerFun.QUERY,PerPrefix.SECURITY_CHECK_PLAN_1 + PerFun.QUERY})
    @GetMapping(value = "/findCheckPlan")
    @ApiImplicitParam(name = "id", value = "检查计划id", required = true, dataTypeClass = Long.class)
    public ResultData find(@RequestParam("id") Long id) {
        CheckPlanVo checkPlanVo = checkPlanService.findCheckPlan(id);
        return ResultData.success(checkPlanVo);
    }

    /**
     * 小程序根据id查询计划方法
     *
     * @Param [id 检查计划id]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("小程序根据id查询计划方法")
    @GetMapping(value = "/appFindCheckPlan")
    @ApiImplicitParam(name = "id", value = "检查计划id", required = true, dataTypeClass = Long.class)
    public ResultData appFindCheckPlan(@RequestParam("id") Long id) {
        CheckPlanVo checkPlanVo = checkPlanService.findCheckPlan(id);
        return ResultData.success(checkPlanVo);
    }

    /**
     * 获取检查计划列表（分页）
     *
     * @Param [checkPlanBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("获取检查计划列表（分页）")
    //@DataPermission(permissionStr = PerPrefix.SECURITY_CHECK_PLAN)
//    @DataPermission(roleKey="checkGentle", tableAlias="*")
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_PLAN + PerFun.LIST,PerPrefix.SECURITY_CHECK_PLAN_1 + PerFun.LIST})
    @PostMapping(value = "/list")
    public ResultData list(@RequestBody QueryCheckPlanListParam queryCheckPlanListParam) {
        LambdaQueryWrapper<CheckPlan> queryWrapper = new LambdaQueryWrapper<>();
        if (!Objects.isNull(queryCheckPlanListParam.getCheckType()) && queryCheckPlanListParam.getCheckType() != 0) {
            queryWrapper.eq(CheckPlan::getCheckType, queryCheckPlanListParam.getCheckType());
        }
        if (!Objects.isNull(queryCheckPlanListParam.getCheckStatus()) && queryCheckPlanListParam.getCheckStatus() != 0) {
            queryWrapper.eq(CheckPlan::getCheckStatus, queryCheckPlanListParam.getCheckStatus());
        }
        if (StringUtils.isNotBlank(queryCheckPlanListParam.getSearchValue())) {
            queryWrapper.and(wrapper -> {
                wrapper.like(CheckPlan::getTitle, queryCheckPlanListParam.getSearchValue()).or().like(CheckPlan::getCreateName, queryCheckPlanListParam.getSearchValue());
            });
        }
        if (!Objects.isNull(queryCheckPlanListParam.getCycleStartTime()) && !Objects.isNull(queryCheckPlanListParam.getCycleEndTime())) {
            queryWrapper.le(CheckPlan::getCycleStartTime, queryCheckPlanListParam.getCycleEndTime())
                    .ge(CheckPlan::getCycleEndTime, queryCheckPlanListParam.getCycleStartTime());
        }
        if (Objects.nonNull(queryCheckPlanListParam.getCreateTimeSort()) && queryCheckPlanListParam.getCreateTimeSort() == 1){
            queryWrapper.orderByAsc(CheckPlan::getCreateTime);
        }
        if (Objects.nonNull(queryCheckPlanListParam.getCreateTimeSort()) && queryCheckPlanListParam.getCreateTimeSort() == 2){
            queryWrapper.orderByDesc(CheckPlan::getCreateTime);
        }
        StringBuilder sql = new StringBuilder();
        if(Objects.nonNull(queryCheckPlanListParam.getMyRelated()) && queryCheckPlanListParam.getMyRelated() == 1){
            sql.append(" ( create_by = ").append(getCurrentUserId()).append(" ) ");
        }
        if(Objects.nonNull(queryCheckPlanListParam.getMyRelated()) && queryCheckPlanListParam.getMyRelated() != 1){
            sql.append(" ( create_by = ").append(getCurrentUserId()).append(" OR 1=1 )");
        }
        queryWrapper.apply(sql.toString());
        queryWrapper.orderByDesc(CheckPlan::getId);
        Page<CheckPlan> page = checkPlanService.page(new Page<>(queryCheckPlanListParam.getPageNum(), queryCheckPlanListParam.getPageSize()), queryWrapper);;
        List<CheckPlan> records = page.getRecords();
        if (records!=null && !records.isEmpty()) {
            List<CheckPlanListVo> checkPlanListVos = BeanUtils.copyList2List(records, CheckPlanListVo.class);
            checkPlanListVos.forEach(checkPlanListVo -> {
                if (getCurrentUserId().equals(checkPlanListVo.getCreateBy())) {
                    checkPlanListVo.setIsSelfData(1);
                }else {
                    checkPlanListVo.setIsSelfData(0);
                }
            });
            Page<CheckPlanListVo> checkManageListVoPage = new Page<>();
            BeanUtils.copyProperties(page, checkManageListVoPage);
            checkManageListVoPage.setRecords(checkPlanListVos);
            return ResultData.success(checkManageListVoPage);
        }
        return ResultData.success(page);
    }

    /**
     * 小程序获取检查计划列表（分页）
     *
     * @Param [checkPlanBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation("小程序获取检查计划列表（分页）")
    //@DataPermission(permissionStr = PerPrefix.SECURITY_CHECK_PLAN)
    @DataPermission(roleKey="checkGentle", tableAlias="*")
    @PostMapping(value = "/appList")
    public ResultData appList(@RequestBody QueryCheckPlanListParam queryCheckPlanListParam) {
        queryCheckPlanListParam.setMyRelated(1);
        LambdaQueryWrapper<CheckPlan> queryWrapper = new LambdaQueryWrapper<>();
        if (!Objects.isNull(queryCheckPlanListParam.getCheckType()) && queryCheckPlanListParam.getCheckType() != 0) {
            queryWrapper.eq(CheckPlan::getCheckType, queryCheckPlanListParam.getCheckType());
        }
        if (!Objects.isNull(queryCheckPlanListParam.getCheckStatus()) && queryCheckPlanListParam.getCheckStatus() != 0) {
            queryWrapper.eq(CheckPlan::getCheckStatus, queryCheckPlanListParam.getCheckStatus());
        }
        if (StringUtils.isNotBlank(queryCheckPlanListParam.getSearchValue())) {
            queryWrapper.and(wrapper -> {
                wrapper.like(CheckPlan::getTitle, queryCheckPlanListParam.getSearchValue()).or().like(CheckPlan::getCreateName, queryCheckPlanListParam.getSearchValue());
            });
        }
        if (!Objects.isNull(queryCheckPlanListParam.getCycleStartTime()) && !Objects.isNull(queryCheckPlanListParam.getCycleEndTime())) {
            queryWrapper.le(CheckPlan::getCycleStartTime, queryCheckPlanListParam.getCycleEndTime())
                    .ge(CheckPlan::getCycleEndTime, queryCheckPlanListParam.getCycleStartTime());
        }
        if (Objects.nonNull(queryCheckPlanListParam.getCreateTimeSort()) && queryCheckPlanListParam.getCreateTimeSort() == 1){
            queryWrapper.orderByAsc(CheckPlan::getCreateTime);
        }
        if (Objects.nonNull(queryCheckPlanListParam.getCreateTimeSort()) && queryCheckPlanListParam.getCreateTimeSort() == 2){
            queryWrapper.orderByDesc(CheckPlan::getCreateTime);
        }
        StringBuilder sql = new StringBuilder();
        if(Objects.nonNull(queryCheckPlanListParam.getMyRelated()) && queryCheckPlanListParam.getMyRelated() == 1){
            sql.append(" ( create_by = ").append(getCurrentUserId()).append(" ) ");
        }
        if(Objects.nonNull(queryCheckPlanListParam.getMyRelated()) && queryCheckPlanListParam.getMyRelated() != 1){
            sql.append(" ( create_by = ").append(getCurrentUserId()).append(" OR 1=1 )");
        }
        queryWrapper.apply(sql.toString());
        queryWrapper.orderByDesc(CheckPlan::getId);
        Page<CheckPlan> page;
        lock.lock();
        try {
            page = checkPlanService.page(new Page<>(queryCheckPlanListParam.getPageNum(), queryCheckPlanListParam.getPageSize()), queryWrapper);
        }finally {
            lock.unlock();
        }
        return ResultData.success(page);
    }

    /**
     * 通过id删除检查计划
     *
     * @Param [id 检查计划id]
     * @Return com.zd.model.domain.ResultData
     **/
    @Log(title = "通过id删除检查计划", businessType = BusinessType.DELETE)
    //@DataPermission(permissionStr = PerPrefix.SECURITY_CHECK_PLAN)
    @PreAuthorize(hasAnyPermi = {PerPrefix.SECURITY_CHECK_PLAN + PerFun.REMOVE,PerPrefix.SECURITY_CHECK_PLAN_1 + PerFun.REMOVE})
    @DeleteMapping(value = "/delete")
    @ApiOperation("通过id删除检查计划")
    public ResultData delete(@RequestParam("id") Long id,
                             @RequestParam("checkType") Integer checkType) {
        boolean b = checkPlanService.deleteCheckPlan(id,checkType);
        if (b) {
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 查询历史计划标题列表
     * @Return com.zd.model.domain.ResultData
     **/
    @GetMapping(value = "/getHistoryPlanTitles")
    @ApiOperation("查询历史计划标题列表")
    public ResultData getHistoryPlanTitles() {
        List<CheckPlan> list = checkPlanService.list(new LambdaQueryWrapper<CheckPlan>()
                .eq(CheckPlan::getCreateBy, getCurrentUserId())
                .eq(CheckPlan::getHideTitle,0)
                .between(CheckPlan::getCreateTime, LocalDate.now().with(TemporalAdjusters.firstDayOfYear()), LocalDate.now().with(TemporalAdjusters.lastDayOfYear()))
                .orderByDesc(CheckPlan::getId));
        return ResultData.success(list);
    }

    /**
     * 隐藏历史计划标题
     * @Return com.zd.model.domain.ResultData
     **/
    @GetMapping(value = "/hideHistoryPlanTitle")
    @ApiOperation("隐藏历史计划标题")
    public ResultData deletHistoryPlanTitl(@RequestParam("checkPlanId") Long checkPlanId) {
        boolean update = checkPlanService.update(new LambdaUpdateWrapper<CheckPlan>().eq(CheckPlan::getId, checkPlanId).set(CheckPlan::getHideTitle, 1));
        if (update) {
            return ResultData.success();
        }
        return ResultData.fail();
    }

    /**
     * 查询检查计划各检查状态数据数量
     * @Return com.zd.model.domain.ResultData
     **/
    @GetMapping(value = "/getCheckStatusCount")
    @ApiOperation("查询检查计划各检查状态数据数量")
    public ResultData getCheckStatusCount() {
        Map<String,Long> map = new HashMap<>();
        long noStartNum = checkPlanService.count(new LambdaQueryWrapper<CheckPlan>().eq(CheckPlan::getCheckStatus, 1));
        long startNum = checkPlanService.count(new LambdaQueryWrapper<CheckPlan>().eq(CheckPlan::getCheckStatus, 2));
        map.put("noStart",noStartNum);
        map.put("start",startNum);
        return ResultData.success(map);
    }

    /**
     * 查询所有计划 所有人员信息列表
     * @Return com.zd.model.domain.ResultData
     **/
    @GetMapping(value = "/getAllCheckMemberList/{userId}")
    @ApiOperation("查询所有计划 所有人员信息列表")
    public ResultData getAllCheckMemberList(@PathVariable("userId") Long userId) {
        List<CheckPlan> list = checkPlanService.list(new LambdaQueryWrapper<CheckPlan>().and(i -> i.eq(CheckPlan::getCheckStatus, 1).or().eq(CheckPlan::getCheckStatus, 2)));
        if (list!=null && !list.isEmpty()){
            List<Long> checkPlanIdList = list.stream().map(CheckPlan::getId).collect(Collectors.toList());
            List<CheckMember> memberList = checkMemberService.list(new LambdaQueryWrapper<CheckMember>().in(CheckMember::getCheckPlanId, checkPlanIdList).eq(CheckMember::getUserId,userId));
            return ResultData.success(memberList);
        }
        return ResultData.success(new ArrayList<CheckMember>());
    }
}