package com.casic.missiles.utils;

import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.lang.generator.SnowflakeGenerator;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.casic.missiles.enums.BusinessExceptionEnum;
import com.casic.missiles.exception.BusinessException;
import com.casic.missiles.mapper.system.SystemTemplateMapper;
import com.casic.missiles.model.system.SystemTemplate;
import io.minio.GetObjectArgs;
import io.minio.MinioClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.List;
import java.util.Optional;

/**
 * @Author: TuT
 * @CreateTime: 2024-04-11 15:55
 * @Description: TemplateUtils
 */
@Slf4j
@Component
public class TemplateUtils {
    @Autowired
    private MinioClient minioClient;
    @Value("${minio.bucketName}")
    private String bucketName;
    @Value("${casic.file.dir}")
    private String localFileDir;
    @Autowired
    private SystemTemplateMapper systemTemplateMapper;

    /**
     * 模板名称
     *
     * @param templateName 模板类型
     * @param templateType 文件服务器名称
     * @return String minioFileName
     */
    public String selectTemplateFileName(String templateName, String templateType) {
        LambdaQueryWrapper<SystemTemplate> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SystemTemplate::getTemplateName, templateName);
        queryWrapper.eq(SystemTemplate::getTemplateType, templateType);
        List<SystemTemplate> templateList = systemTemplateMapper.selectList(queryWrapper);
        Optional<SystemTemplate> systemTemplate = templateList.stream().findFirst();
        SystemTemplate template = systemTemplate.orElse(null);
        if (template.getMinioFileName() == null) {
            throw new BusinessException(BusinessExceptionEnum.MINIO_FILE_NAME_NOT_EXIST);
        }
        return template.getMinioFileName();
    }

    /**
     * @param fileName
     * @return
     */
    public String downloadTemplate(String fileName) {
        String fileUrl = localFileDir;
        Snowflake snowflake = new Snowflake(1, 1);
        String id = snowflake.nextIdStr();
        fileUrl = fileUrl + id + File.separator;
        File file = new File(fileUrl);
        if (file.exists()) {
            file.delete();
        }
        file.mkdirs();
        InputStream in = null;
        ByteArrayOutputStream out = null;
        try {
            in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
            out = new ByteArrayOutputStream();
            IOUtils.copy(in, out);
            //封装返回值
            byte[] bytes = out.toByteArray();
            this.byteToFile(bytes, fileUrl, fileName);
        } catch (Exception e) {
            log.error("download file failed", e);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    log.error("close inputStream failed", e);
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    log.error("close outputStream failed", e);
                }
            }
        }
        return fileUrl;
    }

    /**
     * @param bytes
     * @param localFileDir
     * @param fileName
     */
    private void byteToFile(byte[] bytes, String localFileDir, String fileName) {
        BufferedOutputStream bos = null;
        FileOutputStream fos = null;
        File file = null;
        try {
            File dir = new File(localFileDir);
            if (!dir.exists() && dir.isDirectory()) {
                dir.mkdirs();
            }
            file = new File(localFileDir + File.separator + fileName);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(bytes);
        } catch (Exception e) {
            log.error("Failed to save file '{}' to disk at '{}'. Exception:", fileName, localFileDir, e);
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    log.error("Failed to close BufferedOutputStream for file '{}'. Exception:", fileName, e);
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    log.error("Failed to close FileOutputStream for file '{}'. Exception:", fileName, e);
                }
            }
        }
    }

    public synchronized String downloadFile(List<String> fileNameList, String zipLocalFileDir) {
        String fileUrl = localFileDir + zipLocalFileDir;
        File file = new File(fileUrl);
        if (!file.exists()) {
            file.mkdirs();
        }
        if (CollectionUtils.isEmpty(fileNameList)) {
            return null;
        }
        InputStream in = null;
        ByteArrayOutputStream out = null;
        try {
            for (String fileName : fileNameList) {
                if (StringUtils.isNotBlank(fileName)) {
                    in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
                    out = new ByteArrayOutputStream();
                    IOUtils.copy(in, out);
                    //封装返回值
                    byte[] bytes = out.toByteArray();
                    byteToFile(bytes, fileUrl, fileName);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return fileUrl;
    }

    /**
     * @param file
     */
    public void deleteFile(File file) {
        //返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
        File[] files = file.listFiles();
        int length = files.length;
        if (files != null) {//如果包含文件进行删除操作
            for (int i = 0; i < length; i++) {
                if (files[i].isFile()) {
                    //删除子文件
                    files[i].delete();
                } else if (files[i].isDirectory()) {
                    //通过递归的方法找到子目录的文件
                    deleteFile(files[i]);
                }
            }
        }
        if (file.list().length == 0) {
            log.debug("invalid print file has already delete success!");
        }
        //删除子目录
        if (file != null && file.isDirectory()) {
            file.delete();
        }
    }
}