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

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.modules.dnc.entity.PermissionStream;
import org.jeecg.modules.dnc.mapper.PermissionStreamMapper;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.dnc.service.IPermissionStreamService;
import org.apache.commons.collections4.ListUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

@Service
public class PermissionStreamServiceImpl extends ServiceImpl<PermissionStreamMapper, PermissionStream> implements IPermissionStreamService {
    @Override
    public PermissionStream getByProductIdAndUserId(String productId, String userId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(userId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                eq(PermissionStream::getUserId, userId).isNull(PermissionStream::getComponentId).isNull(PermissionStream::getPartsId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public PermissionStream getByComponentIdAndUserId(String productId, String componentId, String userId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(userId)
                || !ValidateUtil.validateString(componentId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                eq(PermissionStream::getUserId, userId).eq(PermissionStream::getComponentId, componentId)
                .isNull(PermissionStream::getPartsId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public PermissionStream getByPartsIdAndUserId(String productId, String componentId, String partsId, String userId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(userId)
                || !ValidateUtil.validateString(componentId) || !ValidateUtil.validateString(partsId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                eq(PermissionStream::getUserId, userId).eq(PermissionStream::getComponentId, componentId)
                .eq(PermissionStream::getPartsId, partsId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    /**
     * 根据零件编号，用户编号查找权限-工序
     * @param productId
     * @param componentId
     * @param userId
     * @param partsId
     * @return
     */
    @Override
    public PermissionStream getByProcessIdAndUserId(String productId, String componentId, String partsId,String processId,String userId){
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(userId)
                || !ValidateUtil.validateString(componentId) || !ValidateUtil.validateString(processId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                eq(PermissionStream::getUserId, userId).eq(PermissionStream::getComponentId, componentId)
                .eq(StrUtil.isNotEmpty(partsId),PermissionStream::getPartsId, partsId)
                .eq(PermissionStream::getProcessId, processId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    /**
     * 根据零件编号，用户编号查找权限-工步
     * @param productId
     * @param componentId
     * @param userId
     * @param partsId
     * @return
     */
    @Override
    public PermissionStream getByStepIdAndUserId(String productId, String componentId, String partsId,String processId,String stepId, String userId){
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(userId)
                || !ValidateUtil.validateString(componentId) || !ValidateUtil.validateString(processId)
                || !ValidateUtil.validateString(stepId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                eq(PermissionStream::getUserId, userId).eq(PermissionStream::getComponentId, componentId)
                .eq(StrUtil.isNotEmpty(partsId),PermissionStream::getPartsId, partsId)
                .eq(PermissionStream::getProcessId, processId)
                .eq(PermissionStream::getStepId, stepId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public List<PermissionStream> getByProductId(String productId) {
        if(!ValidateUtil.validateString(productId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                isNull(PermissionStream::getUserId).isNull(PermissionStream::getComponentId).isNull(PermissionStream::getPartsId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }

    @Override
    public List<PermissionStream> getByComponentId(String productId, String componentId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(componentId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                isNull(PermissionStream::getUserId).eq(PermissionStream::getComponentId, componentId)
                .isNull(PermissionStream::getPartsId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }

    @Override
    public List<PermissionStream> getByPartsId(String productId, String componentId, String partsId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(componentId)
                || !ValidateUtil.validateString(partsId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                isNull(PermissionStream::getUserId).eq(PermissionStream::getComponentId, componentId)
                .eq(PermissionStream::getPartsId, partsId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }

    @Override
    public List<PermissionStream> getByProcessId(String productId, String componentId, String partsId, String processId){
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(componentId)
                || !ValidateUtil.validateString(partsId) || !ValidateUtil.validateString(processId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).
                isNull(PermissionStream::getUserId).eq(PermissionStream::getComponentId, componentId)
                .eq(PermissionStream::getPartsId, partsId).eq(PermissionStream::getProcessId,processId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteUserPermsByProductId(String productId) {
        if(!ValidateUtil.validateString(productId))
            return false;
        LambdaQueryWrapper<PermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(PermissionStream::getProductId, productId).isNull(PermissionStream::getDepartId)
                .isNull(PermissionStream::getComponentId).isNull(PermissionStream::getPartsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteUserPermsByComponentId(String productId, String componentId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(componentId))
            return false;
        LambdaQueryWrapper<PermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(PermissionStream::getProductId, productId).isNull(PermissionStream::getDepartId)
                .eq(PermissionStream::getComponentId, componentId).isNull(PermissionStream::getPartsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteUserPermsByPartsId(String productId, String componentId, String partsId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(componentId)
                || !ValidateUtil.validateString(partsId))
            return false;
        LambdaQueryWrapper<PermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(PermissionStream::getProductId, productId).isNull(PermissionStream::getDepartId)
                .eq(PermissionStream::getComponentId, componentId).eq(PermissionStream::getPartsId, partsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDepartPermsByProductId(String productId) {
        if(!ValidateUtil.validateString(productId))
            return false;
        LambdaQueryWrapper<PermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(PermissionStream::getProductId, productId).isNull(PermissionStream::getUserId)
                .isNull(PermissionStream::getComponentId).isNull(PermissionStream::getPartsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDepartPermsByComponentId(String productId, String componentId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(componentId))
            return false;
        LambdaQueryWrapper<PermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(PermissionStream::getProductId, productId).isNull(PermissionStream::getUserId)
                .eq(PermissionStream::getComponentId, componentId).isNull(PermissionStream::getPartsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDepartPermsByPartsId(String productId, String componentId, String partsId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(componentId)
                || !ValidateUtil.validateString(partsId))
            return false;
        LambdaQueryWrapper<PermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(PermissionStream::getProductId, productId).isNull(PermissionStream::getUserId)
                .eq(PermissionStream::getComponentId, componentId).eq(PermissionStream::getPartsId, partsId);
        return super.remove(lambdaQueryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean removeByCollection(List<PermissionStream> permissionStreamList) {
        if(permissionStreamList == null || permissionStreamList.isEmpty())
            return false;
        if(permissionStreamList.size() == 1) {
            return super.removeById(permissionStreamList.get(0).getStreamId());
        }
        List<String> ids = new ArrayList<>();
        permissionStreamList.forEach(item -> {
            ids.add(item.getStreamId());
        });
        return super.removeByIds(ids);
    }

    @Override
    public PermissionStream getByProductIdAndDepartId(String productId, String departId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(departId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).eq(PermissionStream::getDepartId, departId)
                .isNull(PermissionStream::getComponentId).isNull(PermissionStream::getPartsId)
                .isNull(PermissionStream::getUserId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public PermissionStream getByComponentIdAndDepartId(String productId, String componentId, String departId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(departId) || !ValidateUtil.validateString(componentId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).eq(PermissionStream::getDepartId, departId)
                .eq(PermissionStream::getComponentId, componentId).isNull(PermissionStream::getPartsId)
                .isNull(PermissionStream::getUserId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public PermissionStream getByPartsIdAndDepartId(String productId, String componentId, String partsId, String departId) {
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(departId)
                || !ValidateUtil.validateString(componentId) || !ValidateUtil.validateString(partsId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).eq(PermissionStream::getDepartId, departId)
                .eq(PermissionStream::getComponentId, componentId).eq(PermissionStream::getPartsId, partsId)
                .isNull(PermissionStream::getUserId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    /**
     * 根据工序编号，用户编号查找权限
     * @param productId
     * @param componentId
     * @param departId
     * @param partsId
     * @param processId
     * @return
     */
    @Override
    public PermissionStream getByProcessIdAndDepartId(String productId, String componentId, String partsId,String processId, String departId){
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(departId)
                || !ValidateUtil.validateString(componentId) || !ValidateUtil.validateString(processId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).eq(PermissionStream::getDepartId, departId)
                .eq(PermissionStream::getComponentId, componentId).eq(StrUtil.isNotEmpty(partsId),PermissionStream::getPartsId, partsId).eq(PermissionStream::getProcessId,processId)
                .isNull(PermissionStream::getUserId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    /**
     * 根据工步编号，用户编号查找权限
     * @param productId
     * @param componentId
     * @param departId
     * @param partsId
     * @param processId
     * @param stepId
     * @return
     */
    @Override
    public PermissionStream getByStepIdAndDepartId(String productId, String componentId, String partsId,String processId,String stepId, String departId){
        if(!ValidateUtil.validateString(productId) || !ValidateUtil.validateString(departId)
                || !ValidateUtil.validateString(componentId) || !ValidateUtil.validateString(processId)
                || !ValidateUtil.validateString(stepId))
            return null;
        List<PermissionStream> list = super.lambdaQuery().eq(PermissionStream::getProductId, productId).eq(PermissionStream::getDepartId, departId)
                .eq(PermissionStream::getComponentId, componentId).eq(StrUtil.isNotEmpty(partsId),PermissionStream::getPartsId, partsId).eq(PermissionStream::getProcessId,processId)
                .eq(PermissionStream::getStepId,stepId)
                .isNull(PermissionStream::getUserId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public List<PermissionStream> findByDepartId(String departId) {
        return super.lambdaQuery().eq(PermissionStream::getDepartId, departId).list();
    }

    @Override
    public List<PermissionStream> findByUserId(String userId) {
        return super.lambdaQuery().eq(PermissionStream::getUserId, userId).list();
    }

    @Override
    public List<PermissionStream> getByComponentIdsAndUserIds(List<String> componentIds, List<String> userIds) {
        if(componentIds == null || componentIds.isEmpty() || userIds == null || userIds.isEmpty())
            return null;
        List<PermissionStream> total = new ArrayList<>();
        List<List<String>> compListArr;
        List<List<String>> userListArr;
        if(componentIds.size() > 1000){
            compListArr = ListUtils.partition(componentIds, 100);
        }else {
            compListArr = ListUtils.partition(componentIds, 1000);
        }
        if(userIds.size() > 1000){
            userListArr = ListUtils.partition(userIds, 100);
        }else {
            userListArr = ListUtils.partition(userIds, 1000);
        }
        for(List<String> compList : compListArr) {
            for(List<String> userList : userListArr){
                LambdaQueryWrapper<PermissionStream> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(PermissionStream::getComponentId, compList);
                queryWrapper.in(PermissionStream::getUserId, userList);
                queryWrapper.isNull(PermissionStream::getPartsId);
                queryWrapper.isNull(PermissionStream::getDepartId);
                List<PermissionStream> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }

    @Override
    public List<PermissionStream> getByComponentIdsAndDepartIds(List<String> componentIds, List<String> departIds) {
        if(componentIds == null || componentIds.isEmpty() || departIds == null || departIds.isEmpty())
            return null;
        List<PermissionStream> total = new ArrayList<>();
        List<List<String>> compListArr;
        List<List<String>> departListArr;
        if(componentIds.size() > 1000){
            compListArr = ListUtils.partition(componentIds, 100);
        }else {
            compListArr = ListUtils.partition(componentIds, 1000);
        }
        if(departIds.size() > 1000){
            departListArr = ListUtils.partition(departIds, 100);
        }else {
            departListArr = ListUtils.partition(departIds, 1000);
        }
        for(List<String> compList : compListArr) {
            for(List<String> departList : departListArr){
                LambdaQueryWrapper<PermissionStream> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(PermissionStream::getComponentId, compList);
                queryWrapper.in(PermissionStream::getDepartId, departList);
                queryWrapper.isNull(PermissionStream::getUserId);
                queryWrapper.isNull(PermissionStream::getPartsId);
                List<PermissionStream> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }

    @Override
    public List<PermissionStream> getByPartsIdsAndUserIds(List<String> partsIds, List<String> userIds) {
        if(partsIds == null || partsIds.isEmpty() || userIds == null || userIds.isEmpty())
            return null;
        List<PermissionStream> total = new ArrayList<>();
        List<List<String>> compListArr;
        List<List<String>> userListArr;
        if(partsIds.size() > 1000){
            compListArr = ListUtils.partition(partsIds, 100);
        }else {
            compListArr = ListUtils.partition(partsIds, 1000);
        }
        if(userIds.size() > 1000){
            userListArr = ListUtils.partition(userIds, 100);
        }else {
            userListArr = ListUtils.partition(userIds, 1000);
        }
        for(List<String> compList : compListArr) {
            for(List<String> userList : userListArr){
                LambdaQueryWrapper<PermissionStream> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(PermissionStream::getPartsId, compList);//零件
                queryWrapper.in(PermissionStream::getUserId, userList);
                queryWrapper.isNull(PermissionStream::getDepartId);
                List<PermissionStream> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }

    @Override
    public List<PermissionStream> getByPartsIdsAndDepartIds(List<String> partsIds, List<String> departIds) {
        if(partsIds == null || partsIds.isEmpty() || departIds == null || departIds.isEmpty())
            return null;
        List<PermissionStream> total = new ArrayList<>();
        List<List<String>> compListArr;
        List<List<String>> departListArr;
        if(partsIds.size() > 1000){
            compListArr = ListUtils.partition(partsIds, 100);
        }else {
            compListArr = ListUtils.partition(partsIds, 1000);
        }
        if(departIds.size() > 1000){
            departListArr = ListUtils.partition(departIds, 100);
        }else {
            departListArr = ListUtils.partition(departIds, 1000);
        }
        for(List<String> compList : compListArr) {
            for(List<String> departList : departListArr){
                LambdaQueryWrapper<PermissionStream> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.in(PermissionStream::getPartsId, compList);
                queryWrapper.in(PermissionStream::getDepartId, departList);
                queryWrapper.isNull(PermissionStream::getUserId);
                List<PermissionStream> list = super.list(queryWrapper);
                if(list != null && !list.isEmpty()){
                    total.addAll(list);
                }
            }
        }
        return total;
    }
}