package doumeemes.service.system.impl;

import com.alibaba.fastjson.JSONArray;
import doumeemes.core.model.LoginUserInfo;
import doumeemes.core.model.PageData;
import doumeemes.core.model.PageWrap;
import doumeemes.core.utils.Constants;
import doumeemes.dao.ext.vo.DepartmentExtListVO;
import doumeemes.dao.system.SystemDataPermissionMapper;
import doumeemes.dao.system.SystemRoleMapper;
import doumeemes.dao.system.model.SystemDataPermission;
import doumeemes.dao.system.model.SystemRole;
import doumeemes.dao.system.model.SystemUser;
import doumeemes.dao.system.vo.SystemDataPermissionListVO;
import doumeemes.service.ext.DepartmentExtService;
import doumeemes.service.system.SystemDataPermissionService;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

/**
 * 数据权限配置Service实现
 * @author Eva.Caesar Liu
 * @date 2022/04/18 18:12
 */
@Service
public class SystemDataPermissionServiceImpl implements SystemDataPermissionService {

    @Autowired
    private DepartmentExtService departmentExtService;
    @Autowired
    private SystemDataPermissionMapper systemDataPermissionMapper;

    @Autowired
    private SystemRoleMapper systemRoleMapper;

    @Override
    public Integer create(SystemDataPermission systemDataPermission) {
        systemDataPermissionMapper.insert(systemDataPermission);
        return systemDataPermission.getId();
    }

    @Override
    public void deleteById(Integer id) {
        SystemDataPermission dataPermission = new SystemDataPermission();
        dataPermission.setId(id);
        dataPermission.setDeleted(Boolean.TRUE);
        this.updateById(dataPermission);
    }

