package com.vci.web.util.file.clientutil;

import com.vci.dto.VciFileObjectDTO;
import com.vci.dto.VciFileShareDTO;
import com.vci.dto.VciFileShareHasClassifyDTO;
import com.vci.pagemodel.VciFileObjectVO;
import com.vci.pagemodel.VciFileShareResultVO;
import com.vci.properties.VciFileTransProperties;
import com.vci.provider.VciFileDownloadProvider;
import com.vci.provider.VciFileQueryProvider;
import com.vci.provider.VciFileUploadProvider;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.BaseModelVO;
import com.vci.starter.web.pagemodel.BaseResult;
import com.vci.starter.web.util.BeanUtil;
import com.vci.starter.web.util.LangBaseUtil;
import com.vci.starter.web.util.LocalFileUtil;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.web.util.file.VciZipUtil;
import net.lingala.zip4j.core.ZipFile;
import net.lingala.zip4j.exception.ZipException;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author ludc
 * @date 2024/7/16 14:43
 */
@Component
public class VciFileServerClientUtil {
    public static final int BLOCKSIZE = 1048576;
    @Autowired(
            required = false
    )
    private VciFileUploadProvider vciFileUploadProvider;
    @Autowired(
            required = false
    )
    private VciFileDocClassifyClientUtil fileDocClassifyClientUtil;
    @Autowired
    private VciFileTransProperties vciFileTransProperties;
    @Autowired(
            required = false
    )
    private VciFileQueryProvider vciFileQueryProvider;
    @Autowired(
            required = false
    )
    private VciFileDownloadProvider vciFileDownloadProvider;
    @Autowired
    private VciZipUtil zipUtil;

    public VciFileServerClientUtil() {
    }

    public String getFileExtension(String fileName) {
        String fileExtension = "";
        if (fileName.indexOf(".") > -1) {
            fileExtension = fileName.substring(fileName.lastIndexOf(".") + 1);
        }

        return fileExtension;
    }

    public String getFileNameNoExtension(String fileName) {
        String fileNameNoExtension = fileName.substring(0, fileName.lastIndexOf("."));
        return fileNameNoExtension;
    }

    private void getFileFromFolder(File folderFile, Set<File> sourceFileSet) {
        File[] fileArr = folderFile.listFiles();
        File[] var4 = fileArr;
        int var5 = fileArr.length;

        for(int var6 = 0; var6 < var5; ++var6) {
            File file = var4[var6];
            if (file.isFile()) {
                sourceFileSet.add(file);
            }

            if (file.isDirectory()) {
                this.getFileFromFolder(file, sourceFileSet);
            }
        }

    }

    public String getFileDocClassifyName(String classifyId) throws VciBaseException {
        return this.fileDocClassifyClientUtil.selectDocClassifyNameById(classifyId);
    }

