package org.jeecg.modules.doc.service.impl;

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 lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.DateUtils;
import org.jeecg.modules.doc.component.*;
import org.jeecg.modules.doc.constant.Constant;
import org.jeecg.modules.doc.dto.DownloadFileDTO;
import org.jeecg.modules.doc.dto.PreviewDTO;
import org.jeecg.modules.doc.dto.UploadFileDTO;
import org.jeecg.modules.doc.entity.*;
import org.jeecg.modules.doc.enums.UploadFileStatusEnum;
import org.jeecg.modules.doc.mapper.*;
import org.jeecg.modules.doc.service.IFiletransferService;
import org.jeecg.modules.doc.service.IUserStorageFlowService;
import org.jeecg.modules.doc.util.UFOPUtils;
import org.jeecg.modules.doc.vo.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.zip.Adler32;
import java.util.zip.CheckedOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

@Slf4j
@Service
@Transactional(rollbackFor=Exception.class)
public class FiletransferService implements IFiletransferService {

    @Resource
    DocFileMapper docFileMapper;

    @Resource
    DocFilePathMapper docFilePathMapper;
    @Resource
    UploadTaskDetailMapper uploadTaskDetailMapper;

    @Resource
    UploadTaskMapper uploadTaskMapper;

    @Resource
    DocFileDealComp fileDealComp;

    @Resource
    ImageMapper imageMapper;

    @Autowired
    RestTemplate restTemplate;

    @Autowired
    IUserStorageFlowService userStorageFlowService;