    @Override
    public void delete(SystemDataPermission systemDataPermission) {
        UpdateWrapper<SystemDataPermission> deleteWrapper = new UpdateWrapper<>(systemDataPermission);
      /*  if(systemDataPermission.getCompanyId()!=null){
            deleteWrapper.exists("select system_role.id from system_role where system_role.id=system_data_permission.`ROLE_ID` and system_role`COMPANY_ID`="+systemDataPermission.getCompanyId());
        }*/
        systemDataPermissionMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        systemDataPermissionMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(SystemDataPermission systemDataPermission) {
        systemDataPermissionMapper.updateById(systemDataPermission);
    }

    @Override
    public void updateByIdInBatch(List<SystemDataPermission> systemDataPermissions) {
        if (CollectionUtils.isEmpty(systemDataPermissions)) {
            return;
        }
        for (SystemDataPermission systemDataPermission: systemDataPermissions) {
            this.updateById(systemDataPermission);
        }
    }

    @Override
    public SystemDataPermission findById(Integer id) {
        return systemDataPermissionMapper.selectById(id);
    }

    @Override
    public SystemDataPermission findOne(SystemDataPermission systemDataPermission) {
        Wrapper<SystemDataPermission> wrapper = new QueryWrapper<>(systemDataPermission);
        return systemDataPermissionMapper.selectOne(wrapper);
    }

    @Override
    public List<SystemDataPermission> findList(SystemDataPermission systemDataPermission) {
        Wrapper<SystemDataPermission> wrapper = new QueryWrapper<>(systemDataPermission);
        return systemDataPermissionMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<SystemDataPermissionListVO> findPage(PageWrap<SystemDataPermission> pageWrap) {
        PageHelper.startPage(pageWrap.getPage(), pageWrap.getCapacity());
        return PageData.from(new PageInfo<>(systemDataPermissionMapper.selectManageList(pageWrap.getModel(), pageWrap.getOrderByClause())));
    }

    @Override
    public List<Integer> selectHighRole(SystemDataPermission model, SystemRole role, SystemUser user, DepartmentExtListVO department) {
        List<SystemDataPermissionListVO>list =   systemDataPermissionMapper.selectUserList(model,role,user.getId()) ;
        if(list !=null){
            boolean all = false;
            boolean departAndChild=false;
            boolean depart=false;
            boolean departAndLeaf=false;
            boolean custom=false;
            String c = "";
            for(SystemDataPermissionListVO d : list){
                if(!all && Constants.equalsInteger(d.getType(),Constants.DATAPERMISSION_TYPE.all)){
                    all =true;
                }
                if(!depart && Constants.equalsInteger(d.getType(),Constants.DATAPERMISSION_TYPE.depart)){
                    depart =true;
                }
                if(!departAndChild && Constants.equalsInteger(d.getType(),Constants.DATAPERMISSION_TYPE.departAndChild)){
                    departAndChild =true;
                }
                if(!departAndLeaf && Constants.equalsInteger(d.getType(),Constants.DATAPERMISSION_TYPE.departAndLeaf)){
                    departAndLeaf =true;
                }
                if(  Constants.equalsInteger(d.getType(),Constants.DATAPERMISSION_TYPE.custom)){
                    custom =true;
                    c += StringUtils.defaultString(d.getCustomData(),"");
                }
            }
            if(all){
                return  null;
            }else{
                List<Integer> dList = new ArrayList<>();
               if(custom) {
                //如果有自定义部门
                   String[] idStrs = c.split(",");
                   for(String s :idStrs){
                       try {
                           Integer si = Integer.parseInt(s);
                           if(!isExists(si,dList)){
                               dList.add(si);
                           }
                       }catch (Exception e){
                       }
                   }
               }
               if(departAndLeaf){
                   if(department!= null){
                       dList.addAll(departmentExtService.userDataPermissonList(department,true));
                   }
               }else if(departAndChild){
                   if(department!= null) {
                       dList.addAll(departmentExtService.userDataPermissonList(department, false));
                   }
               }else if(depart){
                   if(department!= null && !isExists(department.getId(), dList)){
                       dList.add(department.getId());
                   }
               }
               return  dList;
            }

        }
        return new ArrayList<>();
    }

    private boolean isExists(Integer s, List<Integer> dList) {
        if(dList!=null){
            for(Integer t : dList){
                if(Constants.equalsInteger(s,t)){
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public List<SystemDataPermissionListVO> selectUserList( SystemDataPermission model,SystemRole role,Integer userId) {
        return  systemDataPermissionMapper.selectUserList(model,role,userId) ;
    }

    @Override
    public List<SystemDataPermission> findDataPermission(String businessCode, List<String> roles) {
        if (CollectionUtils.isEmpty(roles)) {
            return Collections.emptyList();
        }
        // 查询角色
        QueryWrapper<SystemRole> queryRoleWrapper = new QueryWrapper<>();
        queryRoleWrapper.lambda().in(SystemRole::getCode, roles).eq(SystemRole::getDeleted, Boolean.FALSE);
        List<SystemRole> systemRoles = systemRoleMapper.selectList(queryRoleWrapper);
        if (CollectionUtils.isEmpty(systemRoles)) {
            return Collections.emptyList();
        }
        List<Integer> roleIds = new ArrayList<>();
        for (SystemRole role : systemRoles) {
            roleIds.add(role.getId());
        }
        // 查询数据权限
        QueryWrapper<SystemDataPermission> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda()
                .eq(SystemDataPermission::getBusinessCode, businessCode)
                .in(SystemDataPermission::getRoleId, roleIds)
                .eq(SystemDataPermission::getDeleted, Boolean.FALSE)
                .eq(SystemDataPermission::getDisabled, Boolean.FALSE);
        return systemDataPermissionMapper.selectList(queryWrapper);
    }
    @Override
    public SystemDataPermission findByRoleId(SystemDataPermission pageWrap){
        if ( pageWrap.getRoleId() == null) {
            return null;
        }

        // 查询数据权限
        QueryWrapper<SystemDataPermission> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda()
                .eq(SystemDataPermission::getBusinessCode, "DEPARTMENT")
                .eq(SystemDataPermission::getRoleId, pageWrap.getRoleId())
                .eq(SystemDataPermission::getDeleted, Boolean.FALSE)
                .eq(SystemDataPermission::getDisabled, Boolean.FALSE);
        List<SystemDataPermission> result = systemDataPermissionMapper.selectList(queryWrapper);
        if(result!=null && result.size()>0){
            return result.get(0);
        }
        return  null;
    }

    @Override
    public long count(SystemDataPermission systemDataPermission) {
        Wrapper<SystemDataPermission> wrapper = new QueryWrapper<>(systemDataPermission);
        return systemDataPermissionMapper.selectCount(wrapper);
    }
}