    public BaseResult<VciFileObjectVO> uploadFile(VciFileObjectDTO fileObjectDTO) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件传输对象", fileObjectDTO.getOwnbizOid(), "业务数据主键", fileObjectDTO.getOwnBtmname(), "业务数据业务类型", fileObjectDTO.getSourceFilePath(), "文件路径", fileObjectDTO.getFileDocClassify(), "文档类型编号"});
        List<VciFileObjectDTO> vciFileObjectDTOS = new ArrayList();
        Map<String, File> sourceFileMap = new HashMap();
        String sourceFilePath = fileObjectDTO.getSourceFilePath();
        File sourceFile = new File(sourceFilePath);
        if (!sourceFile.exists()) {
            throw new VciBaseException("fileNotFound", new String[]{sourceFile.getName()});
        } else {
            String _key;
            if (StringUtils.isNotBlank(fileObjectDTO.getFileDocClassify()) && StringUtils.isBlank(fileObjectDTO.getFileDocClassifyName())) {
                _key = this.getFileDocClassifyName(fileObjectDTO.getFileDocClassify());
                fileObjectDTO.setFileDocClassifyName(_key);
            }

            fileObjectDTO.setFileExtension(this.getFileExtension(sourceFile.getName()));
            if (StringUtils.isBlank(fileObjectDTO.getName())) {
                fileObjectDTO.setName(this.getFileNameNoExtension(sourceFile.getName()));
            }

            if (StringUtils.isBlank(fileObjectDTO.getId())) {
                fileObjectDTO.setId(fileObjectDTO.getName());
            }

            fileObjectDTO.setFileSize(sourceFile.length());
            vciFileObjectDTOS.add(fileObjectDTO);
            _key = fileObjectDTO.getId() + "{##$$}" + fileObjectDTO.getName();
            sourceFileMap.put(_key, sourceFile);
            Map<String, VciFileObjectVO> resultMap = this.uploadFile((List)vciFileObjectDTOS, (Map)sourceFileMap);
            BaseResult result = new BaseResult();
            if (resultMap != null && resultMap.size() > 0) {
                List<VciFileObjectVO> resultList = (List)resultMap.values().stream().collect(Collectors.toList());
                result.setData(resultList);
                result.setMsg("uploadSuccess");
                result.setObj(resultMap.get(sourceFilePath));
                result.setSuccess(true);
            } else {
                result.setMsg("uploadFail");
            }

            return result;
        }
    }

    public Map<String, VciFileObjectVO> batchUploadFiles(List<VciFileObjectDTO> fileObjectDTOS) throws VciBaseException {
        Iterator var2 = fileObjectDTOS.iterator();

        while(var2.hasNext()) {
            VciFileObjectDTO vciFileObjectDTO = (VciFileObjectDTO)var2.next();
            VciBaseUtil.alertNotNull(new Object[]{vciFileObjectDTO, "文件传输对象", vciFileObjectDTO.getOwnbizOid(), "业务数据主键", vciFileObjectDTO.getOwnBtmname(), "业务数据业务类型", vciFileObjectDTO.getSourceFilePath(), "文件路径", vciFileObjectDTO.getFileDocClassify(), "文档类型编号"});
        }

        Map<String, File> sourceFileMap = new HashMap();
        Iterator var9 = fileObjectDTOS.iterator();

        while(var9.hasNext()) {
            VciFileObjectDTO vciFileObjectDTO = (VciFileObjectDTO)var9.next();
            String sourceFilePath = vciFileObjectDTO.getSourceFilePath();
            File sourceFile = new File(sourceFilePath);
            if (!sourceFile.exists()) {
                throw new VciBaseException("fileNotFound", new String[]{sourceFile.getName()});
            }

            String _key;
            if (StringUtils.isNotBlank(vciFileObjectDTO.getFileDocClassify()) && StringUtils.isBlank(vciFileObjectDTO.getFileDocClassifyName())) {
                _key = this.getFileDocClassifyName(vciFileObjectDTO.getFileDocClassify());
                vciFileObjectDTO.setFileDocClassifyName(_key);
            }

            vciFileObjectDTO.setFileExtension(this.getFileExtension(sourceFile.getName()));
            if (StringUtils.isBlank(vciFileObjectDTO.getName())) {
                vciFileObjectDTO.setName(this.getFileNameNoExtension(sourceFile.getName()));
            }

            if (StringUtils.isBlank(vciFileObjectDTO.getId())) {
                vciFileObjectDTO.setId(vciFileObjectDTO.getName());
            }

            vciFileObjectDTO.setFileSize(sourceFile.length());
            _key = vciFileObjectDTO.getId() + "{##$$}" + vciFileObjectDTO.getName();
            sourceFileMap.put(_key, sourceFile);
        }

        return this.uploadFile((List)fileObjectDTOS, (Map)sourceFileMap);
    }

    public Map<String, VciFileObjectVO> uploadFileForFolder(VciFileObjectDTO fileObjectDTO) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件数据传输对象", fileObjectDTO.getOwnbizOid(), "业务数据主键", fileObjectDTO.getOwnBtmname(), "业务数据的类型", fileObjectDTO.getDirPath(), "文件夹", fileObjectDTO.getFileDocClassify(), "文档类型"});
        Map<String, File> sourceFileMap = new HashMap();
        List<VciFileObjectDTO> vciFileObjectDTOS = new ArrayList();
        String dirPath = fileObjectDTO.getDirPath();
        File dirFile = new File(dirPath);
        if (!dirFile.isDirectory()) {
            throw new VciBaseException("isNotFolder", new String[]{dirFile.getName()});
        } else if (!dirFile.exists()) {
            throw new VciBaseException("folderNotExist", new String[]{dirFile.getName()});
        } else {
            Set<File> sourceFileSet = new HashSet();
            this.getFileFromFolder(dirFile, sourceFileSet);
            if (StringUtils.isNotBlank(fileObjectDTO.getFileDocClassify()) && StringUtils.isBlank(fileObjectDTO.getFileDocClassifyName())) {
                String classifyName = this.getFileDocClassifyName(fileObjectDTO.getFileDocClassify());
                fileObjectDTO.setFileDocClassifyName(classifyName);
            }

            Iterator var11 = sourceFileSet.iterator();

            while(var11.hasNext()) {
                File file = (File)var11.next();
                VciFileObjectDTO tempDTO = new VciFileObjectDTO();
                BeanUtil.convert(fileObjectDTO, tempDTO);
                tempDTO.setFileExtension(this.getFileExtension(file.getName()));
                tempDTO.setName(this.getFileNameNoExtension(file.getName()));
                tempDTO.setId(this.getFileNameNoExtension(file.getName()));
                tempDTO.setFileSize(file.length());
                vciFileObjectDTOS.add(tempDTO);
                String _key = tempDTO.getId() + "{##$$}" + tempDTO.getName();
                sourceFileMap.put(_key, file);
            }

            return this.uploadFile((List)vciFileObjectDTOS, (Map)sourceFileMap);
        }
    }

    private Map<String, VciFileObjectVO> uploadFile(List<VciFileObjectDTO> vciFileObjectDTOS, Map<String, File> sourceFileMap) throws VciBaseException {
        VciFileObjectDTO parameterObject = new VciFileObjectDTO();
        parameterObject.setVciFileObjectDTOList(vciFileObjectDTOS);
        BaseResult<VciFileObjectVO> baseResult = this.vciFileUploadProvider.initUploadFileInfo(parameterObject);
        if (baseResult.getData() != null && baseResult.getData().size() != 0) {
            Map<String, VciFileObjectVO> resultMap = new HashMap();
            Iterator var6 = baseResult.getData().iterator();

            while(var6.hasNext()) {
                VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)var6.next();
                String _key = vciFileObjectVO.getId() + "{##$$}" + vciFileObjectVO.getName();
                File sourceFile = (File)sourceFileMap.get(_key);
                String sourceFilePath = sourceFile.getAbsolutePath();
                String tempFolder = sourceFile.getParent() + File.separator + VciBaseUtil.getPk();
                File tempFolderFile = new File(tempFolder);
                if (!tempFolderFile.exists()) {
                    tempFolderFile.mkdirs();
                }

                BaseResult tempBaseResult = null;
                long fileSize = vciFileObjectVO.getFileSize();
                FileInputStream in = null;

                try {
                    in = new FileInputStream(sourceFile);
                    byte[] buffer = new byte[1048576];

                    int temp;
                    for(temp = 0; (long)temp < fileSize - 1048576L; temp += 1048576) {
                        in.read(buffer, 0, 1048576);
                        MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
                        tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, (long)temp, vciFileObjectVO.getOid());
                        if (!tempBaseResult.isSuccess()) {
                            throw new VciBaseException(tempBaseResult.getMsg());
                        }
                    }

                    int remainSize = (int)(fileSize - (long)temp);
                    buffer = new byte[remainSize];
                    in.read(buffer, 0, remainSize);
                    MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
                    tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, (long)temp, vciFileObjectVO.getOid());
                    if (!tempBaseResult.isSuccess()) {
                        throw new VciBaseException(tempBaseResult.getMsg());
                    }

                    resultMap.put(sourceFilePath, (VciFileObjectVO)tempBaseResult.getObj());
                } catch (FileNotFoundException var30) {
                    throw new VciBaseException("fileNotFound", new String[]{sourceFile.getName()});
                } catch (IOException var31) {
                    throw new VciBaseException("fileReadFail", new String[]{var31.getMessage()});
                } catch (Exception var32) {
                    throw new VciBaseException("uploadFail", new String[]{var32.getMessage()});
                } finally {
                    if (in != null) {
                        try {
                            in.close();
                        } catch (IOException var29) {
                            var29.printStackTrace();
                        }
                    }

                    LocalFileUtil.deleteFile(tempFolderFile);
                }
            }

            return resultMap;
        } else {
            throw new VciBaseException("fileInfoInitFail");
        }
    }

    public MultipartFile getMultipartFile(byte[] buffer, File tempFolderFile) {
        FileItemFactory factory = new DiskFileItemFactory(10240, tempFolderFile);
        FileItem item = factory.createItem("file", "multipart/form-data", true, VciBaseUtil.getPk());
        OutputStream os = null;

        try {
            os = item.getOutputStream();
            os.write(buffer);
            os.close();
        } catch (IOException var10) {
            var10.printStackTrace();
        } finally {
            IOUtils.closeQuietly(os);
        }

        MultipartFile mfile = new CommonsMultipartFile(item);
        return mfile;
    }

    public BaseResult<VciFileObjectVO> uploadFileByZip(String zipFilePath, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
        if (StringUtils.isBlank(zipFilePath)) {
            throw new VciBaseException("fileNull");
        } else {
            File zipFile = new File(zipFilePath);
            if (!zipFile.exists()) {
                throw new VciBaseException("fileNotFound", new String[]{zipFile.getName()});
            } else {
                return this.uploadFileByZip(zipFile, fileObjectDTO);
            }
        }
    }

    public BaseResult<VciFileObjectVO> uploadFileByZip(File zipFile, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
        if (zipFile != null && zipFile.exists()) {
            ZipFile zipFileObj = null;

            try {
                zipFileObj = new ZipFile(zipFile);
                if (!zipFileObj.isValidZipFile()) {
                    throw new VciBaseException("zipFileError");
                }
            } catch (ZipException var5) {
                throw new VciBaseException("zipFileReadError");
            }

            return this.uploadFileByZip(zipFileObj, fileObjectDTO);
        } else {
            throw new VciBaseException("fileNotFound", new String[]{zipFile.getName()});
        }
    }

    public BaseResult<VciFileObjectVO> uploadFileByZip(ZipFile zipFile, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件数据传输对象", fileObjectDTO.getOwnbizOid(), "业务数据主键", fileObjectDTO.getOwnBtmname(), "业务数据的类型", fileObjectDTO.getFileDocClassify(), "文档类型"});
        String tempFolderPath = zipFile.getFile().getParentFile() + File.separator + VciBaseUtil.getPk();
        File tempFolder = new File(tempFolderPath);
        if (!tempFolder.exists()) {
            tempFolder.mkdirs();
        }

        try {
            zipFile.setFileNameCharset(this.vciFileTransProperties.getZipCharset());
            zipFile.extractAll(tempFolderPath);
        } catch (ZipException var10) {
            throw new VciBaseException("zipFileReadError");
        }

        fileObjectDTO.setDirPath(tempFolderPath);
        BaseResult baseResult = new BaseResult();
        Map resultMap = null;

        try {
            resultMap = this.uploadFileForFolder(fileObjectDTO);
        } catch (Exception var9) {
            File folderFile = new File(tempFolderPath);
            LocalFileUtil.deleteFile(folderFile);
            throw new VciBaseException("uploadFail");
        }

        if (resultMap != null && resultMap.size() > 0) {
            List<VciFileObjectVO> resultList = (List)resultMap.values().stream().collect(Collectors.toList());
            baseResult.setData(resultList);
            baseResult.setMsg("uploadSuccess");
            baseResult.setSuccess(true);
        } else {
            baseResult.setMsg("uploadFail");
        }

        File folderFile = new File(tempFolderPath);
        LocalFileUtil.deleteFile(folderFile);
        return baseResult;
    }

    public BaseResult<VciFileObjectVO> shareFilesToBO(String sourceBtmName, String sourceBusinessOid, String btmName, String businessOid) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{sourceBtmName, "原业务类型", sourceBusinessOid, "原业务数据主键", btmName, "业务类型", businessOid, "业务数据主键"});
        return this.vciFileUploadProvider.shareFilesToBO(sourceBtmName, sourceBusinessOid, btmName, businessOid);
    }

    public BaseResult shareFilesToBO(String fileOids, String btmName, String businessOid) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileOids, "文件主键", btmName, "业务类型", businessOid, "业务数据主键"});
        return this.vciFileUploadProvider.shareFilesToBO(fileOids, btmName, businessOid);
    }

    public BaseResult shareAnnexFilesToBO(String sourceBtmName, String sourceBusinessOid, String btmName, String businessOid) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{sourceBtmName, "原业务类型", sourceBusinessOid, "原业务数据主键", btmName, "业务类型", businessOid, "业务数据主键"});
        return this.vciFileUploadProvider.shareAnnexFilesToBO(sourceBtmName, sourceBusinessOid, btmName, businessOid);
    }

    public BaseResult releasedFile(Collection<VciFileObjectDTO> vciFileObjectDTOS) throws VciBaseException {
        if (vciFileObjectDTOS != null && vciFileObjectDTOS.size() > 0) {
            List<String> fileOidList = new ArrayList();
            Iterator var3 = vciFileObjectDTOS.iterator();

            while(var3.hasNext()) {
                VciFileObjectDTO fileObjectDTO = (VciFileObjectDTO)var3.next();
                fileOidList.add(fileObjectDTO.getOid());
            }

            String fileOids = VciBaseUtil.list2String(fileOidList);
            return this.vciFileQueryProvider.releasedFile(fileOids);
        } else {
            throw new VciBaseException("文件对象列表为空，不能生效文件！");
        }
    }

    public BaseResult releasedFile(VciFileObjectDTO fileObjectDTO) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件传输对象"});
        return this.vciFileQueryProvider.releasedFile(fileObjectDTO.getOid());
    }

    public BaseResult uploadFile(InputStream inputStream, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
        if (inputStream == null) {
            throw new VciBaseException("uploadFail", new String[]{"文件流"});
        } else {
            List<VciFileObjectDTO> vciFileObjectDTOS = new ArrayList();
            vciFileObjectDTOS.add(fileObjectDTO);
            VciFileObjectDTO parameterObject = new VciFileObjectDTO();
            parameterObject.setVciFileObjectDTOList(vciFileObjectDTOS);
            BaseResult<VciFileObjectVO> baseResult = this.vciFileUploadProvider.initUploadFileInfo(parameterObject);
            if (baseResult.getData() != null && baseResult.getData().size() != 0) {
                VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)baseResult.getData().iterator().next();
                String tempFolder = LocalFileUtil.getProjectFolder() + File.separator + VciBaseUtil.getPk();
                File tempFolderFile = new File(tempFolder);
                if (!tempFolderFile.exists()) {
                    tempFolderFile.mkdirs();
                }

                BaseResult tempBaseResult;
                try {
                    int fileSize = inputStream.available();
                    fileObjectDTO.setFileSize((long)fileSize);
                    byte[] buffer = new byte[1048576];

                    long temp;
                    for(temp = 0L; temp < (long)fileSize; temp += 1048576L) {
                        inputStream.read(buffer, 0, 1048576);
                        MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
                        tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, temp, vciFileObjectVO.getOid());
                        if (!tempBaseResult.isSuccess()) {
                            throw new VciBaseException(tempBaseResult.getMsg());
                        }
                    }

                    int remainSize = (int)((long)fileSize - temp);
                    buffer = new byte[remainSize];
                    inputStream.read(buffer, 0, remainSize);
                    MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
                    tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, temp, vciFileObjectVO.getOid());
                    if (!tempBaseResult.isSuccess()) {
                        throw new VciBaseException(tempBaseResult.getMsg());
                    }
                } catch (Exception var23) {
                    throw new VciBaseException("uploadFail", new String[]{var23.getMessage()});
                } finally {
                    if (inputStream != null) {
                        try {
                            inputStream.close();
                        } catch (IOException var22) {
                            var22.printStackTrace();
                        }
                    }

                    LocalFileUtil.deleteFile(tempFolderFile);
                }

                return tempBaseResult;
            } else {
                throw new VciBaseException("fileInfoInitFail");
            }
        }
    }

    public void downloadFileObject(String tempFilePath, VciFileObjectVO vciFileObjectVO) throws VciBaseException {
        FileOutputStream out = null;
        File tempFile = new File(tempFilePath);

        try {
            File dirFile = tempFile.getParentFile();
            if (!dirFile.exists()) {
                dirFile.mkdirs();
            }

            if (!tempFile.exists()) {
                tempFile.createNewFile();
            }

            long fileSize = vciFileObjectVO.getFileSize();
            int temp = 0;

            byte[] buffer;
            for(out = new FileOutputStream(tempFile); (long)temp < fileSize; temp += buffer.length) {
                BaseResult<byte[]> baseResult = this.vciFileDownloadProvider.sectionDownloadByFileOid(vciFileObjectVO.getOid(), (long)temp);
                buffer = (byte[])baseResult.getObj();
                out.write(buffer, 0, buffer.length);
            }
        } catch (Exception var18) {
            if (tempFile.exists()) {
                tempFile.delete();
            }

            File tempFolderFile = tempFile.getParentFile();
            File[] files = tempFolderFile.listFiles();
            if (tempFolderFile.exists() && (files == null || files.length == 0)) {
                tempFolderFile.delete();
            }

            throw new VciBaseException("downloadFail", new String[]{var18.getMessage()});
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
            } catch (Exception var17) {
                var17.printStackTrace();
            }

        }

    }

    public String downloadByFileOid(String fileOid) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileOid, "文件主键"});
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        return this.downloadByFileOid(tempFolder, fileOid);
    }

    public String downloadByFileOid(String tempFolder, String fileOid) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileOid, "文件主键", tempFolder, "下载的目录"});
        BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.getFileObjectByOid(fileOid);
        VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)baseResult.getObj();
        if (vciFileObjectVO == null) {
            throw new VciBaseException("这个文件不存在");
        } else {
            String tempFilePath = tempFolder + File.separator + vciFileObjectVO.getOid() + File.separator + vciFileObjectVO.getName() + "." + vciFileObjectVO.getFileExtension();
            this.downloadFileObject(tempFilePath, vciFileObjectVO);
            return tempFilePath;
        }
    }

    public Map<String, String> downloadByFileOids(Collection<String> fileOidCollection) throws VciBaseException {
        return this.downloadByFileOids(LocalFileUtil.getDefaultTempFolder(), fileOidCollection);
    }

    public Map<String, String> downloadByFileOids(String tempFolder, Collection<String> fileOidCollection) throws VciBaseException {
        VciBaseUtil.alertCollectionNotNull("文件的主键集合", fileOidCollection);
        Map<String, String> fileOidPathMap = new HashMap();
        Iterator var4 = fileOidCollection.iterator();

        while(var4.hasNext()) {
            String fileOid = (String)var4.next();
            fileOidPathMap.put(fileOid, this.downloadByFileOid(tempFolder, fileOid));
        }

        return fileOidPathMap;
    }

    public String downloadToZipByFileOid(String fileOid) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileOid, "文件的主键"});
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.getFileObjectByOid(fileOid);
        VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)baseResult.getObj();
        String zipFile = tempFolder + File.separator + vciFileObjectVO.getName() + "." + vciFileObjectVO.getFileExtension();
        this.downloadToZipByFileOid(zipFile, fileOid);
        return zipFile;
    }

    public void downloadToZipByFileOid(String zipFile, String fileOid) throws VciBaseException {
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        String filePath = this.downloadByFileOid(tempFolder, fileOid);
        File file = new File(filePath);
        this.zipUtil.addFileToZip(file, zipFile);
        if (file.exists()) {
            file.delete();
        }

        File dirFile = file.getParentFile();
        if (dirFile.exists()) {
            dirFile.delete();
        }

    }

    public String downloadToZipByFileOids(Collection<String> fileOidCollection) throws VciBaseException {
        String zipFile = LocalFileUtil.getDefaultTempFolder() + File.separator + VciBaseUtil.getPk() + ".zip";
        this.downloadToZipByFileOids(zipFile, fileOidCollection);
        return zipFile;
    }

    public void downloadToZipByFileOids(String zipFile, Collection<String> fileOidCollection) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{zipFile, "压缩包的路径"});
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        this.downloadByFileOids(tempFolder, fileOidCollection);
        this.zipUtil.folderToZipFile(tempFolder, zipFile);
        File folderFile = new File(tempFolder);
        LocalFileUtil.deleteFile(folderFile);
    }

    public void downloadToIOByFileOid(OutputStream ops, String fileOid) throws VciBaseException {
        this.downloadToIOByFileOid(ops, fileOid, true);
    }

    public void downloadToIOByFileOid(OutputStream ops, String fileOid, boolean closeOutSteam) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{ops, "输出流", fileOid, "文件主键"});
        BaseResult<VciFileObjectVO> returnBaseResult = this.vciFileQueryProvider.getFileObjectByOid(fileOid);
        VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)returnBaseResult.getObj();

        try {
            long fileSize = vciFileObjectVO.getFileSize();

            byte[] buffer;
            for(int temp = 0; (long)temp <= fileSize; temp += buffer.length) {
                BaseResult<byte[]> baseResult = this.vciFileDownloadProvider.sectionDownloadByFileOid(vciFileObjectVO.getOid(), (long)temp);
                buffer = (byte[])baseResult.getObj();
                ops.write(buffer, temp, buffer.length);
            }
        } catch (Throwable var14) {
            throw new VciBaseException("downloadFail", new String[]{LangBaseUtil.getErrorMsg(var14)}, var14);
        } finally {
            if (closeOutSteam) {
                IOUtils.closeQuietly(ops);
            }

        }

    }

    public Map<String, String> downloadByOwnbiz(String ownBizOid, String ownBtmName) throws VciBaseException {
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        return this.downloadByOwnbiz(tempFolder, ownBizOid, ownBtmName);
    }

    public Map<String, String> downloadByOwnbiz(String tempFolder, String ownBizOid, String ownBtmName) throws VciBaseException {
        return this.downloadByOwnbizAndClassify(tempFolder, ownBizOid, ownBtmName, "");
    }

    public Map<String, String> downloadByOwnbizAndClassify(String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        return this.downloadByOwnbizAndClassify(tempFolder, ownBizOid, ownBtmName, docClassifyId);
    }

    public Map<String, String> downloadByOwnbizAndClassify(String tempFolder, String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
        if (StringUtils.isBlank(docClassifyId)) {
            docClassifyId = "";
        }

        BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.listFilesByOwnbizAndClassify(ownBizOid, ownBtmName, docClassifyId);
        if (CollectionUtils.isEmpty(baseResult.getData())) {
            throw new VciBaseException("fileInfoNotExist", new String[]{""});
        } else {
            Map<String, String> fileOidPathMap = new HashMap();
            baseResult.getData().stream().forEach((vciFileObjectVO) -> {
                String thisFilePath = tempFolder + File.separator + vciFileObjectVO.getName() + "." + vciFileObjectVO.getFileExtension();
                this.downloadFileObject(thisFilePath, vciFileObjectVO);
                fileOidPathMap.put(vciFileObjectVO.getOid(), thisFilePath);
            });
            return fileOidPathMap;
        }
    }

    public String downloadToZipByOwnbiz(String ownBizOid, String ownBtmName) throws VciBaseException {
        String zipFile = LocalFileUtil.getDefaultTempFolder() + File.separator + VciBaseUtil.getPk() + ".zip";
        this.downloadToZipByOwnbiz(zipFile, ownBizOid, ownBtmName);
        return zipFile;
    }

    public void downloadToZipByOwnbiz(String zipFile, String ownBizOid, String ownBtmName) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        this.downloadByOwnbiz(tempFolder, ownBizOid, ownBtmName);
        this.zipUtil.folderToZipFile(tempFolder, zipFile);
        File file = new File(tempFolder);
        LocalFileUtil.deleteFile(file);
    }

    public String downloadToZipByOwnbizAndClassify(String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
        String zipFile = LocalFileUtil.getDefaultTempFolder() + File.separator + VciBaseUtil.getPk() + ".zip";
        this.downloadToZipByOwnbizAndClassify(zipFile, ownBizOid, ownBtmName, docClassifyId);
        return zipFile;
    }

    public void downloadToZipByOwnbizAndClassify(String zipFile, String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
        String tempFolder = LocalFileUtil.getDefaultTempFolder();
        this.downloadByOwnbizAndClassify(tempFolder, ownBizOid, ownBtmName, docClassifyId);
        this.zipUtil.folderToZipFile(tempFolder, zipFile);
        File file = new File(tempFolder);
        LocalFileUtil.deleteFile(file);
    }

    public BaseResult deleteFileByOid(String fileOids) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{fileOids, "文件主键"});
        return this.vciFileDownloadProvider.deleteFile(fileOids);
    }

    public BaseResult deleteFileByOwnbiz(String ownBizOid, String ownBtmName) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
        BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.listFilesByOwnbiz(ownBizOid, ownBtmName);
        List<VciFileObjectVO> fileObjectVOList = (List)baseResult.getData();
        if (fileObjectVOList != null && fileObjectVOList.size() > 0) {
            List<String> fileOidList = new ArrayList();
            Iterator var6 = fileObjectVOList.iterator();

            while(var6.hasNext()) {
                VciFileObjectVO fileObjectVO = (VciFileObjectVO)var6.next();
                fileOidList.add(fileObjectVO.getOid());
            }

            String fileOids = VciBaseUtil.list2String(fileOidList);
            return this.deleteFileByOid(fileOids);
        } else {
            return BaseResult.successMsg("deleteSuccess");
        }
    }

    public BaseResult deleteFileByOwnbizAndClassify(String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
        VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
        BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.listFilesByOwnbizAndClassify(ownBizOid, ownBtmName, docClassifyId);
        List<VciFileObjectVO> fileObjectVOList = (List)baseResult.getData();
        if (fileObjectVOList != null && fileObjectVOList.size() > 0) {
            List<String> fileOidList = new ArrayList();
            Iterator var7 = fileObjectVOList.iterator();

            while(var7.hasNext()) {
                VciFileObjectVO fileObjectVO = (VciFileObjectVO)var7.next();
                fileOidList.add(fileObjectVO.getOid());
            }

            String fileOids = VciBaseUtil.list2String(fileOidList);
            return this.deleteFileByOid(fileOids);
        } else {
            return BaseResult.successMsg("deleteSuccess");
        }
    }

    public void batchDeleteFiles(Collection<VciFileObjectVO> fileObjectVOS) throws VciBaseException {
        if (!CollectionUtils.isEmpty(fileObjectVOS)) {
            this.batchDeleteFilesByOids((Collection)fileObjectVOS.stream().map(BaseModelVO::getOid).collect(Collectors.toList()));
        }

    }

    public void batchDeleteFilesByOids(Collection<String> fileOidCollection) throws VciBaseException {
        if (!CollectionUtils.isEmpty(fileOidCollection)) {
            VciBaseUtil.switchCollectionForOracleIn(fileOidCollection).forEach((fileOids) -> {
                BaseResult result = this.vciFileDownloadProvider.deleteFile((String)fileOids.stream().collect(Collectors.joining(",")));
                if (!result.isSuccess()) {
                    throw new VciBaseException(result.getMsg(), result.getMsgObjs());
                }
            });
        }

    }

    public VciFileObjectDTO fileObjectVO2DTO(VciFileObjectVO fileObjectVO) {
        VciFileObjectDTO fileObjectDTO = new VciFileObjectDTO();
        BeanUtil.convert(fileObjectVO, fileObjectDTO);
        return fileObjectDTO;
    }

    public VciFileObjectDTO fileObjectVO2DTOForUpdate(VciFileObjectVO fileObjectVO) {
        VciFileObjectDTO fileObjectDTO = new VciFileObjectDTO();
        BeanUtil.convert(fileObjectVO, fileObjectDTO);
        fileObjectDTO.setFileOid(fileObjectVO.getOid());
        fileObjectDTO.setUpdateFileFlag(true);
        return fileObjectDTO;
    }

    public void updateFileInfos(Collection<VciFileObjectDTO> fileObjectDTOS) {
        if (!CollectionUtils.isEmpty(fileObjectDTOS)) {
            VciBaseUtil.switchCollectionForOracleIn(fileObjectDTOS).stream().forEach((fileDTOs) -> {
                BaseResult result = this.vciFileUploadProvider.updateFileInfos(fileDTOs);
                if (!result.isSuccess()) {
                    throw new VciBaseException(result.getMsg(), result.getMsgObjs());
                }
            });
        }

    }

    public List<VciFileShareResultVO> batchShareFile(Collection<VciFileShareDTO> shareDTOList, String fileDocClassifyId) {
        if (!CollectionUtils.isEmpty(shareDTOList)) {
            List<VciFileShareResultVO> resultVOList = new ArrayList();
            VciBaseUtil.switchCollectionForOracleIn(shareDTOList).stream().forEach((dtos) -> {
                VciFileShareHasClassifyDTO shareHasClassifyDTO = new VciFileShareHasClassifyDTO();
                shareHasClassifyDTO.setDocClassifyId(fileDocClassifyId);
                shareHasClassifyDTO.setShareDTOList((List)dtos.stream().collect(Collectors.toList()));
                BaseResult<VciFileShareResultVO> result = this.vciFileUploadProvider.batchShareFile(shareHasClassifyDTO);
                if (!result.isSuccess()) {
                    throw new VciBaseException(result.getMsg(), result.getMsgObjs());
                } else {
                    resultVOList.addAll(result.getData());
                }
            });
            return resultVOList;
        } else {
            return null;
        }
    }
}