package org.jeecg.modules.doc.controller;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.xkcoding.http.util.StringUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.collections.map.HashedMap;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.IPUtils;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.modules.doc.api.JeecgSystemClient;
import org.jeecg.modules.doc.component.DocFileDealComp;
import org.jeecg.modules.doc.component.PathFileUtil;
import org.jeecg.modules.doc.component.PathPermissionComp;
import org.jeecg.modules.doc.component.UfopConfig;
import org.jeecg.modules.doc.constant.Constant;
import org.jeecg.modules.doc.dto.*;
import org.jeecg.modules.doc.entity.*;
import org.jeecg.modules.doc.service.*;
import org.jeecg.modules.doc.vo.CompareFileVo;
import org.jeecg.modules.doc.vo.DocTree;
import org.jeecg.modules.doc.exception.QiwenException;
import org.jeecg.modules.doc.vo.QiwenFile;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.*;
import lombok.extern.slf4j.Slf4j;

import javax.print.Doc;
import javax.servlet.http.HttpServletRequest;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;


@RestController
@RequestMapping("/document")
@Api("文档管理")
@ApiOperation("文件管理")
@Slf4j
public class LbDocController {

	@Autowired
	private UfopConfig ufopConfig;
	@Autowired
	private ILbDocService lbDocService;
	@Autowired
	private DocFileDealComp fileDealComp;
	@Autowired
	private IDocFilePathService filePathService;
	@Autowired
	private IDocFileService docFileService;
	@Autowired
	private PathPermissionComp pathPermissionComp;
	@Autowired
	private IUserStorageFlowService userStorageFlowService;
	@Autowired
	private JeecgSystemClient jeecgSystemClient;

	@Autowired
	private IDocOperationHisService operationHisService;

	@Autowired
	private RedisUtil redisUtil;


	@ApiOperation( "本地目录树")
	@GetMapping(value = "/docTree")
	public List<DocTree> queryPageList(DocTree docTree) {
		System.out.println("开始:: " + System.currentTimeMillis());
		if (docTree.getPath() == null || "".equals(docTree.getPath())){
			docTree.setPath(ufopConfig.getReleasePath());
			docTree.setKey("0-0");
		}
		docTree = lbDocService.genDocTree( docTree );
		System.out.println("结束：：" + System.currentTimeMillis());
		return docTree.getChildren();
	}

	@AutoLog(value = "初始化同步本地目录")
	@ApiOperation("初始化同步本地目录")
	@GetMapping("/init")
	public void initDoc() {
		System.out.println("开始初始化：：：" + System.currentTimeMillis());
		List<DocFilePath> pathList = filePathService.list(
				new LambdaQueryWrapper<DocFilePath>()

//						.likeRight(DocFilePath::getFilePath,"/工作文件区/01 公共区域")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/02 3D视觉事业部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/03 研发二部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/04 研发三部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/05 开发一部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/06 开发二部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/07 开发三部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/08 工业设计部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/09 研发管理部")
//						.likeRight(DocFilePath::getFilePath,"/工作文件区/10 兰浦公司")
						.likeRight(DocFilePath::getFilePath,"/档案资料区")


		);
		Map<String, String> paths = new HashMap<>();
		pathList.stream().forEach(item -> {
//			if (item.getFileName().contains("20171201技术体系文件标准化管理制度V1")) {
//				System.out.println("["+item.getFilePath()+item.getFileName()+(item.getExtendName().isEmpty()?"":item.getExtendName())+item.getIsDir()+"]");
//			}
			paths.put(item.getFilePath()+item.getFileName()+(item.getExtendName().isEmpty()?"":item.getExtendName())+item.getIsDir(), item.getPathId());
		});
		System.out.println("当前已有：" + paths.size());
		String releasePath = ufopConfig.getReleasePath();
		//filePathService.initDocFilePath();
		lbDocService.initDoc(paths, releasePath, null);
		System.out.println("初始化完成：：：" + System.currentTimeMillis());
	}



