package org.jeecg.modules.doc.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.doc.vo.DeptPathPermissionVo;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.doc.api.JeecgSystemClient;
import org.jeecg.modules.doc.component.PathPermissionComp;
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.service.IDeptPathPermissionService;

import org.jeecg.modules.doc.vo.QiwenFile;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
* @Description: path_permission
* @Author: jeecg-boot
* @Date:   2022-08-04
* @Version: V1.0
*/
@Api(tags="dept_path_permission")
@RestController
@RequestMapping("/deptPathPermission")
@Slf4j
public class DeptPathPermissionController extends JeecgController<DeptPathPermission, IDeptPathPermissionService> {
   @Autowired
   private IDeptPathPermissionService deptPathPermissionService;

   @Autowired
   private JeecgSystemClient jeecgSystemClient;

   @Autowired
   private PathPermissionComp pathPermissionComp;

   /**
    * 分页列表查询
    *
    * @param deptPathPermission
    * @param pageNo
    * @param pageSize
    * @param req
    * @return
    */
   @AutoLog(value = "dept_path_permission-分页列表查询")
   @ApiOperation(value="dept_path_permission-分页列表查询", notes="dept_path_permission-分页列表查询")
   @GetMapping(value = "/list")
   public Result<?> queryPageList(DeptPathPermission deptPathPermission,
                                  @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                  @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                  HttpServletRequest req) {
       QueryWrapper<DeptPathPermission> queryWrapper = QueryGenerator.initQueryWrapper(deptPathPermission, req.getParameterMap());
       Page<DeptPathPermission> page = new Page<DeptPathPermission>(pageNo, pageSize);
       IPage<DeptPathPermission> pageList = deptPathPermissionService.page(page, queryWrapper);
       return Result.OK(pageList);
   }

   /**
    *   添加
    *
    * @param deptPathPermission
    * @return
    */
   @AutoLog(value = "dept_path_permission-添加")
   @ApiOperation(value="dept_path_permission-添加", notes="dept_path_permission-添加")
   @PostMapping(value = "/add")
   public Result<?> add(@RequestBody DeptPathPermission deptPathPermission) {
       deptPathPermissionService.save(deptPathPermission);
       return Result.OK("添加成功！");
   }

   /**
    *  编辑
    *
    * @param deptPathPermission
    * @return
    */
   @AutoLog(value = "dept_path_permission-编辑")
   @ApiOperation(value="dept_path_permission-编辑", notes="dept_path_permission-编辑")
   @PutMapping(value = "/edit")
   public Result<?> edit(@RequestBody DeptPathPermission deptPathPermission) {
       deptPathPermissionService.updateById(deptPathPermission);
       return Result.OK("编辑成功!");
   }

   /**
    *   通过id删除
    *
    * @param id
    * @return
    */
   @AutoLog(value = "dept_path_permission-通过id删除")
   @ApiOperation(value="dept_path_permission-通过id删除", notes="dept_path_permission-通过id删除")
   @DeleteMapping(value = "/delete")
   public Result<?> delete(@RequestParam(name="id",required=true) String id) {
       deptPathPermissionService.removeById(id);
       return Result.OK("删除成功!");
   }