    @Override
    public UploadFileVo uploadFileSpeed(UploadFileDTO uploadFileDTO) {
        LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        UploadFileVo uploadFileVo = new UploadFileVo();
        Map<String, Object> param = new HashMap<>();
        param.put("identifier", uploadFileDTO.getIdentifier());
        // 查询是否已存在相同文件
        List<DocFile> list = docFileMapper.selectList(new LambdaQueryWrapper<DocFile>().eq(DocFile::getIdentifier,uploadFileDTO.getIdentifier()));

        String filePath = uploadFileDTO.getFilePath();
        String relativePath = uploadFileDTO.getRelativePath();
        QiwenFile qiwenFile = null;
        if (relativePath.contains("/")) {
            qiwenFile = new QiwenFile(filePath, relativePath, false);
        } else {
            qiwenFile = new QiwenFile(filePath, uploadFileDTO.getFilename(), false);
        }

        // 有相同文件
        if (list != null && !list.isEmpty()) {
            DocFile file = list.get(0);

            DocFilePath userFile = new DocFilePath(qiwenFile,  file.getFileId());
            DocFilePath parent = fileDealComp.getParent(userFile.getFilePath());
            if (parent != null) {
                userFile.setParentId(parent.getPathId());
            }

            // 查询用户文件是否已存在
            DocFilePath param1 = PathFileUtil.searchParam(userFile);
            List<DocFilePath> FilePathList = docFilePathMapper.selectList(new QueryWrapper<>(param1));
            if (FilePathList.size() <= 0) {
                docFilePathMapper.insert(userFile);
                //fileDealComp.uploadESByUserFileId(userFile.getUserFileId());
            }
            if (relativePath.contains("/")) {
                fileDealComp.restoreParentFilePath(qiwenFile, userFile.getPathId());
            }

            // 已极速上传，文件不用再上传
            uploadFileVo.setSkipUpload(true);
        } else {
            // 需要上传
            uploadFileVo.setSkipUpload(false);

            // 查询已上传块
            List<Integer> uploaded = uploadTaskDetailMapper.selectUploadedChunkNumList(uploadFileDTO.getIdentifier());
            if (uploaded != null && !uploaded.isEmpty()) {
                uploadFileVo.setUploaded(uploaded);
            } else {

                // 添加上传任务
                LambdaQueryWrapper<UploadTask> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(UploadTask::getIdentifier, uploadFileDTO.getIdentifier());
                List<UploadTask> rslist = uploadTaskMapper.selectList(lambdaQueryWrapper);
                if (rslist == null || rslist.isEmpty()) {
                    UploadTask uploadTask = new UploadTask();
                    uploadTask.setIdentifier(uploadFileDTO.getIdentifier());
                    uploadTask.setUploadTime(DateUtils.getDataString(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")));
                    uploadTask.setUploadStatus(UploadFileStatusEnum.UNCOMPLATE.getCode());
                    uploadTask.setFileName(qiwenFile.getNameNotExtend());
                    uploadTask.setFilePath(qiwenFile.getParent());
                    uploadTask.setExtendName(qiwenFile.getExtendName());
                    uploadTask.setUserId(loginUser.getUserIdentity());
                    uploadTaskMapper.insert(uploadTask);
                }
            }

        }
        return uploadFileVo;
    }

    @Override
    public void uploadFile(HttpServletRequest request, UploadFileDTO uploadFileDto) {

        UploadFile uploadFile = new UploadFile();
        uploadFile.setChunkNumber(uploadFileDto.getChunkNumber());
        uploadFile.setChunkSize(uploadFileDto.getChunkSize());
        uploadFile.setTotalChunks(uploadFileDto.getTotalChunks());
        uploadFile.setIdentifier(uploadFileDto.getIdentifier());
        uploadFile.setTotalSize(uploadFileDto.getTotalSize());
        uploadFile.setCurrentChunkSize(uploadFileDto.getCurrentChunkSize());

        Uploader uploader = new LocalStorageUploader();
        if (uploader == null) {
            log.error("上传失败，请检查storageType是否配置正确");
            throw new UploadException("上传失败");
        }
        List<UploadFileResult> uploadFileResultList;
        try {
            uploadFileResultList = uploader.upload(request, uploadFile);
        } catch (Exception e) {
            log.error("上传失败，请检查UFOP连接配置是否正确");
            throw new UploadException("上传失败", e);
        }
        for (int i = 0; i < uploadFileResultList.size(); i++){
            UploadFileResult uploadFileResult = uploadFileResultList.get(i);
            String relativePath = uploadFileDto.getRelativePath();
            QiwenFile qiwenFile = null;
            if (relativePath.contains("/")) {
                qiwenFile = new QiwenFile(uploadFileDto.getFilePath(), relativePath, false);
            } else {
                qiwenFile = new QiwenFile(uploadFileDto.getFilePath(), uploadFileDto.getFilename(), false);
            }

            if (UploadFileStatusEnum.SUCCESS.equals(uploadFileResult.getStatus())){
             //   log.info("开始保存===文件路径：{}，文件名：{}，文件唯一标识：{}", uploadFileResult.getFileUrl(), uploadFileResult.getFileName(), uploadFileResult.getIdentifier());
                DocFile fileBean = new DocFile(uploadFileResult);
                    docFileMapper.insert(fileBean);


                DocFilePath userFile = new DocFilePath(qiwenFile, fileBean.getFileId());



                DocFilePath param = PathFileUtil.searchParam(userFile);
                List<DocFilePath> userFileList = docFilePathMapper.selectList(new QueryWrapper<>(param));
                if (userFileList.size() > 0) {
                    String fileName = fileDealComp.getRepeatFileName(userFile, userFile.getFilePath());
                    userFile.setFileName(fileName);
                }
                DocFilePath parent = fileDealComp.getParent(userFile.getFilePath());
                if (parent!=null) {
                    userFile.setParentId(parent.getPathId());
                }
                try {
                    docFilePathMapper.insert(userFile);
                } catch (Exception e) {
                    log.error("上传文件异常：" + e.getMessage());

                }

                if (relativePath.contains("/")) {
                    fileDealComp.restoreParentFilePath(qiwenFile, userFile.getPathId());
                }

               // fileDealComp.uploadESByUserFileId(userFile.getUserFileId());


                LambdaQueryWrapper<UploadTaskDetail> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(UploadTaskDetail::getIdentifier, uploadFileDto.getIdentifier());
                uploadTaskDetailMapper.delete(lambdaQueryWrapper);

                LambdaUpdateWrapper<UploadTask> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
                lambdaUpdateWrapper.set(UploadTask::getUploadStatus, UploadFileStatusEnum.SUCCESS.getCode())
                        .eq(UploadTask::getIdentifier, uploadFileDto.getIdentifier());
                uploadTaskMapper.update(null, lambdaUpdateWrapper);


                try {
                    if (UFOPUtils.isImageFile(uploadFileResult.getExtendName())) {
                        BufferedImage src = uploadFileResult.getBufferedImage();
                        Image image = new Image();
                        image.setImageWidth(src.getWidth());
                        image.setImageHeight(src.getHeight());
                        image.setFileId(fileBean.getFileId());
                        imageMapper.insert(image);
                    }
                } catch (Exception e) {
                    log.error("生成图片缩略图失败！", e);
                }

               // fileDealComp.parseMusicFile(uploadFileResult.getExtendName(), uploadFileResult.getStorageType().getCode(), uploadFileResult.getFileUrl(), fileBean.getFileId());

            } else if (UploadFileStatusEnum.UNCOMPLATE.equals(uploadFileResult.getStatus())) {
                UploadTaskDetail uploadTaskDetail = new UploadTaskDetail();
                uploadTaskDetail.setFilePath(qiwenFile.getParent());
                uploadTaskDetail.setFileName(qiwenFile.getNameNotExtend());
                uploadTaskDetail.setChunkNumber(uploadFileDto.getChunkNumber());
                uploadTaskDetail.setChunkSize((int)uploadFileDto.getChunkSize());
                uploadTaskDetail.setRelativePath(uploadFileDto.getRelativePath());
                uploadTaskDetail.setTotalChunks(uploadFileDto.getTotalChunks());
                uploadTaskDetail.setTotalSize((int)uploadFileDto.getTotalSize());
                uploadTaskDetail.setIdentifier(uploadFileDto.getIdentifier());
                uploadTaskDetailMapper.insert(uploadTaskDetail);

            } else if (UploadFileStatusEnum.FAIL.equals(uploadFileResult.getStatus())) {
                LambdaQueryWrapper<UploadTaskDetail> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(UploadTaskDetail::getIdentifier, uploadFileDto.getIdentifier());
                uploadTaskDetailMapper.delete(lambdaQueryWrapper);

                LambdaUpdateWrapper<UploadTask> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
                lambdaUpdateWrapper.set(UploadTask::getUploadStatus, UploadFileStatusEnum.FAIL.getCode())
                        .eq(UploadTask::getIdentifier, uploadFileDto.getIdentifier());
                uploadTaskMapper.update(null, lambdaUpdateWrapper);
            }
        }

    }


    private String formatChatset(String str) {
        if (str == null) {
            return "";
        }
        if (Charset.forName("ISO-8859-1").newEncoder().canEncode(str)) {
            byte[] bytes = str.getBytes(StandardCharsets.ISO_8859_1);
            return new String(bytes, Charset.forName("GBK"));
        }
        return str;
    }

    @Override
    public void downloadFile(HttpServletResponse httpServletResponse, DownloadFileDTO downloadFileDTO) {
        DocFilePath userFile = docFilePathMapper.selectById(downloadFileDTO.getUserFileId());

        if (userFile.getIsDir() == Constant.IS_NOT_DIR) {


            DocFile fileBean = docFileMapper.selectById(userFile.getFileId());
            Downloader downloader = new LocalStorageDownloader();
            if (downloader == null) {
                log.error("下载失败，文件存储类型不支持下载，storageType:{}", fileBean.getStorageType());
                throw new DownloadException("下载失败");
            }
            DownloadFile downloadFile = new DownloadFile();

            downloadFile.setFileUrl(fileBean.getFileUrl());
            httpServletResponse.setContentLengthLong(fileBean.getFileSize());
            userStorageFlowService.updateSurplusFlowByUserId(downloadFileDTO.getUserToken(), fileBean.getFileSize());
            downloader.download(httpServletResponse, downloadFile);
        } else {

            QiwenFile qiwenFile = new QiwenFile(userFile.getFilePath(), userFile.getFileName(), true);
            List<DocFilePath> userFileList = docFilePathMapper.selectUserFileByLikeRightFilePath(qiwenFile.getPath() );
            List<String> userFileIds = userFileList.stream().map(DocFilePath::getPathId).collect(Collectors.toList());

            downloadUserFileList(httpServletResponse, userFile.getFilePath()+QiwenFile.separator, userFile.getFileName(), userFileIds, downloadFileDTO.getUserToken());
        }
    }

    @Override
    public void downloadUserFileList(HttpServletResponse httpServletResponse, String filePath, String fileName, List<String> userFileIds, String token) {
        String staticPath = UFOPUtils.getStaticPath();
        String tempPath = staticPath + "temp" + File.separator;
        File tempDirFile = new File(tempPath);
        if (!tempDirFile.exists()) {
            tempDirFile.mkdirs();
        }

        FileOutputStream f = null;
        try {
            f = new FileOutputStream(tempPath + fileName + ".zip");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        CheckedOutputStream csum = new CheckedOutputStream(f, new Adler32());
        ZipOutputStream zos = new ZipOutputStream(csum);
        BufferedOutputStream out = new BufferedOutputStream(zos);

        try {
            for (String userFileId : userFileIds) {
                DocFilePath userFile1 = docFilePathMapper.selectById(userFileId);
                if (userFile1.getIsDir() == Constant.IS_NOT_DIR) {
                    DocFile fileBean = docFileMapper.selectById(userFile1.getFileId());
                    Downloader downloader = new LocalStorageDownloader();
                    if (downloader == null) {
                        log.error("下载失败，文件存储类型不支持下载，storageType:{}", fileBean.getStorageType());
                        throw new UploadException("下载失败");
                    }
                    DownloadFile downloadFile = new DownloadFile();
                    downloadFile.setFileUrl(fileBean.getFileUrl());
//                    String url = UFOPUtils.ENCRYPT_PATH + "/fileTransfer/encryptDownload";
//                    ResponseEntity<byte[]> responseEntity = restTemplate.exchange(url+"?userFileId=" + userFileId +"&userToken=" + token, HttpMethod.GET, null, byte[].class);
//                    byte[] data;
//                    if (responseEntity != null) {
//                        data=responseEntity.getBody();
//                    } else {
//                        data = new byte[0];
//                    }
//                    //byte[] data =responseEntity.getBody();
//                    InputStream inputStream = new ByteArrayInputStream(data);
                    InputStream inputStream = downloader.getInputStream(downloadFile);
                    BufferedInputStream bis = new BufferedInputStream(inputStream);
                    try {
                        QiwenFile qiwenFile = new QiwenFile(userFile1.getFilePath(), userFile1.getFileName() + "." + userFile1.getExtendName(), false);
                        zos.putNextEntry(new ZipEntry(qiwenFile.getPath().replaceFirst(filePath.replace("(","\\(").replace(")","\\)"), "")));

                        byte[] buffer = new byte[1024];
                        int i = bis.read(buffer);
                        while (i != -1) {
                            out.write(buffer, 0, i);
                            i = bis.read(buffer);
                        }
                    } catch (IOException e) {
                        log.error("" + e);
                        e.printStackTrace();
                    } finally {
                        IOUtils.closeQuietly(bis);
                        try {
                            out.flush();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                } else {
                    QiwenFile qiwenFile = new QiwenFile(userFile1.getFilePath(), userFile1.getFileName(), true);
                    // 空文件夹的处理
                    zos.putNextEntry(new ZipEntry(qiwenFile.getPath().replaceFirst(filePath.replace("(","\\(").replace(")","\\)"),"") + QiwenFile.separator));
                    // 没有文件，不需要文件的copy
                    zos.closeEntry();
                }
            }

        } catch (Exception e) {
            log.error("压缩过程中出现异常:"+ e);
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String zipPath = "";
        try {
            Downloader downloader = new LocalStorageDownloader();
            DownloadFile downloadFile = new DownloadFile();
            downloadFile.setFileUrl("temp" + File.separator + fileName + ".zip");
            File tempFile = new File(UFOPUtils.getStaticPath() + downloadFile.getFileUrl());
            httpServletResponse.setContentLengthLong(tempFile.length());
            downloader.download(httpServletResponse, downloadFile);
            zipPath = UFOPUtils.getStaticPath() + "temp" + File.separator + fileName + ".zip";
        } catch (Exception e) {
            //org.apache.catalina.connector.ClientAbortException: java.io.IOException: Connection reset by peer
            if (e.getMessage().contains("ClientAbortException")) {
                //该异常忽略不做处理
            } else {
                log.error("下传zip文件出现异常：{}", e.getMessage());
            }

        } finally {
            File file = new File(zipPath);
            if (file.exists()) {
                file.delete();
            }
        }
    }

    @Override
    public void previewFile(HttpServletResponse httpServletResponse, PreviewDTO previewDTO) {
        DocFilePath userFile = docFilePathMapper.selectById(previewDTO.getUserFileId());
        DocFile fileBean = docFileMapper.selectById(userFile.getFileId());
        Previewer previewer = new LocalStoragePreviewer(new ThumbImage(150,150));
        if (previewer == null) {
            log.error("预览失败，文件存储类型不支持预览，storageType:{}", fileBean.getStorageType());
            throw new UploadException("预览失败");
        }
        try {
            if ("true".equals(previewDTO.getIsMin())) {
                previewer.imageThumbnailPreview(httpServletResponse, fileBean.getFileUrl());
            } else {
                previewer.imageOriginalPreview(httpServletResponse, fileBean.getFileUrl());
            }
        } catch (Exception e){
                //org.apache.catalina.connector.ClientAbortException: java.io.IOException: 你的主机中的软件中止了一个已建立的连接。
                if (e.getMessage().contains("ClientAbortException")) {
                //该异常忽略不做处理
            } else {
                log.error("预览文件出现异常：{}", e.getMessage());
            }

        }

    }
//
//    @Override
//    public void previewPictureFile(HttpServletResponse httpServletResponse, PreviewDTO previewDTO) {
//        byte[] bytesUrl = Base64.getDecoder().decode(previewDTO.getUrl());
//        PictureFile pictureFile = new PictureFile();
//        pictureFile.setFileUrl(new String(bytesUrl));
//        pictureFile = pictureFileMapper.selectOne(new QueryWrapper<>(pictureFile));
//        Previewer previewer = ufopFactory.getPreviewer(pictureFile.getStorageType());
//        if (previewer == null) {
//            log.error("预览失败，文件存储类型不支持预览，storageType:{}", pictureFile.getStorageType());
//            throw new UploadException("预览失败");
//        }
//        PreviewFile previewFile = new PreviewFile();
//        previewFile.setFileUrl(pictureFile.getFileUrl());
////        previewFile.setFileSize(pictureFile.getFileSize());
//        try {
//
//            String mime= MimeUtils.getMime(pictureFile.getExtendName());
//            httpServletResponse.setHeader("Content-Type", mime);
//
//            String fileName = pictureFile.getFileName() + "." + pictureFile.getExtendName();
//            try {
//                fileName = new String(fileName.getBytes("utf-8"), "ISO-8859-1");
//            } catch (UnsupportedEncodingException e) {
//                e.printStackTrace();
//            }
//
//            httpServletResponse.addHeader("Content-Disposition", "fileName=" + fileName);// 设置文件名
//
//            previewer.imageOriginalPreview(httpServletResponse, previewFile);
//        } catch (Exception e){
//            //org.apache.catalina.connector.ClientAbortException: java.io.IOException: 你的主机中的软件中止了一个已建立的连接。
//            if (e.getMessage().contains("ClientAbortException")) {
//                //该异常忽略不做处理
//            } else {
//                log.error("预览文件出现异常：{}", e.getMessage());
//            }
//
//        }
//    }

    @Override
    public void deleteFile(DocFile fileBean) {
        Deleter deleter = null;

        deleter = new LocalStorageDeleter();
        DeleteFile deleteFile = new DeleteFile();
        deleteFile.setFileUrl(fileBean.getFileUrl());
        deleter.delete(deleteFile);
    }


//
//    @Override
//    public Long selectStorageSizeByUserId(Long userId){
//        return userFileMapper.selectStorageSizeByUserId(userId);
//    }
}