	@AutoLog(value = "初始化同步本地目录结构")
	@ApiOperation("初始化同步本地目录结构")
	@GetMapping("/initDir")
	public void initDir() {
		System.out.println("开始初始化：：：" + System.currentTimeMillis());
		List<DocFilePath> pathList = filePathService.list(new LambdaQueryWrapper<DocFilePath>().eq(DocFilePath::getIsDir, 1));
//		String releasePath = ufopConfig.getReleasePath();
//
//		Map<String, String> paths = new HashMap<>();
//		pathList.stream().forEach(item -> {
//			paths.put(item.getFilePath()+item.getFileName()+(item.getExtendName().isEmpty()?"":item.getExtendName())+item.getIsDir(), item.getPathId());
//		});
//
//				System.out.println("当前已有：" + paths.size());
//		List<DocFilePath> filePaths = new ArrayList<>();
//
//		lbDocService.initDir(paths,filePaths,releasePath, null);
//		System.out.println("文件夹有：" + filePaths.size());
//		filePathService.saveOrUpdateBatch(filePaths);
//		System.out.println("初始化完成：：：" + System.currentTimeMillis());
//




//		filePaths = null;
//		pathList = filePathService.list();

		Map<String, String> dirMap = new HashMap<>();

		pathList.stream().forEach(item -> {
			if (item.isDirectory()) {
				if (item.getFilePath().endsWith("/")) {
					dirMap.put(item.getFilePath()+item.getFileName(), item.getPathId());
				} else {
					dirMap.put(item.getFilePath()+"/"+item.getFileName(), item.getPathId());
				}

			}

		});
		System.out.println("文件夹map准备完成：：" + System.currentTimeMillis());
		List<DocFilePath> newList = new ArrayList<>();
		pathList.stream().forEach(item -> {
			if ( item.getParentId() == null || !item.getParentId().equals(dirMap.get(item.getFilePath()))) {
				item.setParentId(dirMap.get(item.getFilePath()));
				newList.add(item);
			}

		});
		System.out.println("文件夹排序完成：："  + System.currentTimeMillis());
		System.out.println("发现有问题目录：" + newList.size() +"个");
		filePathService.saveOrUpdateBatch(newList);
		System.out.println("更新完成：：" + System.currentTimeMillis());

	}
//	@AutoLog(value = "检测文件是否损坏")
//	@ApiOperation("检测文件是否损坏")
//	@GetMapping("/checkFile")
//	public void checkFile() {
//		String filePath ="//192.168.0.9/研发技术文档";
//
//		lbDocService.checkFile(filePath);
//	}
//
//
//
//	@AutoLog(value = "检测文件是否损坏")
//	@ApiOperation("检测文件是否损坏")
//	@GetMapping("/checkFileIsExist")
//	public void checkFileIsExist() {
//		List<DocFile> list = docFileService.list();
//		String dir = "//192.168.0.9/研发技术文档";
//		List<DocFile> upids = new ArrayList<>();
//		list.forEach(file -> {
//			String fileurl = file.getFileUrl().replace("upload", dir);
//			File ff = new File(fileurl);
//
//			if(!ff.exists()) {
//				file.setFileStatus(0);
//				upids.add(file);
//
//				System.out.println(file.getFileId());
//			}
//		});
//		System.out.println("待更新个数："+upids.size());
//		docFileService.updateBatchById(upids);
//		System.out.println("完成++++");
//
//	}


	@AutoLog(value = "获取同步目标文件个数")
	@ApiOperation("获取同步目标文件个数")
	@GetMapping("/initDocSize")
	public void initDocSize() {

		Map<String, Long> map = new HashedMap();
		map.put("dsize", 0L);
		map.put("fsize", 0L);
		String releasePath = ufopConfig.getReleasePath();
		lbDocService.initDocSize(map,releasePath,null);
		System.out.println("文件总数：" + map.get("fsize"));
		System.out.println("文件夹总数：" + map.get("dsize"));
		System.out.println("总个数：" +(map.get("fsize")+map.get("dsize")));
	}


	/**
	 * 获取完整目录树
	 * @return
	 */
	@ApiOperation(value = "获取目录结构树", notes = "左侧目录树")
	@GetMapping("/getFileTree")
	public Map<String,Object> getFileTree() {
		System.out.println("获取目录树：：" + LocalDateTime.now().toString());

		// 获取访问集合
		Set<String> visits = pathPermissionComp.getVisible();
		Map<String, Object> map = new HashMap<>();
		// 查询有访问权限的文件列表
		List<DocFilePath> pathList = filePathService.listDirTree(null, visits);
		// 查询有访问权限的文件下的子文件
		LambdaQueryWrapper<DocFilePath> subQueryWrapper = new LambdaQueryWrapper<>();
		subQueryWrapper.eq(DocFilePath::getIsDir, Constant.IS_DIR)
				.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);
		System.out.println("查询完成：：" + LocalDateTime.now());
		pathList.addAll(subList);
		DocTree resultTreeNode = getResultTreeNode(pathList);
		map.put("success", true);
		map.put("result", resultTreeNode);

