package com.ruoyi.cs.service.impl;

import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.cs.domain.CsApprovalConfig;
import com.ruoyi.cs.domain.CsApprovalInfo;
import com.ruoyi.cs.domain.CsApprovalRecord;
import com.ruoyi.cs.domain.FileJsonObj;
import com.ruoyi.cs.domain.vo.CsAnnexApplyVO;
import com.ruoyi.cs.mapper.CsAnnexMapper;
import com.ruoyi.cs.mapper.CsApprovalInfoMapper;
import com.ruoyi.cs.service.ICsApprovalConfigService;
import com.ruoyi.cs.service.ICsApprovalInfoService;
import com.ruoyi.cs.service.ICsApprovalRecordService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 审核流程发起Service业务层处理
 *
 * @author cc
 * @date 2024-04-30
 */
@Service
public class CsApprovalInfoServiceImpl implements ICsApprovalInfoService
{
    @Autowired
    private CsApprovalInfoMapper csApprovalInfoMapper;

    @Resource
    private ICsApprovalConfigService approvalConfigService;
    @Resource
    private ICsApprovalRecordService approvalRecordService;
    @Autowired
    private CsAnnexMapper csAnnexMappre;

    /**
     * 查询审核流程发起
     *
     * @param approvalInfoId 审核流程发起主键
     * @return 审核流程发起
     */
    @Override
    public CsApprovalInfo selectCsApprovalInfoByApprovalInfoId(String approvalInfoId)
    {
        return csApprovalInfoMapper.selectCsApprovalInfoByApprovalInfoId(approvalInfoId);
    }

    @Override
    public CsApprovalInfo selectCsApprovalInfoByFormId(String formId) {
        return csApprovalInfoMapper.selectCsApprovalInfoByFormId(formId);
    }

    /**
     * 查询审核流程发起列表
     *
     * @param csApprovalInfo 审核流程发起
     * @return 审核流程发起
     */
    @Override
    public List<CsApprovalInfo> selectCsApprovalInfoList(CsApprovalInfo csApprovalInfo)
    {
        return csApprovalInfoMapper.selectCsApprovalInfoList(csApprovalInfo);
    }

    /**
     * 新增审核流程发起
     *
     * @param csApprovalInfo 审核流程发起
     * @return 结果
     */
    @Override
    public int insertCsApprovalInfo(CsApprovalInfo csApprovalInfo)
    {
        return csApprovalInfoMapper.insertCsApprovalInfo(csApprovalInfo);
    }

    /**
     * 修改审核流程发起
     *
     * @param csApprovalInfo 审核流程发起
     * @return 结果
     */
    @Override
    public int updateCsApprovalInfo(CsApprovalInfo csApprovalInfo)
    {
        return csApprovalInfoMapper.updateCsApprovalInfo(csApprovalInfo);
    }

    /**
     * 批量删除审核流程发起
     *
     * @param approvalInfoIds 需要删除的审核流程发起主键
     * @return 结果
     */
    @Override
    public int deleteCsApprovalInfoByApprovalInfoIds(String[] approvalInfoIds)
    {
        return csApprovalInfoMapper.deleteCsApprovalInfoByApprovalInfoIds(approvalInfoIds);
    }

    /**
     * 删除审核流程发起信息
     *
     * @param approvalInfoId 审核流程发起主键
     * @return 结果
     */
    @Override
    public int deleteCsApprovalInfoByApprovalInfoId(String approvalInfoId)
    {
        return csApprovalInfoMapper.deleteCsApprovalInfoByApprovalInfoId(approvalInfoId);
    }

