package com.ruoyi.web.controller.api;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.BaseModel;
import com.ruoyi.common.core.domain.BasePage;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.exception.GlobalException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.bo.*;
import com.ruoyi.system.model.StateProcessModule;
import com.ruoyi.system.model.StateProcessTemplate;
import com.ruoyi.system.model.TContract;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.system.service.StateProcessModuleService;
import com.ruoyi.system.service.StateProcessTemplateService;
import com.ruoyi.system.vo.ProcessDetailVO;
import com.ruoyi.system.vo.ProcessTaskListVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

@Api(tags = "审批流程管理")
@RequestMapping("/state-process")
@RestController
@RequiredArgsConstructor
public class StateProcessController {

    private final StateProcessTemplateService processTemplateService;
    private final StateProcessModuleService processModuleService;
    private final ISysUserService sysUserService;

    //应用流程分页列表
    @ApiOperation("应用流程分页列表")
    @PostMapping("/module/page")
    public AjaxResult<List<StateProcessModule>> modulePage(@RequestBody BasePage basePage) {
        LambdaQueryWrapper<StateProcessModule> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByAsc(StateProcessModule::getCategory);
        //查询应用流程列表
        List<StateProcessModule> result = processModuleService.list(queryWrapper);
        List<String> updateUserId = result.stream().map(BaseModel::getUpdateBy).collect(Collectors.toList());
        if (!CollectionUtils.isEmpty(updateUserId)){
            //根据用户id查询用户信息
            List<SysUser> sysUsers = sysUserService.selectUserByUserNameList(updateUserId);
            Map<Long, SysUser> sysUserMap;
            if (!CollectionUtils.isEmpty(sysUsers)){
                sysUserMap = sysUsers.stream().collect(Collectors.toMap(SysUser::getUserId, Function.identity()));
            } else {
                sysUserMap = new HashMap<>();
            }
            //遍历列表，设置更新人名称
            result.forEach(e -> {
                SysUser sysUser = sysUserMap.get(e.getUpdateBy());
                if (Objects.nonNull(sysUser)){
                    e.setUpdateBy(sysUser.getNickName());
                }
            });
        }
        return AjaxResult.success(result);
    }
    //修改应用流程
    @Log(title = "审批流程管理-修改应用流程", businessType = BusinessType.UPDATE)
    @ApiOperation("修改应用流程")
    @PostMapping("/module/update")
    public AjaxResult<PageInfo<StateProcessModule>> moduleUpdate(@RequestBody ProcessModuleUpdateBO processModuleUpdateBO) {
        StateProcessTemplate stateProcessTemplate = processTemplateService.getById(processModuleUpdateBO.getTemplateId());
        if (Objects.isNull(stateProcessTemplate)) {
            return AjaxResult.success();
        }
        StateProcessModule stateProcessModule = new StateProcessModule();
        stateProcessModule.setId(processModuleUpdateBO.getId());
        stateProcessModule.setTemplateId(processModuleUpdateBO.getTemplateId());
        stateProcessModule.setTemplateName(stateProcessTemplate.getTemplateName());
        stateProcessModule.setUpdateBy(SecurityUtils.getLoginUser().getUser().getNickName());
        stateProcessModule.setCreateTime(LocalDateTime.now());
        stateProcessModule.setUpdateTime(LocalDateTime.now());
        stateProcessModule.setRemark(processModuleUpdateBO.getRemark());
        processModuleService.updateById(stateProcessModule);
        return AjaxResult.success();
    }

    //流程模版分页
    @ApiOperation("流程模版分页")
    @PostMapping("/template/page")
    public AjaxResult<Page<StateProcessTemplate>> page(ProcessTemplatePageBO request) {
        Page<StateProcessTemplate> templatePage = processTemplateService.page(request);
        return AjaxResult.success(templatePage);
    }

    //查询流程模版
    @ApiOperation("查询流程模版")
    @GetMapping("/template/getById")
    public AjaxResult<StateProcessTemplate> selectById(@RequestParam String id) {
        return AjaxResult.success(processTemplateService.getById(id));
    }

    //修改并部署模版
    @Log(title = "审批流程管理-修改并部署模版", businessType = BusinessType.UPDATE)
    @ApiOperation("修改并部署模版")
    @PostMapping("/template/update")
    public AjaxResult<Boolean> update(@RequestBody ProcessUpdateBO processUpdateBO) {
        return AjaxResult.success(processTemplateService.update(processUpdateBO));
    }