		System.out.println("获取完成：：：" + LocalDateTime.now());
		return map;
	}


	/**
	 * 异步获取目录树
	 * @param parent 父级目录
	 * @return
	 */
	@ApiOperation(value = "异步获取目录结构树", notes = "异步获取左侧目录树")
	@GetMapping("/getAsyncTree")
	public Map<String, Object> getAsyncTree(DocTreeDTO parent ){
		Map<String, Object> map = new HashMap<>();
		// 访问、下载、管理权限包
		Map<String, Map<String, DocFilePath>> pathPermission = pathPermissionComp.getPathPermission();
		// 拥有访问权限的文件id集合
		Map<String, DocFilePath> visits =  pathPermission.get(Constant.VISIT);
		//DocTree parent = new DocTree();
		DocTree tree = getDocTree(parent, visits, map);
		map.put("success", true);
		map.put("result", tree);
		return map;
	}

	/**
	 * 根据传过来的上级方件组织异步树的下级文件列表
	 * @param parent 上级文件
	 * @param visits 可访问文件列表
	 * @param map 返回前端对象
	 * @return
	 */
	@NotNull
	private DocTree getDocTree(DocTreeDTO parent, Map<String, DocFilePath> visits, Map<String, Object> map) {
		LambdaQueryWrapper<DocFilePath> queryWrapper = new LambdaQueryWrapper<>();


		if (parent.getPathId() == null) {
			queryWrapper.isNull(DocFilePath::getParentId);
			parent.setTitle("全部文件");
			parent.setPath(QiwenFile.separator);
			parent.setId(0L);
			parent.setKey("0");
			parent.setPathId("1");
			parent.setTargetId("1");
		} else if ("1".equals(parent.getPathId())) {
			queryWrapper.isNull(DocFilePath::getParentId);

		} else {
			queryWrapper.eq(DocFilePath::getParentId, parent.getPathId());
		}
		queryWrapper.eq(DocFilePath::getDeleteFlag, Constant.DEL_FALSE)
				.eq(DocFilePath::getIsDir, Constant.IS_DIR);  // 注释掉后同时查询文件夹和文件
		queryWrapper.orderByAsc(DocFilePath::getFileName);
		List<DocTree> trees = new ArrayList<>();
		List<DocFilePath> list = filePathService.list(queryWrapper);
		// 当前查询结果中可访问的文件集合
		list = list.stream().filter(
				i -> visits.get(i.getPathId())!=null || fileDealComp.isParentsOrChild(visits,i, true)
		).collect(Collectors.toList());
		String[] fileIds = new String[list.size()];
		for (int i=0; i< list.size(); i++) {
			fileIds[i] = list.get(i).getPathId();
			trees.add(new DocTree(list.get(i), parent.getKey()+ "-" + i));
		}
		setIsLeaf(trees, fileIds);
		DocTree tree = new DocTree(parent);
		tree.getChildren().addAll(trees);
		// 点击收藏列表递归查询，直到找到目标文件
		if (!tree.getPathId().equals(parent.getTargetId()) ) {

			for (DocTree i: tree.getChildren() ) {
				if (i.getPathId().equals(parent.getTargetId())||parent.getPath().startsWith(i.getPath()+QiwenFile.separator)) {
					DocTreeDTO docTreeDTO = new DocTreeDTO(i);
					docTreeDTO.setTargetId(parent.getTargetId());
					docTreeDTO.setPath(parent.getPath());
					DocTree docTree = this.getDocTree(docTreeDTO, visits, map);
					i.setChildren(docTree.getChildren());
				}
			}
		}  else {
			map.put("target", tree);
		}

		return tree;
	}

	/**
	 * 判断是否子节点
	 * @param trees
	 * @param fileIds
	 */
	private void setIsLeaf(List<DocTree> trees, String[] fileIds) {
		List<Map<String,Object>> subCount = fileIds.length>0? filePathService.querySubCount(fileIds): new ArrayList<>();

		Map<String,Integer> subMap = subCount.stream().collect(Collectors.toMap(i->i.get("parentId").toString(), i-> new Integer( i.get("num").toString())));
		trees.stream().forEach(t -> {
			if (subMap.get(t.getPathId())!=null &&subMap.get(t.getPathId())>0) {
				t.setLeaf(false);
			} else {
				t.setLeaf(true);
			}
		});
	}

	@NotNull
	private DocTree getResultTreeNode(List<DocFilePath> pathList) {
		DocTree resultTreeNode = new DocTree();
		resultTreeNode.setTitle("全部文件");
		resultTreeNode.setPath(QiwenFile.separator);
		resultTreeNode.setId(0L);
		resultTreeNode.setKey("0");
		resultTreeNode.setPathId("1");
		long id = 1;
		for (int i = 0; i < pathList.size(); i++){
			DocFilePath userFile = pathList.get(i);
			QiwenFile qiwenFile = new QiwenFile(userFile.getFilePath(), userFile.getFileName(), false);
			String filePath = qiwenFile.getPath();
			Queue<String> queue = new LinkedList<>();
			String[] strArr = filePath.split(QiwenFile.separator);
			for (int j = 0; j < strArr.length; j++){
				if (!"".equals(strArr[j]) && strArr[j] != null){
					queue.add(strArr[j]);
				}
			}
			if (queue.size() == 0){
				continue;
			}
			resultTreeNode = fileDealComp.insertTreeNode(resultTreeNode, id++, QiwenFile.separator, queue, userFile.getPathId());
		}
		System.out.println("组织树完成：：" + LocalDateTime.now());
		fileDealComp.sortByKey(resultTreeNode);
		fileDealComp.checkLeaf(resultTreeNode);
		return resultTreeNode;
	}


	@ApiOperation(value = "获取目录结构树列表", notes = "用于分配文件夹权限")
	@GetMapping("/queryTreeList")
	public Result<Map<String,Object>> queryTreeList(DocFilePath docFilePath) {
		Result<Map<String,Object>> result = new Result<>();
		List<DocFilePath> pathList = filePathService.listDirTree(docFilePath,null);
		List<String> ids = pathList.stream().map(DocFilePath::getPathId).collect(Collectors.toList());
		Map<String, Object> map = new HashMap<>();
		DocTree resultTreeNode = getResultTreeNode(pathList);
		map.put("treeList", resultTreeNode.getChildren());
		map.put("ids",ids);
		result.setSuccess(true);
		result.setResult(map);
		return result;
	}



	@ApiOperation(value = "获取异步目录结构树列表", notes = "用于分配文件夹权限")
	@GetMapping("/queryAsyncTreeList")
	public Result<Map<String,Object>> queryAsyncTreeList(DocTreeDTO parent) {
		Result<Map<String,Object>> result = new Result<>();
		LambdaQueryWrapper<DocFilePath> queryWrapper = new LambdaQueryWrapper<>();

		if (parent.getFileName()!=null && parent.getFileName().trim().length()>0) {
			queryWrapper.like(DocFilePath::getFileName, parent.getTitle());
		} else {
			if (parent.getPathId() == null) {
				queryWrapper.isNull(DocFilePath::getParentId);
				parent.setTitle("全部文件");
				parent.setPath(QiwenFile.separator);
				parent.setId(0L);
				parent.setKey("0");
				parent.setPathId("1");
			} else {
				queryWrapper.eq(DocFilePath::getParentId, parent.getPathId());
			}
		}
		queryWrapper.eq(DocFilePath::getDeleteFlag, Constant.DEL_FALSE)
				.eq(DocFilePath::getIsDir, Constant.IS_DIR);
		queryWrapper.orderByDesc(DocFilePath::getIsDir).orderByAsc(DocFilePath::getFileName);


		List<DocTree> trees = new ArrayList<>();
		List<DocFilePath> list = filePathService.list(queryWrapper);
		String[] fileIds = new String[list.size()];
		for (int i=0; i< list.size(); i++) {
			fileIds[i] = list.get(i).getPathId();
			trees.add(new DocTree(list.get(i), parent.getKey()+ "-" + i));
		}


		setIsLeaf(trees,fileIds);
		List<String> ids = list.stream().map(DocFilePath::getPathId).collect(Collectors.toList());
		Map<String, Object> map = new HashMap<>();
		//DocTree resultTreeNode = getResultTreeNode(pathList);
		map.put("treeList", trees);
		map.put("ids",ids);
		result.setSuccess(true);
		result.setResult(map);
		return result;
	}


	/**
	 * 点击目录树节点，查询前端主界面文件列表内容
	 * @param path
	 * @return
	 */
	@ApiOperation("根据路径查询文件列表")
	@GetMapping("/listFile")
	public Map<String, Object> queryFileList(String path, String pathId) {

		QueryWrapper<DocFilePath> queryWrapper = new QueryWrapper<>();
		queryWrapper.lambda().eq(DocFilePath::getFilePath,path)
				.eq(DocFilePath::getDeleteFlag,Constant.DEL_FALSE)
				.orderByDesc(DocFilePath::getIsDir);

//				.orderBy(DocFilePath::getFileName + 0)
				queryWrapper.orderByAsc("((file_name + 0) > 0) desc, (file_name + 0) asc,file_name");
				//.orderByAsc(DocFilePath::getFileName);


//		boolean create = filePathService.selectPermissionByPath(pathId);
		Map<String, Object> listFileResult = getListFileResult(queryWrapper, pathId);
//		listFileResult.put("create", create);
		return listFileResult;
	}

	/**
	 * 根据传递过来的sql条件，查询文件夹下的子目录 或 文件搜索
	 * TODO 待返回当前点击节点的权限，用于判断新建文件夹和上传文件及上传文件夹权限
	 * TODO 需要查询子文件没有权限但下级子文件有权限的文件夹显示问题。全局文件搜索不需要此操作。
	 * @param queryWrapper
	 * @return
	 */
	@NotNull
	private Map<String, Object> getListFileResult(QueryWrapper<DocFilePath> queryWrapper, String pathId) {
		Map<String, Object> result = new HashMap<>();
		List<DocFilePath> filePaths = filePathService.list(queryWrapper);

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



		// 当前查询结果中可访问的文件集合
		filePaths = filePaths.stream().filter(
				i -> visits.get(i.getPathId())!=null || fileDealComp.isParentsOrChild(visits,i, true)
				).collect(Collectors.toList());

		Set<String> downloadSet = filePaths.stream().filter(
				i -> downloads.get(i.getPathId()) != null || fileDealComp.isParentsOrChild(downloads,i, false)
		).map(DocFilePath::getPathId).collect(Collectors.toSet());
		Set<String> manageSet = filePaths.stream().filter(
				i -> manages.get(i.getPathId()) != null || fileDealComp.isParentsOrChild(manages,i, false)
		).map(DocFilePath::getPathId).collect(Collectors.toSet());

		// 是文件需要查询文件大小
		Set<String> fileIds = filePaths.stream()
				.filter(docFilePath -> docFilePath.getFileId()!=null&&!"".equals(docFilePath.getFileId()))
				.map(docFilePath -> docFilePath.getFileId())
				.collect(Collectors.toSet());
		if (fileIds.size()>0) {
			// 查询文件大小
			List<DocFile> files = docFileService.list(new LambdaQueryWrapper<DocFile>().in(DocFile::getFileId,fileIds));
			Map<String, Long> sizeMap = files.stream().collect(Collectors.toMap(DocFile::getFileId,DocFile::getFileSize));
			filePaths.stream().forEach(p -> p.setFileSize(sizeMap.get(p.getFileId())));
		}

		result.put("create", filePathService.selectPermissionByPath(pathId, manages));
		result.put("upload", filePathService.selectPermissionByPath(pathId, downloads));
		result.put("success", true);
		result.put("result", filePaths);
		result.put("downloadPrem", downloadSet);
		result.put("managePrem", manageSet);
		return result;
	}



	@ApiOperation("根据名称模糊搜索文件列表")
	@GetMapping("/searchFile")
	public Map<String, Object> searchFileList(String name) {

		QueryWrapper<DocFilePath> queryWrapper = new QueryWrapper<>();
		queryWrapper.lambda().like(DocFilePath::getFileName,name)
				.eq(DocFilePath::getDeleteFlag,Constant.DEL_FALSE)
				.orderByDesc(DocFilePath::getIsDir);
				//.orderByAsc(DocFilePath::getFileName);
		queryWrapper.orderByAsc("((file_name + 0) > 0) desc, (file_name + 0) asc,file_name");
		return getListFileResult(queryWrapper, null);
	}

	@ApiOperation("创建文件")
	@PostMapping("createFile")
	public Result<Object> createFile(@RequestBody DocFilePath docFilePath, HttpServletRequest request) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		boolean isDirExist = fileDealComp.isDirExist(docFilePath.getFileName(), docFilePath.getFilePath(), docFilePath.getIsDir());

		if (isDirExist) {
			return Result.error("同名文件已存在");
		}
		DocFilePath parent = fileDealComp.getParent(docFilePath.getFilePath());
		DocFilePath filePath = PathFileUtil.getDir(docFilePath.getFilePath(), docFilePath.getFileName(), parent);
		filePathService.save(filePath);

		operationHisService.saveHis(loginUser,docFilePath,Constant.OPERATION_CREATE);
		return Result.OK();
	}

	@ApiOperation("创建文件")
	@PostMapping("test")
	public Result<Object> test(@RequestBody DocFilePath docFilePath, HttpServletRequest request) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

