package com.project.approval.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.project.approval.domain.ApprovalNode;
import com.project.approval.domain.ApprovalNodeLink;
import com.project.approval.domain.vo.ApprovalNodeVo;
import com.project.approval.service.IApprovalNodeLinkService;
import com.project.approval.service.IApprovalNodeService;
import com.project.common.constant.ApprovalConstants;
import com.project.common.exception.base.BaseException;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import cn.hutool.core.convert.Convert;
import com.project.common.utils.StringUtils;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.springframework.transaction.annotation.Transactional;
import com.project.approval.domain.vo.ApprovalFlowVo;
import com.project.approval.domain.bo.editBo.ApprovalFlowBo;
import com.project.approval.domain.bo.queryBo.ApprovalFlowQueryBo;
import com.project.approval.domain.ApprovalFlow;
import com.project.approval.mapper.ApprovalFlowMapper;
import com.project.approval.service.IApprovalFlowService;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 审批流程Service业务层处理
 *
 * @author manton
 */
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class ApprovalFlowServiceImpl extends ServiceImpl<ApprovalFlowMapper, ApprovalFlow> implements IApprovalFlowService {

    private final IApprovalNodeLinkService linkService;
    private final IApprovalNodeService nodeService;

    @Override//列表查询
    public List<ApprovalFlowVo> queryList(ApprovalFlowQueryBo bo)
    {
        QueryWrapper<ApprovalFlow> qw = getQw(bo);
        List<ApprovalFlow> list = this.list(qw);
        return Convert.toList(ApprovalFlowVo.class , list);
    }

    @Override//id查询
    public ApprovalFlowVo queryById(Long flowId)
    {
        ApprovalFlow db = this.baseMapper.selectById(flowId);
        ApprovalFlowVo vo = Convert.convert(ApprovalFlowVo.class, db);
        this.setChildByFlowId(vo);
        return vo;
    }

    @Override//添加
    @Transactional
    public Boolean insertByBo(ApprovalFlowBo bo)
    {
        saveFlowByBo(bo);
        List<ApprovalNodeVo> nodeVos = new ArrayList<>();
        List<ApprovalNodeVo> voList = getLinkNode(nodeVos, bo);
        ApprovalFlow one = this.getOne(new LambdaQueryWrapper<ApprovalFlow>().eq(ApprovalFlow::getFlowName, bo.getFlowName()));
        List<Long> collect = voList.stream().map(ApprovalNodeVo::getNodeId).collect(Collectors.toList());
        String join = StringUtils.join(collect,",",0,collect.size());
        ApprovalNodeLink saveLink = new ApprovalNodeLink().setFlowId(one.getFlowId()).setNodeIds(join);
        linkService.save(saveLink);
        return true;
    }

    @Override//修改
    @Transactional
    public Boolean updateByBo(ApprovalFlowBo bo)
    {
        saveFlowByBo(bo);
        List<ApprovalNodeVo> nodeVos = new ArrayList<>();
        List<ApprovalNodeVo> voList = getLinkNode(nodeVos, bo);
        ApprovalFlow one = this.getOne(new LambdaQueryWrapper<ApprovalFlow>().eq(ApprovalFlow::getFlowName, bo.getFlowName()));
        List<Long> collect = voList.stream().map(ApprovalNodeVo::getNodeId).collect(Collectors.toList());
        String join = StringUtils.join(collect,",",0,collect.size());
        ApprovalNodeLink saveLink = new ApprovalNodeLink().setFlowId(one.getFlowId()).setNodeIds(join);
        linkService.updateById(saveLink);
        return true;
    }

    @Override//删除
    @Transactional
    public Boolean deleteByIds(Collection<Long> ids)
    {

        //做一些业务上的校验,判断是否需要校验

        return this.removeByIds(ids);
    }


//-------------------------------------------------------------------------------------

    /**
     * 根据bo保存流程
     * @param bo    参数
     */
    @Transactional
    public void saveFlowByBo(ApprovalFlowBo bo)
    {
        validBo(bo);
        ApprovalFlow save = Convert.convert(ApprovalFlow.class, bo);
        List<Long> collect = bo.getNodeVos().stream().map(ApprovalNodeVo::getNodeId).collect(Collectors.toList());
        String join = StringUtils.join(collect,",",0,collect.size());
        save.setFlowNodeIds(join);
        validEntityBeforeSave(save);
        this.saveOrUpdate(save);
        ApprovalFlow one = this.getOne(new LambdaQueryWrapper<ApprovalFlow>().eq(ApprovalFlow::getFlowName, save.getFlowName()));
        bo.setFlowId(one.getFlowId());
        if (StringUtils.isNotEmpty(bo.getChild())){
            for (ApprovalFlowBo approvalFlowBo : bo.getChild()) {
                approvalFlowBo.setParentId(one.getFlowId());
                this.saveFlowByBo(approvalFlowBo);
            }
        }
    }

    /**
     * 获取线性节点
     * @param nodeVos   节点数组
     * @param bo    参数
     * @return  线性节点
     */
    private List<ApprovalNodeVo> getLinkNode(List<ApprovalNodeVo> nodeVos, ApprovalFlowBo bo)
    {
        nodeVos.addAll(bo.getNodeVos());
        if (StringUtils.isNotEmpty(bo.getChild())){
            for (ApprovalFlowBo approvalFlowBo : bo.getChild()) {
                return this.getLinkNode(nodeVos, approvalFlowBo);
            }
        } else {
            return nodeVos;
        }
        return nodeVos;
    }

    /**
     * 设置子流程
     * @param vo    流程vo
     */
    private void setChildByFlowId(ApprovalFlowVo vo)
    {
        List<ApprovalFlow> list = this.list(new LambdaQueryWrapper<ApprovalFlow>().eq(ApprovalFlow::getParentId, vo.getFlowId()));
        String[] nodeIdStrArr = vo.getFlowNodeIds().split(",");
        List<String> nodeIdStrList = Arrays.asList(nodeIdStrArr);
        List<Long> nodeIdList = nodeIdStrList.stream().map(Long::parseLong).collect(Collectors.toList());
        List<ApprovalNode> nodeList = nodeService.list(new LambdaQueryWrapper<ApprovalNode>().in(ApprovalNode::getNodeId, nodeIdList));
        List<ApprovalNodeVo> nodeVos = Convert.toList(ApprovalNodeVo.class, nodeList);
        vo.setNodeVos(nodeVos);
        List<ApprovalFlowVo> child = null;
        if (StringUtils.isNotEmpty(list)) {
            child = Convert.toList(ApprovalFlowVo.class, list);
            for (ApprovalFlowVo approvalFlowVo : child) {
                this.setChildByFlowId(approvalFlowVo);
            }
        }
        vo.setChild(child);
    }


    /**
     * 必要参数校验
     * @param bo    参数
     */
    private void validBo(ApprovalFlowBo bo)
    {
        if (StringUtils.isEmpty(bo.getNodeVos())){
            throw new BaseException(ApprovalConstants.LOSS_FLOW_NODE);
        }
        if (StringUtils.isNotEmpty(bo.getChild())){
            for (ApprovalFlowBo childBo : bo.getChild()) {
                validBo(childBo);
            }
        }
    }


    /**
     * 实体校验，处理必要数据
     * @param entity    实体
     */
    private void validEntityBeforeSave(ApprovalFlow entity)
    {
        int nameCount = 0;
        if (entity.getFlowId()==null){ //新增
            nameCount = this.count(ApprovalFlow::getFlowName, entity.getFlowName());
        } else { //修改
            nameCount = this.count(new LambdaQueryWrapper<ApprovalFlow>()
                    .eq(ApprovalFlow::getFlowName, entity.getFlowName())
                    .ne(ApprovalFlow::getFlowId, entity.getFlowId()));
        }
        if (nameCount>0) {
            throw new BaseException(ApprovalConstants.EXIST_FLOW_NAME);
        }
    }


    /**
     * 获取查询条件
     * @param bo    入参
     * @return  查询条件
     */
    private QueryWrapper<ApprovalFlow> getQw(ApprovalFlowQueryBo bo)
    {
        QueryWrapper<ApprovalFlow> qw = Wrappers.query();

            qw.like(StringUtils.isNotEmpty(bo.getFlowName()), "flow_name", bo.getFlowName());
            qw.eq(StringUtils.isNotEmpty(bo.getFlowCode()), "flow_code", bo.getFlowCode());
            qw.eq(bo.getParentId() != null, "parent_id", bo.getParentId());
            qw.eq(StringUtils.isNotEmpty(bo.getFlowStatic()), "flow_static", bo.getFlowStatic());
            qw.eq(bo.getSortNum() != null, "sort_num", bo.getSortNum());
        if (StringUtils.isNotEmpty(bo.getIsAsc()) && StringUtils.isNotEmpty(bo.getOrderByColumn())){
            if ("acs".equals(bo.getIsAsc())) {
                qw.orderByAsc(bo.getOrderByColumn());
            } else if ("desc".equals(bo.getIsAsc())) {
                qw.orderByDesc(bo.getOrderByColumn());
            }
        }
        return qw;
    }
}