package com.zzg.web.controller.state;

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.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zzg.common.constant.state.UrlConstants;
import com.zzg.common.core.domain.AjaxResult;
import com.zzg.common.core.domain.BaseEntity;
import com.zzg.common.core.domain.entity.state.StateProcessModule;
import com.zzg.common.core.domain.entity.state.StateProcessTemplate;
import com.zzg.common.core.domain.entity.system.SysUser;
import com.zzg.common.core.page.PageDomain;
import com.zzg.common.enums.DeleteFlagEnum;
import com.zzg.common.exception.GlobalException;
import com.zzg.common.utils.SecurityUtils;
import com.zzg.system.domain.bo.ProcessAgreeBO;
import com.zzg.system.domain.bo.ProcessCreateBO;
import com.zzg.system.domain.bo.ProcessModuleUpdateBO;
import com.zzg.system.domain.bo.ProcessRefuseBO;
import com.zzg.system.domain.bo.ProcessStartBO;
import com.zzg.system.domain.bo.ProcessTaskListBO;
import com.zzg.system.domain.bo.ProcessTemplatePageBO;
import com.zzg.system.domain.bo.ProcessUpdateBO;
import com.zzg.system.domain.vo.ProcessTaskListVO;
import com.zzg.system.service.state.StateProcessModuleService;
import com.zzg.system.service.state.StateProcessTemplateService;
import com.zzg.system.service.system.ISysUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
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;

@RestController
@RequiredArgsConstructor
public class StateProcessController {

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

    //应用流程分页列表
    @PostMapping(UrlConstants.STATE_PROCESS_STATE_MODULE_PAGE)
    public AjaxResult<PageInfo<StateProcessModule>> modulePage(@RequestBody PageDomain pageDomain) {
        PageHelper.startPage(pageDomain.getPageNum(), pageDomain.getPageSize());
        LambdaQueryWrapper<StateProcessModule> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByAsc(StateProcessModule::getCategory);
        //查询应用流程列表
        List<StateProcessModule> moduleList = processModuleService.list(queryWrapper);
        if (CollectionUtils.isEmpty(moduleList)) {
            return AjaxResult.success(new PageInfo<>());
        }
        PageInfo<StateProcessModule> pageInfo = new PageInfo<>(moduleList);
        List<String> updateUserId = pageInfo.getList().stream().map(BaseEntity::getUpdateBy).collect(Collectors.toList());
        if (!CollectionUtils.isEmpty(updateUserId)){
            //根据用户id查询用户信息
            List<SysUser> sysUsers = sysUserService.selectUserByIdList(updateUserId);
            Map<String, SysUser> sysUserMap;
            if (!CollectionUtils.isEmpty(sysUsers)){
                sysUserMap = sysUsers.stream().collect(Collectors.toMap(SysUser::getUserId, Function.identity()));
            } else {
                sysUserMap = new HashMap<>();
            }
            //遍历列表，设置更新人名称
            pageInfo.getList().forEach(e -> {
                SysUser sysUser = sysUserMap.get(e.getUpdateBy());
                if (Objects.nonNull(sysUser)){
                    e.setUpdateBy(sysUser.getNickName());
                }
            });
        }
        return AjaxResult.success(pageInfo);
    }
    //修改应用流程
    @PostMapping(UrlConstants.STATE_PROCESS_STATE_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(new Date());
        stateProcessModule.setUpdateTime(new Date());
        stateProcessModule.setRemark(processModuleUpdateBO.getRemark());
        processModuleService.updateById(stateProcessModule);
        return AjaxResult.success();
    }

    //流程模版分页
    @PostMapping(UrlConstants.STATE_PROCESS_TEMPLATE_PAGE)
    public AjaxResult<Page<StateProcessTemplate>> page(ProcessTemplatePageBO request) {
        Page<StateProcessTemplate> templatePage = processTemplateService.page(request);

        return AjaxResult.success(templatePage);
    }

    //查询流程模版
    @GetMapping(UrlConstants.STATE_PROCESS_TEMPLATE_GET_BY_ID)
    public AjaxResult<StateProcessTemplate> selectById(@PathVariable String id) {
        return AjaxResult.success(processTemplateService.getById(id));
    }

    //修改并部署模版
    @PostMapping(UrlConstants.STATE_PROCESS_TEMPLATE_UPDATE)
    public AjaxResult<Boolean> update(@RequestBody ProcessUpdateBO processUpdateBO) {
        return AjaxResult.success(processTemplateService.update(processUpdateBO));
    }

    //删除模版
    @GetMapping(UrlConstants.STATE_PROCESS_TEMPLATE_DELETE)
    public AjaxResult<Boolean> deleteById(@PathVariable 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修改所有版本为已删除
        LambdaUpdateWrapper<StateProcessTemplate> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(StateProcessTemplate::getDelFlag, DeleteFlagEnum.DELETED.getKey());
        updateWrapper.eq(StateProcessTemplate::getTemplateKey, template.getTemplateKey());
        return AjaxResult.success(processTemplateService.update(updateWrapper));
    }

    //创建并部署模版
    @PostMapping(UrlConstants.STATE_PROCESS_TEMPLATE_CREATE)
    public AjaxResult<Boolean> create(@RequestBody ProcessCreateBO processCreateBO) {
        return AjaxResult.success(processTemplateService.create(processCreateBO));
    }

    //流程发起
    @PostMapping(UrlConstants.STATE_PROCESS_START)
    public AjaxResult<Boolean> start(@RequestBody ProcessStartBO processStartBO) {
        return AjaxResult.success(processTemplateService.start(processStartBO));
    }

    //待办
    @PostMapping(UrlConstants.STATE_PROCESS_WAIT_TASK_PAGE)
    public AjaxResult<PageInfo<ProcessTaskListVO>> waitTaskPage(@RequestBody ProcessTaskListBO processTemplatePageBO) {
        return AjaxResult.success(processTemplateService.waitTaskPage(processTemplatePageBO));
    }

    //已办
    @PostMapping(UrlConstants.STATE_PROCESS_DEAL_TASK_PAGE)
    public AjaxResult<PageInfo<ProcessTaskListVO>> dealTaskPage(@RequestBody ProcessTaskListBO processTemplatePageBO) {
        return AjaxResult.success(processTemplateService.dealTaskPage(processTemplatePageBO));
    }

    //抄送
    @PostMapping(UrlConstants.STATE_PROCESS_COPY_TASK_PAGE)
    public AjaxResult<PageInfo<ProcessTaskListVO>> copyTaskPage(@RequestBody ProcessTaskListBO processTaskListBO){
        return AjaxResult.success(processTemplateService.copyTaskPage(processTaskListBO));
    }

    //审核通过
    @PostMapping(UrlConstants.STATE_PROCESS_AGREE)
    public AjaxResult<Object> agree(@RequestBody ProcessAgreeBO processAgreeBO) {
        processTemplateService.agree(processAgreeBO);
        return AjaxResult.success();
    }

    //审核拒绝
    @PostMapping(UrlConstants.STATE_PROCESS_REFUSE)
    public AjaxResult<Object> refuse(@RequestBody ProcessRefuseBO processRefuseBO) {
        processTemplateService.refuse(processRefuseBO);
        return AjaxResult.success();
    }

}