package org.jeecg.modules.doc.component;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.modules.doc.constant.Constant;
import org.jeecg.modules.doc.entity.DocFile;
import org.jeecg.modules.doc.entity.DocFilePath;
import org.jeecg.modules.doc.mapper.DocFileMapper;
import org.jeecg.modules.doc.mapper.DocFilePathMapper;
import org.jeecg.modules.doc.service.IDocFilePathService;
import org.jeecg.modules.doc.vo.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

@Slf4j
@Component
public class DocFileDealComp {



    @Autowired
    private IDocFilePathService docFilePathService;

    @Resource
    DocFilePathMapper filePathMapper;

    @Resource
    DocFileMapper docFileMapper;

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 组织一个树目录节点
     *
     * @param treeNode
     * @param id
     * @param filePath
     * @param nodeNameQueue
     * @return
     */
    public DocTree insertTreeNode(DocTree treeNode, long id, String filePath, Queue<String> nodeNameQueue, String pathId){
        List<DocTree> childrenTreeNodes = treeNode.getChildren();
        String currentNodeName = nodeNameQueue.peek();

        if (currentNodeName == null){
            return treeNode;
        }
        QiwenFile qiwenFile = new QiwenFile(filePath, currentNodeName, true);
        filePath = qiwenFile.getPath();

        if (!isExistPath(childrenTreeNodes, currentNodeName)){  //1、判断有没有该子节点，如果没有则插入
            //插入
            DocTree resultTreeNode = new DocTree();

            resultTreeNode.setPath(filePath);
            resultTreeNode.setTitle(nodeNameQueue.poll());
            resultTreeNode.setId(++id);
            resultTreeNode.setLeaf(true);
            resultTreeNode.setKey(treeNode.getKey()+"-"+childrenTreeNodes.size());
            resultTreeNode.getSlots().setIcon("folder");
            resultTreeNode.getScopedSlots().setTitle("custom");
            childrenTreeNodes.add(resultTreeNode);

        }else{  //2、如果有，则跳过
            nodeNameQueue.poll();
        }

        if (nodeNameQueue.size() != 0) {
            for (int i = 0; i < childrenTreeNodes.size(); i++) {

                DocTree childrenTreeNode = childrenTreeNodes.get(i);
                if (currentNodeName.equals(childrenTreeNode.getTitle())){
                    childrenTreeNode = insertTreeNode(childrenTreeNode, id * 10, filePath, nodeNameQueue, pathId);
                    childrenTreeNodes.remove(i);
                    childrenTreeNodes.add(childrenTreeNode);
                   // treeNode.setChildren(childrenTreeNodes);
                }
            }
        }else{
            for (int i = 0; i < childrenTreeNodes.size(); i++) {

                DocTree childrenTreeNode = childrenTreeNodes.get(i);
                if (currentNodeName.equals(childrenTreeNode.getTitle())){
                    childrenTreeNode.setPathId(pathId);
                    childrenTreeNodes.remove(i);
                    childrenTreeNodes.add(childrenTreeNode);
                }
            }
            //treeNode.setChildren(childrenTreeNodes);
            //treeNode.setLeaf(false);
        }

        return treeNode;

    }