//		boolean isDirExist = fileDealComp.isDirExist(docFilePath.getFileName(), docFilePath.getFilePath(), docFilePath.getIsDir());
//
//		if (isDirExist) {
//			return Result.error("同名文件已存在");
//		}
//		DocFilePath parent = fileDealComp.getParent(docFilePath.getFilePath());
//		DocFilePath filePath = PathFileUtil.getDir(docFilePath.getFilePath(), docFilePath.getFileName(), parent);
//		filePathService.save(filePath);
//
//		operationHisService.saveHis(loginUser,docFilePath,Constant.OPERATION_CREATE);
		return Result.OK();
	}




	@ApiOperation(value = "修改文件", notes = "支持普通文本类文件的修改", tags = {"file"})
	@RequestMapping(value = "/update", method = RequestMethod.POST)
	public Result<String> updateFile(@RequestBody UpdateFileDTO updateFileDTO) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		//JwtUser sessionUserBean =  SessionUtil.getSession();
		// 获取路径文件
		DocFilePath userFile = filePathService.getById(updateFileDTO.getUserFileId());
		// 获取目标文件
		DocFile fileBean = docFileService.getById(userFile.getFileId());
		// 目标文件被引用数
		Long pointCount = docFileService.getFilePointCount(userFile.getFileId());
		String fileUrl = fileBean.getFileUrl();
		if (pointCount > 1) {
			fileUrl = fileDealComp.copyFile(fileBean, userFile);
		}
		String content = updateFileDTO.getFileContent();
		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(content.getBytes());
		try {
			long fileSize = byteArrayInputStream.available();
			fileDealComp.saveFileInputStream( fileUrl, byteArrayInputStream);
			String md5Str = fileDealComp.getIdentifierByFile(fileUrl, 0);
			docFileService.updateFileDetail(userFile.getPathId(), md5Str, fileSize, loginUser.getId());
		} catch (Exception e) {
			throw new QiwenException(999999, "修改文件异常");
		} finally {
			try {
				byteArrayInputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		operationHisService.saveHis(loginUser, userFile, Constant.OPERATION_UPDATE);
		return Result.OK("修改文件成功");
	}


	@ApiOperation(value = "批量删除文件", notes = "批量删除文件", tags = {"file"})
	@RequestMapping(value = "/batchdeletefile", method = RequestMethod.POST)
	public Result<String> deleteImageByIds(@RequestBody BatchDeleteFileDTO batchDeleteFileDto) {
		System.out.println("批量删除文件：：：" + LocalDateTime.now().toString());
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		List<DocFilePath> userFiles = JSON.parseArray(batchDeleteFileDto.getFiles(), DocFilePath.class);
		DigestUtils.md5Hex("data");
		for (DocFilePath userFile : userFiles) {

			filePathService.deleteUserFile(userFile.getPathId(),loginUser.getId());
			operationHisService.saveHis(loginUser,userFile,Constant.OPERATION_DELETE);
			//fileDealComp.deleteESByUserFileId(userFile.getPathId());
		}
		// 删除reids中缓存的 CacheConstant.DOC_FILE_PATH_CACHE 下的所有key
		redisUtil.removeAll(CacheConstant.DOC_FILE_PATH_CACHE);

		return Result.OK("批量删除文件成功");
	}

	@ApiOperation(value = "删除文件", notes = "可以删除文件或者目录", tags = {"file"})
	@RequestMapping(value = "/deletefile", method = RequestMethod.POST)
	public Result deleteFile(@RequestBody DeleteFileDTO deleteFileDto) {
		System.out.println("删除文件：：：" + LocalDateTime.now().toString());
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		DocFilePath byId = filePathService.getById(deleteFileDto.getUserFileId());
		filePathService.deleteUserFile(deleteFileDto.getUserFileId(), loginUser.getId());
		//fileDealComp.deleteESByUserFileId(deleteFileDto.getUserFileId());
		System.out.println("删除完成：：：" + LocalDateTime.now().toString());
		operationHisService.saveHis(loginUser,byId,Constant.OPERATION_DELETE);
		// 删除reids中缓存的 CacheConstant.DOC_FILE_PATH_CACHE 下的所有key
		redisUtil.removeAll(CacheConstant.DOC_FILE_PATH_CACHE);
		return Result.OK();

	}


	@ApiOperation(value = "文件重命名", notes = "文件重命名", tags = {"file"})
	@RequestMapping(value = "/renamefile", method = RequestMethod.POST)
	public Result<String> renameFile(@RequestBody RenameFileDTO renameFileDto) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		//JwtUser sessionUserBean =  SessionUtil.getSession();
		DocFilePath userFile = filePathService.getById(renameFileDto.getUserFileId());

		List<DocFilePath> userFiles = filePathService.selectUserFileByNameAndPath(renameFileDto.getFileName(), userFile.getFilePath(), loginUser.getId());
		if (userFiles != null && !userFiles.isEmpty()) {
			return Result.error("同名文件已存在", null);
		}

		LambdaUpdateWrapper<DocFilePath> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
		lambdaUpdateWrapper.set(DocFilePath::getFileName, renameFileDto.getFileName())
				.set(DocFilePath::getUpdateTime, DateUtils.getDate())
				.eq(DocFilePath::getPathId, renameFileDto.getUserFileId());
		filePathService.update(lambdaUpdateWrapper);
		if (Constant.IS_DIR == userFile.getIsDir()) {
			List<DocFilePath> list = filePathService.selectUserFileByLikeRightFilePath(new QiwenFile(userFile.getFilePath(), userFile.getFileName(), true).getPath());

			for (DocFilePath newUserFile : list) {
				newUserFile.setFilePath(newUserFile.getFilePath().replaceFirst(new QiwenFile(userFile.getFilePath(), userFile.getFileName(), userFile.getIsDir() == Constant.IS_DIR).getPath().replace("(","\\(").replace(")","\\)"),
						new QiwenFile(userFile.getFilePath(), renameFileDto.getFileName(), userFile.getIsDir() == Constant.IS_DIR).getPath()));
				filePathService.updateById(newUserFile);
			}
		}
	//	fileDealComp.uploadESByUserFileId(renameFileDto.getUserFileId());
		operationHisService.saveHis(loginUser, userFile, Constant.OPERATION_RENAME);
		return Result.OK();
	}


	@ApiOperation(value = "解压文件", notes = "解压文件。", tags = {"file"})
	@RequestMapping(value = "/unzipfile", method = RequestMethod.POST)
	public Result<String> unzipFile(@RequestBody UnzipFileDTO unzipFileDto) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		try {
			DocFilePath byId = filePathService.getById(unzipFileDto.getUserFileId());
			docFileService.unzipFile(unzipFileDto.getUserFileId(), unzipFileDto.getUnzipMode(), unzipFileDto.getFilePath());
			operationHisService.saveHis(loginUser, byId, Constant.OPERATION_UNZIP);
		} catch (QiwenException e) {
			return Result.error(e.getMessage(),null);
		}

		return Result.OK();

	}

	@ApiOperation(value = "文件复制", notes = "可以复制文件或者目录", tags = {"file"})
	@RequestMapping(value = "/copyfile", method = RequestMethod.POST)
	public Result<String> copyFile(@RequestBody CopyFileDTO copyFileDTO) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		//JwtUser sessionUserBean =  SessionUtil.getSession();

		String userFileId = copyFileDTO.getUserFileId();
		DocFilePath userFile = filePathService.getById(userFileId);
		String oldfilePath = userFile.getFilePath();
		String newfilePath = copyFileDTO.getFilePath();
		String fileName = userFile.getFileName();
		if (userFile.getIsDir() == Constant.IS_DIR) {
			QiwenFile qiwenFile = new QiwenFile(oldfilePath, fileName, true);
			if (newfilePath.startsWith(qiwenFile.getPath() + QiwenFile.separator) || newfilePath.equals(qiwenFile.getPath())) {
				return Result.error("原路径与目标路径冲突，不能复制",null);
			}
		}

		filePathService.userFileCopy(userFileId, newfilePath);
		fileDealComp.deleteRepeatSubDirFile(newfilePath);
		operationHisService.saveHis(loginUser, userFile, Constant.OPERATION_COPY);
		return Result.OK();

	}

	@ApiOperation(value = "批量复制文件", notes = "可以同时选择复制多个文件或者目录", tags = {"file"})
	@RequestMapping(value = "/batchcopyfile", method = RequestMethod.POST)
	public Result<String> batchCopyFile(@RequestBody BatchMoveFileDTO batchMoveFileDto) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		//JwtUser sessionUserBean =  SessionUtil.getSession();

		String files = batchMoveFileDto.getFiles();
		String newfilePath = batchMoveFileDto.getFilePath();

		List<DocFilePath> fileList = JSON.parseArray(files, DocFilePath.class);

		for (DocFilePath userFile : fileList) {

			if (StringUtil.isEmpty(userFile.getExtendName())) {
				QiwenFile qiwenFile = new QiwenFile(userFile.getFilePath(), userFile.getFileName(), true);
				if (newfilePath.startsWith(qiwenFile.getPath() + QiwenFile.separator) || newfilePath.equals(qiwenFile.getPath())) {
					return Result.error("原路径与目标路径冲突，不能复制",null);
				}
			}
			filePathService.userFileCopy(userFile.getPathId(), newfilePath);
			operationHisService.saveHis(loginUser, userFile, Constant.OPERATION_COPY);
		}

		return Result.OK("批量复制文件成功");

	}



	@ApiOperation(value = "文件移动", notes = "可以移动文件或者目录", tags = {"file"})
	@RequestMapping(value = "/movefile", method = RequestMethod.POST)
	public Result<String> moveFile(@RequestBody MoveFileDTO moveFileDto) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		//JwtUser sessionUserBean =  SessionUtil.getSession();
		DocFilePath userFile = filePathService.getById(moveFileDto.getUserFileId());
		String oldfilePath = userFile.getFilePath();
		String newfilePath = moveFileDto.getFilePath();
		String fileName = userFile.getFileName();
		String extendName = userFile.getExtendName();
		if (StringUtil.isEmpty(extendName)) {
			QiwenFile qiwenFile = new QiwenFile(oldfilePath, fileName, true);
			if (newfilePath.startsWith(qiwenFile.getPath() + QiwenFile.separator) || newfilePath.equals(qiwenFile.getPath())) {
				return Result.error("原路径与目标路径冲突，不能移动",null);
			}
		}

		try {
			filePathService.updateFilepathByUserFileId(moveFileDto.getUserFileId(), newfilePath);

			fileDealComp.deleteRepeatSubDirFile(newfilePath);
		} catch (Exception e) {
			e.printStackTrace();
		}
		operationHisService.saveHis(loginUser, userFile, Constant.OPERATION_MOVE);
		return Result.OK();

	}

	@ApiOperation(value = "批量移动文件", notes = "可以同时选择移动多个文件或者目录", tags = {"file"})
	@RequestMapping(value = "/batchmovefile", method = RequestMethod.POST)
	public Result<String> batchMoveFile(@RequestBody BatchMoveFileDTO batchMoveFileDto) {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
		//JwtUser sessionUserBean =  SessionUtil.getSession();

		String files = batchMoveFileDto.getFiles();
		String newfilePath = batchMoveFileDto.getFilePath();

		List<DocFilePath> fileList = JSON.parseArray(files, DocFilePath.class);

		for (DocFilePath userFile : fileList) {

			if (StringUtil.isEmpty(userFile.getExtendName())) {
				QiwenFile qiwenFile = new QiwenFile(userFile.getFilePath(), userFile.getFileName(), true);
				if (newfilePath.startsWith(qiwenFile.getPath() + QiwenFile.separator) || newfilePath.equals(qiwenFile.getPath())) {
					return Result.error("原路径与目标路径冲突，不能移动",null);
				}
			}
			filePathService.updateFilepathByUserFileId(userFile.getPathId(), newfilePath);
			operationHisService.saveHis(loginUser, userFile, Constant.OPERATION_MOVE);
		}

		return Result.OK("批量移动文件成功");

	}

	@ApiOperation(value = "查询限额", notes = "获取个人下载限额及使用情况", tags = {"file"})
	@GetMapping("/loadFlow")
	public  Result<UserStorageFlow> loadFlow() {
		LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();


		LambdaQueryWrapper<UserStorageFlow> qw = new LambdaQueryWrapper<>();
		qw.eq(UserStorageFlow::getUserId, loginUser.getId());
		UserStorageFlow userStorageFlow = userStorageFlowService.getOne(qw);
		if (userStorageFlow != null && userStorageFlow.getFlow() != null) { // 用户单独设置过限额

		} else { // 未单独设置限额的取所有角色限额最大值
			Result<List<String>> roles = jeecgSystemClient.queryUserRole(loginUser.getId());
			if (roles.getResult() == null || roles.getResult().size()<=0) {return Result.error("未设置限额", null);}
			qw = new LambdaQueryWrapper<>();
			qw.in(UserStorageFlow::getRoleId, roles.getResult());
			qw.isNotNull(UserStorageFlow::getFlow);
			qw.orderByDesc(UserStorageFlow::getFlow).last("limit 1");
			UserStorageFlow one = userStorageFlowService.getOne(qw);
			if (userStorageFlow == null) {
				userStorageFlow = new UserStorageFlow();
				userStorageFlow.setUserId(loginUser.getId());
				userStorageFlow.setSurplusFlow(0L);
				userStorageFlowService.save(userStorageFlow);
			}
			if (one != null) {
				userStorageFlow.setFlow(one.getFlow());
			}

		}
		if (userStorageFlow.getSurplusFlow() == null) {
			userStorageFlow.setSurplusFlow(0L);
		}
		return Result.OK(userStorageFlow);
	}


	@ApiOperation(value = "文件夹内文件总大小", notes = "查询文件夹内文件总大小", tags = {"file"})
	@GetMapping("/getSubFileSize")
	public Result<BigDecimal> querySubFileSize(DocFilePath docFilePath) {
		LambdaQueryWrapper<DocFilePath> queryWrapper = new LambdaQueryWrapper<>();
		QiwenFile qiwenFile = new QiwenFile(docFilePath.getFilePath(),docFilePath.getFileName(),docFilePath.isDirectory());
		queryWrapper.likeRight(DocFilePath::getFilePath,qiwenFile.getPath());
		queryWrapper.isNotNull(DocFilePath::getFileId);
		List<DocFilePath> docFilePaths = filePathService.list(queryWrapper);
		BigDecimal total = queryTotalSize(docFilePaths);
		return Result.OK(total);
	}

	/**
	 * 查询传入文件列表的总大小
	 * @param docFilePaths
	 * @return
	 */
	private BigDecimal queryTotalSize(List<DocFilePath> docFilePaths) {
		// 所有文件id集合
		List<String> fileIds = docFilePaths.stream().map(DocFilePath::getFileId).collect(Collectors.toList());
		// 查询出文件大小之和
		QueryWrapper<DocFile> fileQueryWrapper = new QueryWrapper<>();
		fileQueryWrapper.select("IFNULL(sum(file_size),0) as totalSize");
		fileQueryWrapper.lambda().in(DocFile::getFileId, fileIds);
		Map<String, Object> map = docFileService.getMap(fileQueryWrapper);
		BigDecimal total = (BigDecimal) map.get("totalSize");
		return total;
	}


	@ApiOperation(value = "多选文件总大小", notes = "多选文件大小总和", tags = {"file"})
	@GetMapping("/getBatchFileSize")
	public Result<BigDecimal> queryBatchFileSize(BatchDownloadFileDTO batchDownloadFileDTO) {
		// 查询出所有选择的文件
		LambdaQueryWrapper<DocFilePath> queryWrapper = new LambdaQueryWrapper<>();
		String[] ids = batchDownloadFileDTO.getUserFileIds().split(",");
		queryWrapper.in(DocFilePath::getPathId,ids);
		List<DocFilePath> batchFiles = filePathService.list(queryWrapper);

		// 查询出选择的文件夹内的子文件
		LambdaQueryWrapper<DocFilePath> subQueryWrapper = new LambdaQueryWrapper<>();
		subQueryWrapper.isNotNull(DocFilePath::getFileId);
		subQueryWrapper.and( i -> {
			i.apply("{0} = {1}", 1,2);
			for (DocFilePath d: batchFiles) {
				if (d.isDirectory()) {
					QiwenFile qiwenFile = new QiwenFile(d.getFilePath(),d.getFileName(),d.isDirectory());
					i.or().likeRight(DocFilePath::getFilePath,qiwenFile.getPath());
				}
			}
		});
		List<DocFilePath> docFilePaths = filePathService.list(subQueryWrapper);
		docFilePaths.addAll(batchFiles);
		// 所有文件id集合
		BigDecimal total = queryTotalSize(docFilePaths);
		return Result.OK(total);
	}

