package org.jeecg.modules.doc.component;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.doc.api.JeecgSystemClient;
import org.jeecg.modules.doc.constant.Constant;
import org.jeecg.modules.doc.entity.DeptPathPermission;
import org.jeecg.modules.doc.entity.DocFilePath;
import org.jeecg.modules.doc.entity.PathPermission;
import org.jeecg.modules.doc.service.IDeptPathPermissionService;
import org.jeecg.modules.doc.service.IDocFilePathService;
import org.jeecg.modules.doc.service.IPathPermissionService;
import org.jeecg.modules.doc.vo.QiwenFile;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.print.Doc;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

@Component
@Slf4j
public class PathPermissionComp {

    @Autowired
    private IDocFilePathService filePathService;

    @Autowired
    private JeecgSystemClient jeecgSystemClient;

    @Autowired
    private IPathPermissionService pathPermissionService;

    @Autowired
    private IDeptPathPermissionService deptPathPermissionService;

    public Set<String> getVisible() {
        // 获取用户文件权限集合
        List<PathPermission> permissions = getUserPathPermissions();
        // 有访问权限的
        Set<String> visits = permissions.stream().filter(i -> i.getVisit() == Constant.HAVE).map(PathPermission::getPathId).collect(Collectors.toSet());
        return visits;
    }

    /**
     * 获取访问、下载、管理权限集合
     * @return  map{ visitPrem : 可访问文件id集合, downloadPrem : 可下载文件id集合, managePrem : 可管理文件id集合}
     */
    @NotNull
    public Map<String, Map<String, DocFilePath>> getPathPermission() {
        // 获取用户文件权限集合
        List<PathPermission> permissions = getUserPathPermissions();
        List<DocFilePath> docFilePaths = filePathService.listFiles(permissions.stream().map(PathPermission::getPathId).collect(Collectors.toSet()));
        Map<String, DocFilePath> docFilePathMap = docFilePaths.stream().collect(Collectors.toMap(DocFilePath::getPathId,path -> path));
        Map<String, Map<String, DocFilePath>> map = new HashMap<>();
        // 有访问权限的
        //Set<String> visits = new HashSet<>();
        Map<String, DocFilePath> visits = new HashMap<>();
        // 有下载权限的
        Map<String, DocFilePath> downloads = new HashMap<>();
        // 有管理权限的
        Map<String, DocFilePath> manages = new HashMap<>();
        for (PathPermission pathPermission: permissions) {
            if (pathPermission.getVisit() == Constant.HAVE){
                visits.put(pathPermission.getPathId(),docFilePathMap.get(pathPermission.getPathId()));
            }
            if (pathPermission.getDownload() == Constant.HAVE) {
                downloads.put(pathPermission.getPathId(), docFilePathMap.get(pathPermission.getPathId()));
            }
            if (pathPermission.getManage()== Constant.HAVE) {
                manages.put(pathPermission.getPathId(),docFilePathMap.get(pathPermission.getPathId()));
            }
        }

        map.put(Constant.DOWNLOAD, downloads);
        map.put(Constant.MANAGE, manages);
        map.put(Constant.VISIT, visits);

        return map;
    }

    @NotNull
    public Map<String, DocFilePath> getSubPremMap(Map<String, DocFilePath> origin) {
        List<DocFilePath> pathList = filePathService.listFiles(origin.keySet());
        // 查询有访问权限的文件下的子文件
        LambdaQueryWrapper<DocFilePath> subQueryWrapper = new LambdaQueryWrapper<>();
        subQueryWrapper.eq(DocFilePath::getDeleteFlag, Constant.DEL_FALSE).and(i -> {
            i.apply("{0} = {1}",1,2);  // 无具体意义，方便后边拼接

            pathList.stream().forEach(path -> {
                i.or().likeRight(DocFilePath::getFilePath,new QiwenFile(path.getFilePath(),path.getFileName(),true).getPath());
            });
        });

        List<DocFilePath> subList = filePathService.list(subQueryWrapper);
        // 可访问文件及子文件夹权限集合
        Map<String, DocFilePath> sub = subList.stream().collect(Collectors.toMap(path -> path.getPathId(), path -> path));
        sub.putAll(origin);
        return sub;
    }

    /**
     * 查询用户文件权限集合
     * @param
     * @return
     */
    public List<PathPermission> getUserPathPermissions() {
        LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        List<String> roles = jeecgSystemClient.queryUserRole(loginUser.getId()).getResult();
        Set<String> departRoles = jeecgSystemClient.queryUserDepartRole(loginUser.getId());

        // 查询用户及其所拥有角色的权限
        LambdaQueryWrapper<PathPermission> queryWrapper = new LambdaQueryWrapper<PathPermission>()
                .eq(PathPermission::getVisit, Constant.HAVE)
                .and(i -> i.eq(PathPermission::getUserId,loginUser.getId())
                        .or().in(PathPermission::getRoleId,roles));

        List<PathPermission> permissions = pathPermissionService.list(queryWrapper);


        if (departRoles.size() > 0) {
            // 查询部门角色
            LambdaQueryWrapper<DeptPathPermission> deptPathPermissionLambdaQueryWrapper = new LambdaQueryWrapper<DeptPathPermission>()
                    .eq(DeptPathPermission::getVisit, Constant.HAVE)
                    .in(DeptPathPermission::getRoleId, departRoles);


            List<DeptPathPermission> deptPathPermissions = deptPathPermissionService.list(deptPathPermissionLambdaQueryWrapper);

            deptPathPermissions.forEach(item -> {
                PathPermission dp = new PathPermission();
                dp.setRoleId(item.getRoleId());
                dp.setPathId(item.getPathId());
                dp.setVisit(item.getVisit());
                dp.setManage(item.getManage());
                dp.setDownload(item.getDownload());
                permissions.add(dp);
            });
        }



        return permissions;
    }
}