package com.smartor.service.impl;

import cn.hutool.core.io.FileUtil;
import com.ruoyi.common.config.MinioConfig;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.MinioClientUtils;
import com.ruoyi.common.utils.StringUtils;
import com.smartor.domain.MinioFile;
import com.smartor.domain.MinioResponseDTO;
import com.smartor.domain.TreeNode;
import com.smartor.mapper.MinioFileMapper;
import com.smartor.service.IMinioFileService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.time.Instant;
import java.time.Year;
import java.util.ArrayList;
import java.util.List;

/**
 * 【请填写功能名称】Service业务层处理
 *
 * @author ruoyi
 * @date 2023-06-19
 */
@Slf4j
@Service
public class MinioFileServiceImpl implements IMinioFileService {
    @Autowired
    private MinioFileMapper minioFileMapper;

    @Resource
    private MinioClientUtils minioClientUtils;
    @Resource
    private MinioConfig minioConfig;

    /**
     * 查询【请填写功能名称】
     *
     * @param id 【请填写功能名称】主键
     * @return 【请填写功能名称】
     */
    @Override
    public MinioFile selectMinioFileById(Long id) {
        return minioFileMapper.selectMinioFileById(id);
    }

    /**
     * 查询【请填写功能名称】列表
     *
     * @param minioFile 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<MinioFile> selectMinioFileList(MinioFile minioFile) {
        return minioFileMapper.selectMinioFileList(minioFile);
    }

    /**
     * 新增【请填写功能名称】
     *
     * @param minioFile 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int insertMinioFile(MinioFile minioFile) {
        minioFile.setCreateTime(DateUtils.getNowDate());
        return minioFileMapper.insertMinioFile(minioFile);
    }

    /**
     * 修改【请填写功能名称】
     *
     * @param minioFile 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int updateMinioFile(MinioFile minioFile) {
        minioFile.setUpdateTime(DateUtils.getNowDate());
        return minioFileMapper.updateMinioFile(minioFile);
    }

    /**
     * 批量删除【请填写功能名称】
     *
     * @param ids 需要删除的【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteMinioFileByIds(Long[] ids) {
        return minioFileMapper.deleteMinioFileByIds(ids);
    }

    /**
     * 删除【请填写功能名称】信息
     *
     * @param id 【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteMinioFileById(Long id) {
        return minioFileMapper.deleteMinioFileById(id);
    }

    @Override
    public List<MinioResponseDTO> commonUploadFile(String path, List<MultipartFile> files) {
        log.info(files.toString());
        if (StringUtils.isNotEmpty(path) && !path.endsWith("/")) {
            path = path + "/";
        } else {
            path = Year.now().getValue() + "其它/";
        }

        List<MinioResponseDTO> MinioResponseDTOList = new ArrayList<>();
        for (MultipartFile file : files) {
            String originalFilename = file.getOriginalFilename();
//            获取文件拓展名
            String extName = FileUtil.extName(originalFilename);
            log.info("文件拓展名:" + extName);
//            生成新的文件名，存入到minio
            long millSeconds = Instant.now().toEpochMilli();
            String minioFileName = millSeconds + RandomStringUtils.randomNumeric(12) + "." + extName;
            String contentType = file.getContentType();
            log.info("文件mime:{}", contentType);
//            返回文件大小,单位字节
            long size = file.getSize();
            log.info("文件大小：" + size);
            try {
                String bucketName = minioConfig.getBucketName();
                minioClientUtils.putObject(bucketName, file, path + originalFilename);
//                String fileUrl = minioClientUtils.getObjectUrl(bucketName, path + originalFilename);
                // String fileUrl = path + originalFilename;
                //url可以使用一周
                String fileUrl = getFileUrl(path + originalFilename, 6);
                MinioFile minioFile = new MinioFile();
                minioFile.setOriginalFileName(originalFilename);
                minioFile.setFileExtName(extName);
                minioFile.setFileName(originalFilename);
                minioFile.setFileSize(size);
                minioFile.setMime(contentType);
                minioFile.setIsDelete(NumberUtils.INTEGER_ZERO);
                minioFile.setFileUrl(fileUrl);
                int i = insertMinioFile(minioFile);
                if (i > 0) {
                    MinioResponseDTO minioResponseDTO = new MinioResponseDTO();
                    minioResponseDTO.setFileId(minioFile.getId());
                    minioResponseDTO.setOriginalFileName(originalFilename);
                    minioResponseDTO.setFileUrl(fileUrl);
                    MinioResponseDTOList.add(minioResponseDTO);
                }


            } catch (Exception e) {
                log.error("上传文件出错:{}", e);

            }
        }
        return MinioResponseDTOList;
    }

    @Override
    public TreeNode getEduTemplage() {
        List<MinioFile> minioFiles = minioFileMapper.selectMinioFileList(null);

        TreeNode root = new TreeNode("");
        // 使用递归将列表转成树开结构
        for (MinioFile minioFile1 : minioFiles) {
            String[] parts = minioFile1.getFileUrl().split("/");
            TreeNode current = root;
            for (String part : parts) {
                if (!part.isEmpty()) {
                    TreeNode child = findChild(current, part);
                    if (child == null) {
                        child = new TreeNode(part);
                        current.addChild(child);
                    }
                    current = child;
                }
            }
        }
        return root;
    }

    @Override
    public void downloadFile(HttpServletResponse response, String fileName) {
        InputStream object = null;
        try {
            object = minioClientUtils.getObject(minioConfig.getBucketName(), fileName);
            writeFile(response, object);
        } catch (Exception e) {
            log.info("文件下载，报错了！！！{}", fileName);
            e.printStackTrace();
        }
    }

    @Override
    public String getFileUrl(String fileName, Integer expires) {
        String presignedObjectUrl = null;
        try {
            presignedObjectUrl = minioClientUtils.getPresignedObjectUrl(minioConfig.getBucketName(), fileName, expires);
            //去掉url里?后面的请求信息
            presignedObjectUrl = presignedObjectUrl.substring(0, presignedObjectUrl.lastIndexOf("?"));
        } catch (Exception e) {
            log.info("文件下载，报错了！！！{},  {}", fileName, expires);
            e.printStackTrace();
        }
        return presignedObjectUrl;
    }

    private TreeNode findChild(TreeNode parent, String name) {
        for (TreeNode child : parent.getChildren()) {
            if (child.getName().equals(name)) {
                return child;
            }
        }
        return null;
    }

    public void writeFile(HttpServletResponse resp, InputStream inputStream) {
        OutputStream out = null;
        try {
            out = resp.getOutputStream();
            int len = 0;
            byte[] b = new byte[1024];
            while ((len = inputStream.read(b)) != -1) {
                out.write(b, 0, len);
            }
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}