//	@ApiOperation(value = "查询文件详情", notes = "查询文件详情", tags = {"file"})
//	@RequestMapping(value = "/detail", method = RequestMethod.GET)
//	@ResponseBody
//	public RestResult<FileDetailVO> queryFileDetail(
//			@Parameter(description = "用户文件Id", required = true) String userFileId){
//		FileDetailVO vo = fileService.getFileDetail(userFileId);
//		return RestResult.success().data(vo);
//	}

	@GetMapping("/heapSize")
	public Result<?> getHeap() {
		double maxHeapSize = Runtime.getRuntime().maxMemory();
		String sizeInReadableForm;
		double kbSize = maxHeapSize / 1024;
		double mbSize = kbSize / 1024;
		double gbSize = mbSize / 1024;
		if (gbSize > 0) {
			sizeInReadableForm = gbSize + " GB";
		} else if (mbSize > 0) {
			sizeInReadableForm = mbSize + " MB";
		} else {
			sizeInReadableForm = kbSize + " KB";
		}
		return Result.OK(maxHeapSize);
	}

	@ApiOperation( value = "文件对比", notes = "文件对比")
	@PostMapping("/compareFile")
	public Result<CompareFileVo> compareFile( UploadFileDTO uploadFileDto) {
		CompareFileVo compareFileVo = lbDocService.compareFile( uploadFileDto);

		return Result.OK(compareFileVo);
	}

}