package com.zt.modules.workflowconfig.service;

import cn.hutool.core.convert.Convert;
import com.zt.common.db.query.QueryFilter;
import com.zt.common.exception.RenException;
import com.zt.common.service.BaseService;
import com.zt.modules.sys.model.SysRoleMenu;
import com.zt.modules.sys.service.SysRoleMenuService;
import com.zt.modules.sys.service.SysRoleUserService;
import com.zt.modules.workflowconfig.dao.WfDefStepDao;
import com.zt.modules.workflowconfig.dto.FlowMenuDto;
import com.zt.modules.workflowconfig.model.WfDef;
import com.zt.modules.workflowconfig.model.WfDefStep;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class WorkflowConfigService extends BaseService<WfDefStepDao, WfDefStep> {

    @Autowired
    private WfDefStepDao wfDefStepDao;

    @Autowired
    private SysRoleMenuService sysRoleMenuService;

    @Autowired
    private SysRoleUserService sysRoleUserService;
    /**
     * 根据id查询流程配置列表
     *
     * @param queryFilter
     * @return
     */
    public List<WfDefStep> queryStepsList(QueryFilter queryFilter) {
        List<WfDefStep> wfDefStepList = wfDefStepDao.queryStepsList(queryFilter.getQueryParams());
        return wfDefStepList;
    }

    /**
     * 查询工作流下拉框
     *
     * @return
     */
    public List<WfDef> workflowSelect() {
        return wfDefStepDao.workflowSelect();
    }



    /**
     * 按 ID 获取工作流程步骤列表
     *
     * @param id
     * @return
     */
    public WfDefStep getWorkflowStepsListById(Long id) {
        WfDefStep  result = baseDao.selectById(id);
        return result;
    }

    public WfDefStep getWorkflowStepByCode(String stepCode) {
        WfDefStep  result = baseDao.getWorkflowStepByCode(stepCode);
        return result;
    }

    /**
     * 根据步骤获取相关审核用户
     *
     * @param stepsId
     * @return
     */
    public List<WfDefStep> getUserByWorkflowSteps(Long stepsId) {
        return baseDao.getUserByWorkflowSteps(stepsId);
    }

    /**
     * 查询用户列表
     *
     * @param queryFilter
     * @return
     */
    public List<WfDefStep> getUserList(QueryFilter queryFilter) {
        return queryFilter.getPageList(baseDao.getUserList(queryFilter.getQueryParams()));
    }

    /**
     * 添加工作流步骤审核用户
     *
     * @param approver_ids
     * @param id
     */
    public void addWorkflowStepsUser(String approver_ids, Long id) {
        WfDefStep wfDefStep = baseDao.selectById(id);
        StringBuffer sb = new StringBuffer();
        if (StringUtils.isNotBlank(wfDefStep.getApproverIds())) {
            sb.append(wfDefStep.getApproverIds());
            sb.append(",");
            sb.append(approver_ids);
            baseDao.addWorkflowStepsUser(sb.toString(), id);
        } else {
            baseDao.addWorkflowStepsUser(approver_ids, id);
        }
    }

    /**
     * 删除工作流步骤审核用户
     *
     * @param userId
     * @param stepId
     */
    public void deleteWorkflowStepsUser(String userId, String stepId) {
        WfDefStep wfDefStep = baseDao.selectById(stepId);
        if (StringUtils.isNotBlank(wfDefStep.getApproverIds())) {
            String[] newAppRoverId = userId.split(",");
            String[] oldAppRoverId = wfDefStep.getApproverIds().split(",");
            String appRoverId = "";
            for (int i = 0; i < oldAppRoverId.length; i++) {
                int num = 0;
                for (int j = 0; j < newAppRoverId.length; j++) {
                    if (oldAppRoverId[i].equals(newAppRoverId[j])) {
                        num = num + 1;
                    }
                }
                if (num == 0) {
                    appRoverId += oldAppRoverId[i] + ",";
                }
                num = 0;
            }
            baseDao.deleteWorkflowStepsUser(appRoverId, stepId);
        } else {
            throw new RenException("请添加数据后删除");
        }
    }

    /**
     * 添加工作流流程步骤
     *
     * @param wfDefStep
     */
    @Override
    public void insert(WfDefStep wfDefStep) {
        //wfDefStep.setIsDelete(0);
        super.insert(wfDefStep);
    }

    /**
     * 删除工作流流程步骤
     *
     * @param ids
     */
    public void delete(Long[] ids) {
        for (Long id : ids) {
            baseDao.delete(id);
        }
    }


    /**
     * 根据步骤获取相关审核用户
     *
     * @param stepsId
     * @return
     */
    public List<WfDefStep> getRoleByWorkflowSteps(Long stepsId) {
        List<WfDefStep> list = baseDao.getRoleByWorkflowSteps(stepsId);
        return list;
    }

    /**
     * 查询用户列表
     *
     * @param queryFilter
     * @return
     */
    public List<WfDefStep> getRoleList(QueryFilter queryFilter) {
        List<WfDefStep> list = queryFilter.getPageList(baseDao.getRoleList(queryFilter.getQueryParams()));
        return list;
    }

    /**
     * 添加工作流步骤审核用户
     *
     * @param approver_ids
     * @param id
     */
    public void addWorkflowStepsRole(String approver_ids, Long id) {
        WfDefStep wfDefStep = baseDao.selectById(id);
        StringBuffer sb = new StringBuffer();
        if (StringUtils.isNotBlank(wfDefStep.getApproverRoleIds())) {
            sb.append(wfDefStep.getApproverRoleIds());
            sb.append(",");
            sb.append(approver_ids);
            baseDao.addWorkflowStepsRole(sb.toString(), id);
        } else {
            baseDao.addWorkflowStepsRole(approver_ids, id);
        }
    }

    /**
     * 删除工作流步骤审核用户
     *
     * @param roleId
     * @param stepId
     */
    public void deleteWorkflowStepsRole(String roleId, String stepId) {
        WfDefStep wfDefStep = baseDao.selectById(stepId);
        if (StringUtils.isNotBlank(wfDefStep.getApproverRoleIds())) {
            String[] newAppRoverId = roleId.split(",");
            String[] oldAppRoverId = wfDefStep.getApproverRoleIds().split(",");
            String appRoverId = "";
            for (int i = 0; i < oldAppRoverId.length; i++) {
                int num = 0;
                for (int j = 0; j < newAppRoverId.length; j++) {
                    if (oldAppRoverId[i].equals(newAppRoverId[j])) {
                        num = num + 1;
                    }
                }
                if (num == 0) {
                    appRoverId += oldAppRoverId[i] + ",";
                }
                num = 0;
            }
            baseDao.deleteWorkflowStepsRole(appRoverId, stepId);
        } else {
            throw new RenException("请添加数据后删除");
        }
    }

    public void refreshFlowMenu() {
        //baseDao.deleteFlowMenu();

         //没有待办、已办菜单权限的菜单权限记录的角色的更改为有效（sys_role_menu 更改is_delete=0）
        List<FlowMenuDto> list = baseDao.selectFlowMenu();
        for (FlowMenuDto item : list
        ) {
            String roleId = item.getRoleId();
            String menuId = item.getMenuId();
            String menuId2 = item.getMenuId2();
            Long id2 = item.getId2();
            if (!StringUtils.isEmpty(menuId2)) {
                //选择了角色没有待办、已办菜单权限的菜单权限记录被删除了的更改为有效（sys_role_menu 更改is_delete=0）
                SysRoleMenu sysRoleMenu = sysRoleMenuService.get(id2);
                sysRoleMenu.setDelete(false);
                sysRoleMenuService.update(sysRoleMenu);
            } else {
                //选择了角色没有待办、已办菜单权限的加上菜单权限记录
                SysRoleMenu sysRoleMenu = new SysRoleMenu();
                sysRoleMenu.setRoleId(Convert.toLong(roleId));
                sysRoleMenu.setMenuId(Convert.toLong(menuId));
                sysRoleMenu.setDelete(false);
                sysRoleMenuService.insert(sysRoleMenu);
            }
        }
        baseDao.deleteRoleFlowMenu();
    }
    public void refreshFlowMenuOld() {
        //baseDao.deleteFlowMenu();
        //选择了角色没有待办、已办菜单权限的加上菜单权限记录
        //选择了角色没有待办、已办菜单权限的菜单权限记录被删除了的更改为有效（sys_role_menu 更改is_delete=0）
        //没有待办、已办菜单权限的菜单权限记录的角色的更改为有效（sys_role_menu 更改is_delete=0）
        List<FlowMenuDto> list = baseDao.selectFlowMenu();
        for (FlowMenuDto item : list
        ) {
            String roleId = item.getRoleId();
            String menuId = item.getMenuId();
            String menuId2 = item.getMenuId2();
            Long id2 = item.getId2();
            if (!StringUtils.isEmpty(menuId2)) {
                SysRoleMenu sysRoleMenu = sysRoleMenuService.get(id2);
                if (StringUtils.isEmpty(menuId)) {
                    if (!sysRoleMenu.isDelete()) {
                        sysRoleMenu.setDelete(true);
                        sysRoleMenuService.update(sysRoleMenu);
                    }
                } else {
                    if (sysRoleMenu.isDelete()) {
                        sysRoleMenu.setDelete(false);
                        sysRoleMenuService.update(sysRoleMenu);
                    }
                }
            } else {
                SysRoleMenu sysRoleMenu = new SysRoleMenu();
                sysRoleMenu.setRoleId(Convert.toLong(roleId));
                sysRoleMenu.setMenuId(Convert.toLong(menuId));
                sysRoleMenu.setDelete(false);
                sysRoleMenuService.insert(sysRoleMenu);
            }
        }
    }
}