package org.jeecg.modules.activiti.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.activiti.entity.ActivitiDefinition;
import org.jeecg.modules.activiti.mapper.ActivitiDefinitionMapper;
import org.jeecg.modules.activiti.request.ActivitiDefinitionRequest;
import org.jeecg.modules.activiti.service.IActivitiDefinitionService;
import org.jeecg.modules.dnc.exception.ExceptionCast;
import org.jeecg.modules.dnc.mapper.DepartmentMapper;
import org.jeecg.modules.dnc.response.ActivitiDefinitionCode;
import org.jeecg.modules.dnc.response.CommonCode;
import org.jeecg.modules.dnc.response.QueryPageResponseResult;
import org.jeecg.modules.dnc.ucenter.Department;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
public class ActivitiDefinitionServiceImpl extends ServiceImpl<ActivitiDefinitionMapper, ActivitiDefinition> implements IActivitiDefinitionService {
    @Autowired
    private DepartmentMapper departmentMapper;
    @Autowired
    private ISysUserService userService;
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addDefinition(ActivitiDefinition definition) {
        if(definition == null || !ValidateUtil.validateString(definition.getDepartId())
        || !ValidateUtil.validateString(definition.getActName()) || !ValidateUtil.validateString(definition.getApproveUsers()))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ActivitiDefinition en = getByDepartId(definition.getDepartId());
        if(en != null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_IS_EXIST);
        Department department = departmentMapper.selectById(definition.getDepartId());
        if(department == null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_DEPART_NONE);
        String[] userIds = definition.getApproveUsers().split(",");
        if(userIds == null|| userIds.length < 1)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        List<String> userIdList = new ArrayList<>(userIds.length);
        Collections.addAll(userIdList, userIds);
        Collection<SysUser> userList = userService.listByIds(userIdList);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        return super.save(definition);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editDefinition(String id, ActivitiDefinition definition) {
        if(!ValidateUtil.validateString(id) || definition == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ActivitiDefinition en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_NOT_EXIST);
        String[] userIds = definition.getApproveUsers().split(",");
        if(userIds == null|| userIds.length < 1)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        List<String> userIdList = new ArrayList<>(userIds.length);
        Collections.addAll(userIdList, userIds);
        Collection<SysUser> userList = userService.listByIds(userIdList);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        definition.setId(id);
        definition.setDepartId(null);
        return super.updateById(definition);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDefinition(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ActivitiDefinition en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_NOT_EXIST);
        return super.removeById(id);
    }

    @Override
    public ActivitiDefinition getByDepartId(String departId) {
        if(!ValidateUtil.validateString(departId))
            return null;
        List<ActivitiDefinition> list = super.lambdaQuery().eq(ActivitiDefinition::getDepartId, departId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public Result<?> findPageList(int page, int size, ActivitiDefinitionRequest request) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<ActivitiDefinition> pageData = new Page<>(page, size);
        LambdaQueryChainWrapper<ActivitiDefinition> lambdaQuery = super.lambdaQuery();
        if(request != null) {
            if(ValidateUtil.validateString(request.getActName())) {
                lambdaQuery.like(ActivitiDefinition::getActName, request.getActName());
            }
        }
        lambdaQuery.orderByDesc(ActivitiDefinition::getCreateTime);
        IPage<ActivitiDefinition> definitionIPage = lambdaQuery.page(pageData);
        return Result.ok(definitionIPage);

    }

    @Override
    public List<String> getByDepartIds(List<String> departIds) {
        if(departIds == null || departIds.isEmpty())
            return null;
        List<ActivitiDefinition> list = super.lambdaQuery().in(ActivitiDefinition::getDepartId, departIds).list();
        if(list == null || list.isEmpty())
            return null;
        Map<String, String> userIdMap = new HashMap<>();
        list.forEach(item -> {
            if(ValidateUtil.validateString(item.getApproveUsers())) {
                String[] arr = item.getApproveUsers().split(",");
                if(arr != null && arr.length > 0) {
                    for (String s : arr) {
                        userIdMap.put(s, s);
                    }
                }
            }
        });
        if(userIdMap.isEmpty())
            return null;
        List<String> userIds = new ArrayList<>();
        userIdMap.forEach((key, value) -> {
            userIds.add(key);
        });
        return userIds;
    }

    @Override
    public List<ActivitiDefinition> findByUserId(String userId) {
        return super.lambdaQuery().like(ActivitiDefinition::getApproveUsers, userId).list();
    }
}