    //删除模版
    @Log(title = "审批流程管理-删除模版", businessType = BusinessType.DELETE)
    @ApiOperation("删除模版")
    @GetMapping("/template/deleteById")
    public AjaxResult<Boolean> deleteById(@RequestParam String id) {
        StateProcessTemplate template = processTemplateService.getById(id);
        //查询是否存在使用的
        LambdaUpdateWrapper<StateProcessModule> moduleLambdaUpdateWrapper = new LambdaUpdateWrapper<>();;
        moduleLambdaUpdateWrapper.eq(StateProcessModule::getTemplateId, template.getId());
        if (processModuleService.getBaseMapper().exists(moduleLambdaUpdateWrapper)) {
            throw new GlobalException("该模版在应用流程中已使用！");
        }
        //根据key修改所有版本为已删除
        boolean result = processTemplateService.remove(Wrappers.lambdaQuery(StateProcessTemplate.class)
                .eq(StateProcessTemplate::getTemplateKey, template.getTemplateKey()));
        return AjaxResult.success(result);
    }

    //创建并部署模版
    @Log(title = "审批流程管理-创建并部署模版", businessType = BusinessType.INSERT)
    @ApiOperation("创建并部署模版")
    @PostMapping("/template/create")
    public AjaxResult<Boolean> create(@RequestBody ProcessCreateBO processCreateBO) {
        return AjaxResult.success(processTemplateService.create(processCreateBO));
    }

    //流程发起
    @Log(title = "审批流程管理-流程发起", businessType = BusinessType.INSERT)
    @ApiOperation("流程发起")
    @PostMapping("/start")
    public AjaxResult<Boolean> start(@RequestBody ProcessStartBO processStartBO) {
        return AjaxResult.success(processTemplateService.start(processStartBO));
    }

    //待办
    @ApiOperation("待办列表")
    @PostMapping("/wait/task/page")
    public AjaxResult<PageInfo<ProcessTaskListVO>> waitTaskPage(@RequestBody ProcessTaskListBO processTemplatePageBO) {
        return AjaxResult.success(processTemplateService.waitTaskPageApplet(processTemplatePageBO));
    }

    //已办
    @ApiOperation("已办列表")
    @PostMapping("/deal/task/page")
    public AjaxResult<PageInfo<ProcessTaskListVO>> dealTaskPage(@RequestBody ProcessTaskListBO processTemplatePageBO) {
        return AjaxResult.success(processTemplateService.dealTaskPageApplet(processTemplatePageBO));
    }

    //我发起的
    @ApiOperation("我发起的列表")
    @PostMapping("/initiate/task/page")
    public AjaxResult<PageInfo<ProcessTaskListVO>> initiateTaskPage(@RequestBody ProcessTaskListBO processTemplatePageBO) {
        return AjaxResult.success(processTemplateService.initiateTaskPage(processTemplatePageBO));
    }

    //抄送
    @ApiOperation("抄送列表")
    @PostMapping("/copy/task/page")
    public AjaxResult<PageInfo<ProcessTaskListVO>> copyTaskPage(@RequestBody ProcessTaskListBO processTaskListBO){
        return AjaxResult.success(processTemplateService.copyTaskPage(processTaskListBO));
    }

    //审核通过
    @Log(title = "审批流程管理-审核通过", businessType = BusinessType.UPDATE)
    @ApiOperation("审核通过")
    @PostMapping("/agree")
    public AjaxResult<Object> agree(@RequestBody ProcessAgreeBO processAgreeBO) {
        processTemplateService.agree(processAgreeBO);
        return AjaxResult.success();
    }

    //审核拒绝
    @Log(title = "审批流程管理-审核拒绝", businessType = BusinessType.UPDATE)
    @ApiOperation("审核拒绝")
    @PostMapping("/refuse")
    public AjaxResult<Object> refuse(@RequestBody ProcessRefuseBO processRefuseBO) {
        processTemplateService.refuse(processRefuseBO);
        return AjaxResult.success();
    }

    //审核详情
    @ApiOperation("审核详情")
    @GetMapping("/detail")
    public AjaxResult<ProcessDetailVO> detail(@RequestParam String taskId) {
        ProcessDetailVO detail = processTemplateService.detail(taskId);
        return AjaxResult.success(detail);
    }

}