    /**
     * 判断该路径在树节点中是否已经存在
     * @param childrenTreeNodes
     * @param path
     * @return
     */
    public boolean isExistPath(List<DocTree> childrenTreeNodes, String path){
        boolean isExistPath = false;

        try {
            for (int i = 0; i < childrenTreeNodes.size(); i++){
                if (path.equals(childrenTreeNodes.get(i).getTitle())){
                    isExistPath = true;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }


        return isExistPath;
    }

    public boolean isDirExist(String fileName, String filePath, long userId){
        LambdaQueryWrapper<DocFilePath> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(DocFilePath::getFileName, fileName)
                .eq(DocFilePath::getFilePath, QiwenFile.formatPath(filePath))
                .eq(DocFilePath::getDeleteFlag, Constant.DEL_FALSE)
                .eq(DocFilePath::getIsDir, Constant.IS_DIR);
        List<DocFilePath> list = docFilePathService.list(lambdaQueryWrapper);
        if (list != null && !list.isEmpty()) {
            return true;
        }
        return false;
    }

    /**
     * 递归遍历树的节点，对节点子节点按key值进行排序
     * @param node
     */
    public void sortByKey(DocTree node){
        List<DocTree> children = node.getChildren();
        Collections.sort(children, (o1, o2) -> {


            int o1Key = Integer.valueOf(o1.getKey().substring(o1.getKey().lastIndexOf('-')));
            int o2Key = Integer.valueOf(o2.getKey().substring(o2.getKey().lastIndexOf('-')));
            return o2Key-o1Key;
        });
        for (DocTree child: children) {
            this.sortByKey(child);
        }
    }

    public void checkLeaf(DocTree node) {
        List<DocTree> children = node.getChildren();
        for (DocTree dt: children) {
            if(dt.getChildren().size() > 0) {
                dt.setLeaf(false);
            }
            this.checkLeaf(dt);
        }
    }

    /**
     * 获取重复文件名
     *
     * 场景1: 文件还原时，在 savefilePath 路径下，保存 测试.txt 文件重名，则会生成 测试(1).txt
     * 场景2： 上传文件时，在 savefilePath 路径下，保存 测试.txt 文件重名，则会生成 测试(1).txt
     *
     * @param userFile
     * @param savefilePath
     * @return
     */
    public String getRepeatFileName(DocFilePath userFile, String savefilePath) {
        String fileName = userFile.getFileName();
        String extendName = userFile.getExtendName();
        Integer deleteFlag = userFile.getDeleteFlag();

        int isDir = userFile.getIsDir();
        LambdaQueryWrapper<DocFilePath> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(DocFilePath::getFilePath, savefilePath)
                .eq(DocFilePath::getDeleteFlag, deleteFlag)
                .eq(DocFilePath::getFileName, fileName)
                .eq(DocFilePath::getIsDir, isDir);
        if (userFile.getIsDir() == Constant.IS_NOT_DIR) {
            lambdaQueryWrapper.eq(DocFilePath::getExtendName, extendName);
        }
        List<DocFilePath> list = filePathMapper.selectList(lambdaQueryWrapper);
        if (list == null) {
            return fileName;
        }
        if (list.isEmpty()) {
            return fileName;
        }
        int i = 0;

        while (list != null && !list.isEmpty()) {
            i++;
            LambdaQueryWrapper<DocFilePath> lambdaQueryWrapper1 = new LambdaQueryWrapper<>();
            lambdaQueryWrapper1.eq(DocFilePath::getFilePath, savefilePath)
                    .eq(DocFilePath::getDeleteFlag, deleteFlag)
                    .eq(DocFilePath::getFileName, fileName + "(" + i + ")")
                    .eq(DocFilePath::getIsDir, isDir);
            if (userFile.getIsDir() == Constant.IS_NOT_DIR) {
                lambdaQueryWrapper1.eq(DocFilePath::getExtendName, extendName);
            }
            list = filePathMapper.selectList(lambdaQueryWrapper1);
        }

        return fileName + "(" + i + ")";

    }

    /**
     * 还原父文件路径
     * <p>
     * 1、回收站文件还原操作会将文件恢复到原来的路径下,当还原文件的时候，如果父目录已经不存在了，则需要把父目录给还原
     * 2、上传目录
     *
     * @param
     * @param childId 文件pathID
     */
    public synchronized void restoreParentFilePath(QiwenFile qiwenFile, String childId) {
        if (qiwenFile.isFile()) {
            qiwenFile = qiwenFile.getParentFile();
        }
        while(qiwenFile.getParent() != null) {
            String fileName = qiwenFile.getName();
            String parentFilePath = qiwenFile.getParent();

//            QueryWrapper<DocFilePath> qw = new QueryWrapper<>();
//            qw.eq("file_path", parentFilePath).eq("file_name", fileName).eq("delete_flag", Constant.DEL_FALSE).eq("is_dir", Constant.IS_DIR);

            List<DocFilePath> userFileList = docFilePathService.getDocFilePathsByPathName(parentFilePath, fileName);
            String parentId;
            DocFilePath userFile;
            if (userFileList.size() == 0) {
                userFile = PathFileUtil.getDir( parentFilePath, fileName, null);
                try {
                    userFileList.add(userFile);
                    redisUtil.set(CacheConstant.DOC_FILE_PATH_CACHE+"::"+parentFilePath+':'+fileName,userFileList);
                    filePathMapper.insert(userFile);

                } catch (Exception e) {
//                    System.out.println("重复：：：");
                    if (e.getMessage().contains("Duplicate entry")) {
                        log.error("重复了！！" + "【" + fileName+"】" + "["+ parentFilePath + "]");
                        //ignore
                    } else {
                        log.error("异常了");
//                        log.error(e.getMessage());
                    }
                }
                qiwenFile = new QiwenFile(parentFilePath, true);
            } else {
                userFile = userFileList.get(0);
                qiwenFile = new QiwenFile("/", true);
            }
            parentId = userFile.getPathId();
            filePathMapper.update(null,
                    new LambdaUpdateWrapper<DocFilePath>().set(DocFilePath::getParentId,parentId).eq(DocFilePath::getPathId, childId));

            childId = userFile.getPathId();

        }
    }



    /**
     * 拷贝文件
     * 场景：修改的文件被多处引用时，需要重新拷贝一份，然后在新的基础上修改
     * @param fileBean
     * @param userFile
     * @return
     */
    public String copyFile(DocFile fileBean, DocFilePath userFile) {
        Copier copier = new LocalStorageCopier();
        Downloader downloader = new LocalStorageDownloader();
        DownloadFile downloadFile = new DownloadFile();
        downloadFile.setFileUrl(fileBean.getFileUrl());
        CopyFile copyFile = new CopyFile();
        copyFile.setExtendName(userFile.getExtendName());
        String fileUrl = copier.copy(downloader.getInputStream(downloadFile), copyFile);
        if (downloadFile.getOssClient() != null) {
            downloadFile.getOssClient().shutdown();
        }
        fileBean.setFileUrl(fileUrl);
        fileBean.setFileId(null);
        docFileMapper.insert(fileBean);
        userFile.setFileId(fileBean.getFileId());
        userFile.setUpdateTime(DateUtils.getDate());
        filePathMapper.updateById(userFile);
        return fileUrl;
    }

    public void saveFileInputStream(String fileUrl, InputStream inputStream) throws IOException {
        Writer writer1 = new LocalStorageWriter();
        WriteFile writeFile = new WriteFile();
        writeFile.setFileUrl(fileUrl);
        int fileSize = inputStream.available();
        writeFile.setFileSize(fileSize);
        writer1.write(inputStream, writeFile);
    }

    public String getIdentifierByFile(String fileUrl, int storageType) throws IOException {
        DownloadFile downloadFile = new DownloadFile();
        downloadFile.setFileUrl(fileUrl);
        InputStream inputStream = new LocalStorageDownloader().getInputStream(downloadFile);
        String md5Str = DigestUtils.md5Hex(inputStream);
        return md5Str;
    }

    /**
     * 删除重复的子目录文件
     *
     * 当还原目录的时候，如果其子目录在文件系统中已存在，则还原之后进行去重操作
     * @param filePath
     */
    public void deleteRepeatSubDirFile(String filePath) {
        log.debug("删除子目录："+filePath);
        LambdaQueryWrapper<DocFilePath> lambdaQueryWrapper = new LambdaQueryWrapper<>();

        lambdaQueryWrapper.select(DocFilePath::getFileName, DocFilePath::getFilePath)
                .likeRight(DocFilePath::getFilePath, PathFileUtil.formatLikePath(filePath))
                .eq(DocFilePath::getIsDir, Constant.IS_DIR)
                .eq(DocFilePath::getDeleteFlag, Constant.DEL_FALSE)
                .groupBy(DocFilePath::getFilePath, DocFilePath::getFileName)
                .having("count(file_name) >= 2");
        List<DocFilePath> repeatList = docFilePathService.list(lambdaQueryWrapper);

        for (DocFilePath userFile : repeatList) {
            LambdaQueryWrapper<DocFilePath> lambdaQueryWrapper1 = new LambdaQueryWrapper<>();
            lambdaQueryWrapper1.eq(DocFilePath::getFilePath, userFile.getFilePath())
                    .eq(DocFilePath::getFileName, userFile.getFileName())
                    .eq(DocFilePath::getDeleteFlag, Constant.DEL_FALSE);
            List<DocFilePath> userFiles = docFilePathService.list(lambdaQueryWrapper1);
            for (int i = 0; i < userFiles.size() - 1; i ++) {
                docFilePathService.removeById(userFiles.get(i).getPathId());
            }
        }
    }

    public DocFilePath getParent(String filePath) {
        QiwenFile qiwenFile = new QiwenFile(filePath, true);
        DocFilePath parent = docFilePathService.getOne(new LambdaQueryWrapper<DocFilePath>()
                .eq(DocFilePath::getFilePath, qiwenFile.getParent())
                .eq(DocFilePath::getFileName, qiwenFile.getName())
                .eq(DocFilePath::getDeleteFlag, Constant.DEL_FALSE)
                .eq(DocFilePath::getIsDir, Constant.IS_DIR));
        return parent;
    }

    /**
     * 判定是不是有访问权限的祖先节点，如果是前端需要展示该文件
     * @param subVisits
     * @param i
     * @return
     */
    public boolean isParentsOrChild(Map<String,DocFilePath> subVisits, DocFilePath i, boolean visit) {
        // 遍历权限列表
        Iterator<String> iterator = subVisits.keySet().iterator();
        while (iterator.hasNext()){
            String id = iterator.next();
            DocFilePath dfp = subVisits.get(id);
            if (dfp == null) continue;
            // 获取有权限的文件全路径
            String path = new QiwenFile(dfp.getFilePath(),dfp.getFileName(),true).getPath();

            // 判断当前文件是不是有权限文件的子级
            if ( i.getFilePath().startsWith( path )) {
                return true;
            }
            // 如果是访问权限，需要判断当前文件是不是有访问权限文件的祖先节点
            if (visit && i.isDirectory()) {
                String curPath = new QiwenFile(i.getFilePath(), i.getFileName(), true).getPath();
                if (dfp.getFilePath().startsWith(curPath)){
                    i.setPermission(true);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 判定是不是有访问权限的祖先节点，如果是前端需要展示该文件
     * @param subVisits
     * @param i
     * @return
     */
    public boolean isParentsOrChild(Map<String,DocFilePath> subVisits, RecoveryFileListVo i, boolean visit) {
        // 遍历权限列表
        Iterator<String> iterator = subVisits.keySet().iterator();
        while (iterator.hasNext()){
            String id = iterator.next();
            DocFilePath dfp = subVisits.get(id);
            if (dfp == null) continue;
            // 获取有权限的文件全路径
            String path = new QiwenFile(dfp.getFilePath(),dfp.getFileName(),true).getPath();

            // 判断当前文件是不是有权限文件的子级
            try {
                if (i.getFilePath().startsWith(path)) {
                    return true;
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
            // 如果是访问权限，需要判断当前文件是不是有访问权限文件的祖先节点
            if (visit && i.isDirectory()) {
                String curPath = new QiwenFile(i.getFilePath(), i.getFileName(), true).getPath();
                if (dfp.getFilePath().startsWith(curPath)){
                  //  i.setPermission(true);
                    return true;
                }
            }
        }
        return false;
    }
}