   /**
    *  批量删除
    *
    * @param ids
    * @return
    */
   @AutoLog(value = "dept_path_permission-批量删除")
   @ApiOperation(value="dept_path_permission-批量删除", notes="dept_path_permission-批量删除")
   @DeleteMapping(value = "/deleteBatch")
   public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
       this.deptPathPermissionService.removeByIds(Arrays.asList(ids.split(",")));
       return Result.OK("批量删除成功!");
   }

   /**
    * 通过id查询
    *
    * @param id
    * @return
    */
   @AutoLog(value = "dept_path_permission-通过id查询")
   @ApiOperation(value="dept_path_permission-通过id查询", notes="dept_path_permission-通过id查询")
   @GetMapping(value = "/queryById")
   public Result<?> queryById(@RequestParam(name="id",required=true) String id) {
       DeptPathPermission deptPathPermission = deptPathPermissionService.getById(id);
       if(deptPathPermission==null) {
           return Result.error("未找到对应数据");
       }
       return Result.OK(deptPathPermission);
   }

   /**
   * 导出excel
   *
   * @param request
   * @param deptPathPermission
   */
   @RequestMapping(value = "/exportXls")
   public ModelAndView exportXls(HttpServletRequest request, DeptPathPermission deptPathPermission) {
       return super.exportXls(request, deptPathPermission, DeptPathPermission.class, "dept_path_permission");
   }

   /**
     * 通过excel导入数据
   *
   * @param request
   * @param response
   * @return
   */
   @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
   public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
       return super.importExcel(request, response, DeptPathPermission.class);
   }


   @ApiOperation(value = "保存文件权限分配")
   @PostMapping("/save")
   public Result<?> savePathPerm(@RequestBody DeptPathPermissionVo vo) {
       try{
           DeptPathPermission deptPathPermission = new DeptPathPermission(vo);
           deptPathPermissionService.saveOrUpdate(deptPathPermission);
           return Result.OK();
       }catch (Exception e) {
           return Result.error("权限设置失败！");
       }

   }




    /**
     * 查询某一文件的权限分配情况
     * 先查询出所有角色及角色对应的用户列表，将权限分配情况合并到列表，返回给前端展示。
     * @param pathId 文件ID
     * @return
     */
    @ApiOperation(value="查询文件权限分配情况", notes="通过文件pathId查询文件的权限分配情况")
    @GetMapping("/queryAll")
    public Result<List<DeptPathPermissionVo>> queryAllPathPermission(@RequestParam String pathId) {
       // 根据文件id查询文件的权限分配数据
       LambdaQueryWrapper<DeptPathPermission> queryWrapper = new LambdaQueryWrapper<>();
       queryWrapper.eq(DeptPathPermission::getPathId, pathId);
       List<DeptPathPermission> list = deptPathPermissionService.list(queryWrapper);
       // 角色/用户对应的权限转换成MAP,方便查询
       Map<String, DeptPathPermission> permMap = list.stream()
               .collect(Collectors.toMap(path -> path.getDeptId()==null?path.getRoleId():path.getRoleId(), pp -> pp));
       // 调用system的接口查询角色和用户
       List<DeptPathPermissionVo> vos = jeecgSystemClient.queryDeptRoles();
       // 将查到的文件权限绑定到对应角色，给前台展示
       if (vos != null && vos.size() > 0) {
           vos.stream().forEach( r -> {
               r.setPathId(pathId);
               convertVo(r, r.getRoleId(), permMap);
           });
       }
       return Result.OK(vos);
   }

    /**
     * 将权限实体转换成vo对象
     * @param r
     * @param permMap
     */
    private void convertVo(DeptPathPermissionVo r,String key, Map<String, DeptPathPermission> permMap) {
        //System.out.println(r.getDeptName() + "===" + r.getRoleName());
        DeptPathPermission p = permMap.get(key);
        if (p != null) {
            r.setId(p.getId());
            r.setVisit(p.getVisit());
            r.setDownload(p.getDownload());
            r.setManage(p.getManage());
        }else {
            r.setVisit(0);
            r.setDownload(0);
            r.setManage(0);
        }
        r.setKey(r.getType()==1?r.getDeptId():r.getRoleId());
        if (r.getChildren() != null) {
            r.getChildren().stream().forEach( u -> {
                u.setPathId(r.getPathId());
//                u.setChildren(null);
                convertVo(u, u.getRoleId(), permMap);
            });
        }

    }


    @ApiOperation(value="是否有管理权限", notes="通过文件路径查询是否有该文件的管理检权限")
    @GetMapping("/hasManagePrem")
    public boolean hasManagePrem(@RequestParam String filePath) {

        // 访问、下载、管理权限包
        Map<String, Map<String, DocFilePath>> deptPathPermission = pathPermissionComp.getPathPermission();
        // 拥有管理权限的文件集合
        Map<String, DocFilePath> manages =  deptPathPermission.get(Constant.MANAGE);

        Set<String> keys = manages.keySet();
        for (String key: keys) {
            DocFilePath path = manages.get(key);
            if (path != null ) {
                QiwenFile qiwenFile = new QiwenFile(path.getFilePath(), path.getFileName(), path.isDirectory());
                if (filePath.startsWith(qiwenFile.getPath())) {
                    return true;
                }
            }

        }
        return false;
    }

}