    /**
     * 根据审核配置新增审核发起
     * @param config 审核配置节点
     * @return
     */
    @Override
    public int insertInfo(CsApprovalConfig config) {
        CsApprovalInfo add = new CsApprovalInfo();
        if (config.getApprovalInfoId() == null) {
            add.setApprovalInfoId(IdUtil.getSnowflakeNextIdStr());
        } else {
            add.setApprovalInfoId(config.getApprovalInfoId());
        }
        add.setApprovalConfigGroupId(config.getGroupId());
        add.setApprovalConfigId(config.getApprovalConfigId());
        add.setNodeType(config.getNodeType());
        add.setFormId(config.getFormId());
        add.setFormType(config.getFormType());

        add.setLaunchTime(DateUtils.getNowDate());
        add.setEndState(0);
        add.setProcessProgress(config.getApprovalNode());
        add.setDelFlag("0");
        add.setUserId(config.getCurrentNodeApprover());

        Integer approvalType = config.getApprovalType(); //1-并行; 2-串行;
        Long approvalNode = config.getApprovalNode();
        Long beforeNode = approvalNode -1;
        if(beforeNode != -1 && approvalType == 2){ //非0号节点 的串行(审核)节点

            CsApprovalInfo beforeApprovalInfo = csApprovalInfoMapper.selectBeforeCsApprovalInfo(beforeNode, config.getGroupId());
            //发起人 上一节点uid
            add.setFounder(beforeApprovalInfo.getUserId());
            //历史节点
            String historyNode = beforeApprovalInfo.getRecordNodeHistory();
            add.setRecordNodeHistory(historyNode+config.getApprovalNode()+',');
        }else if(approvalType == 1){//并行 执行节点
            //发起人为起始人
            // 审批节点[取值：1~N 从小到大；0：发起节点 、1：是第一个节点、 2：第二个节点 N：是第N个节点；最大的是结束节点]
            CsApprovalConfig csApprovalConfig = approvalConfigService.selectCsApprovalConfigByApprovalConfigId(0L, config.getFormId(), config.getFormType());
            if(ObjectUtils.isEmpty(csApprovalConfig)) {
                csApprovalConfig =  approvalConfigService.selectCsApprovalConfigByApprovalConfigId(null, config.getFormId(), config.getFormType());
            }
            add.setFounder(csApprovalConfig.getCurrentNodeApprover());
            //历史节点
            add.setRecordNodeHistory(",0,"+config.getApprovalNode()+',');
        }else{//审核发起节点
            //发起人为起始人
            add.setFounder(config.getCurrentNodeApprover());
            //历史节点
            add.setRecordNodeHistory(""+','+config.getApprovalNode()+',');
            csApprovalInfoMapper.insertCsApprovalInfo(add);
            // CsApprovalInfo csApprovalInfo = csApprovalInfoMapper.selectCsApprovalInfoByApprovalInfoId(add.getApprovalConfigId());
            CsApprovalRecord record = new CsApprovalRecord();
            record.setApprovalInfoId(add.getApprovalInfoId());
            record.setFormId(add.getFormId());
            record.setFormType(add.getFormType());
            record.setLastNode(0);
            record.setCloseApply(0);
            record.setApprovalNode(0);
            record.setApproverUserId(add.getUserId().toString());
            record.setApproverTime(add.getLaunchTime());
            record.setApproverResult(1);
            record.setApprovalRecordId(IdUtil.getSnowflakeNextIdStr());
            record.setDelFlag("0");
            //json 附件
            List<CsAnnexApplyVO> csAnnexApplyVOS = csAnnexMappre.selectApplyCsAnnexList(add.getFormId(), "1");
            if(!CollectionUtils.isEmpty(csAnnexApplyVOS)){
                record.setAccessoryUrl(JSON.toJSONString(csAnnexApplyVOS.stream().map(l ->
                        new FileJsonObj()
                                .setName(l.getAnnexName())
                                .setUrl(l.getAnnexUrl())
                                .setOriginalFilename(l.getName())
                ).collect(Collectors.toList())));
            }
            return approvalRecordService.insertCsApprovalRecord(record);
        }
        return csApprovalInfoMapper.insertCsApprovalInfo(add);
    }

    /**
     * 覆盖删除 申请单的审核流程节点规则配置
     * @param formId 资源/工单 ID
     * @param formType 申请单类型(0-资源, 1-工单)
     * @return
     */
    @Override
    public int deleteCoverApprovalInfoByApplyIdType(String formId, String formType) {
        return csApprovalInfoMapper.deleteCoverApprovalInfoByApplyIdType(formId, formType);
    }

    @Override
    public int deleteCoverApprovalInfoByApplyId(String formId) {
        return csApprovalInfoMapper.deleteCoverApprovalInfoByApplyId(formId);
    }

    /**
     * 查询审核流程发起（表单ID、用户ID）
     *
     * @param formId 表单ID
     * @param userId 用户ID
     * @return 审核流程发起
     */
    @Override
    public CsApprovalInfo selectCsApprovalInfoByFormIdUserId(String formId, Long userId) {
        return csApprovalInfoMapper.selectCsApprovalInfoByFormIdUserId(formId, userId);
    }

    /**
     * 删除审核流程发起信息
     *
     * @param approvalConfigId 审核流程发起主键
     * @return 结果
     */
    @Override
    public int deleteCsApprovalInfoByApprovalConfigId(String approvalConfigId) {
        return csApprovalInfoMapper.deleteCsApprovalInfoByApprovalConfigId(approvalConfigId);
    }

    /**
     * 查询审核流程发起（审核配置ID）
     *
     * @param approvalConfigId 审核配置ID
     * @return 审核流程发起
     */
    @Override
    public CsApprovalInfo selectCsApprovalInfoByApprovalConfigId(String approvalConfigId) {
        return csApprovalInfoMapper.selectCsApprovalInfoByApprovalConfigId(approvalConfigId);
    }

    /**
     * 批量删除审核流程发起信息
     *
     * @param list 审核配置
     * @return 结果
     */
    @Override
    public int bachDeleteCsApprovalInfoByList(List<CsApprovalConfig> list) {
        return csApprovalInfoMapper.bachDeleteCsApprovalInfoByList(list);
    }
}
