package com.ots.project.tool;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.MessageFormat;
import java.util.concurrent.TimeUnit;

/**
 * Docker转化pdf专用处理工具
 * 使用单例模式实现
 */
@Slf4j
public class PdfDockerUtil {
    
    /**
     * 单例实例
     */
    private static volatile PdfDockerUtil instance;
    
    /**
     * 容器名称前缀
     */
    private static final String CONTAINER_NAME_PREFIX = "pdf_converter_";
    
    /**
     * 文件锁路径
     */
    private static final String LOCK_FILE_PATH = System.getProperty("java.io.tmpdir") + "/pdf_docker_lock";
    
    /**
     * 任务超时时间（秒）
     */
    private static final int TASK_TIMEOUT_SECONDS = 60; // 1分钟
    
    /**
     * 私有构造函数，防止外部实例化
     */
    private PdfDockerUtil() {
        // 私有构造函数
    }
    
    /**
     * 获取单例实例
     * 使用双重检查锁定确保线程安全
     * @return PdfDockerUtil实例
     */
    public static PdfDockerUtil getInstance() {
        if (instance == null) {
            synchronized (PdfDockerUtil.class) {
                if (instance == null) {
                    instance = new PdfDockerUtil();
                }
            }
        }
        return instance;
    }
    
    /**
     * docker word转pdf
     * @param profile 配置文件路径
     * @param docx2pdfPath docker命令模板路径
     * @param fileName 文件名
     */
    public void dockerConvertPDF(String profile, String docx2pdfPath, String fileName) {
        FileLock lock = null;
        Process proc = null;
        
        try {
            // 1. 获取文件锁，确保串行执行
            lock = acquireFileLock();
            if (lock == null) {
                log.error("无法获取文件锁，可能有其他转换任务正在执行");
                return;
            }
            
            // 2. 生成唯一容器名称
            String containerName = CONTAINER_NAME_PREFIX + System.currentTimeMillis();
            
            // 3. 轻量级清理旧容器（可选，如果不需要可以注释掉）
            cleanupOldContainers();
            
            // 4. 构建Docker命令（确保包含容器名称）
            String command = buildDockerCommand(docx2pdfPath, profile, fileName, containerName);
            log.info("docker执行命令:{}", command);
            
            // 5. 执行Docker命令（带超时）
            proc = Runtime.getRuntime().exec(command);
            
            // 6. 异步读取输出流
            ProcessOutputReader outputReader = new ProcessOutputReader(proc.getInputStream(), "STDOUT");
            ProcessOutputReader errorReader = new ProcessOutputReader(proc.getErrorStream(), "STDERR");
            
            outputReader.start();
            errorReader.start();
            
            // 7. 等待进程完成（带超时）
            boolean completed = proc.waitFor(TASK_TIMEOUT_SECONDS, TimeUnit.SECONDS);
            
            if (!completed) {
                log.error("Docker任务执行超时（{}秒），强制终止进程", TASK_TIMEOUT_SECONDS);
                forceKillProcess(proc);
                return;
            }
            
            int exitCode = proc.exitValue();
            log.info("Docker进程退出码: {}", exitCode);
            
            // 8. 等待输出读取完成
            outputReader.join(5000);
            errorReader.join(5000);
            
            if (exitCode != 0) {
                log.error("Docker命令执行失败，退出码: {}", exitCode);
            } else {
                log.info("Docker命令执行成功");
            }
            
        } catch (Exception e) {
            log.error("Docker转换PDF失败", e);
        } finally {
            // 9. 清理资源
            cleanupResources(proc, lock);
        }
    }
    
    /**
     * 构建Docker命令，确保包含容器名称
     * @param docx2pdfPath docker命令模板路径
     * @param profile 配置文件路径
     * @param fileName 文件名
     * @param containerName 容器名称
     * @return 完整的Docker命令
     */
    private String buildDockerCommand(String docx2pdfPath, String profile, String fileName, String containerName) {
        // 如果命令模板中已经包含 --name 参数，则直接使用
        if (docx2pdfPath.contains("--name")) {
            return MessageFormat.format(docx2pdfPath, profile, fileName);
        }
        
        // 如果命令模板中没有 --name 参数，则添加容器名称
        // 假设命令模板格式为: docker run [其他参数] image_name
        // 我们需要在 docker run 后添加 --name 参数
        
        String baseCommand = MessageFormat.format(docx2pdfPath, profile, fileName);
        
        // 检查是否包含 docker run
        if (baseCommand.contains("docker run")) {
            // 在 docker run 后插入 --name 参数
            String[] parts = baseCommand.split("docker run", 2);
            if (parts.length == 2) {
                return "docker run --name " + containerName + parts[1];
            }
        }
        
        // 如果无法解析，则直接返回原命令
        log.warn("无法解析Docker命令模板，使用原始命令: {}", baseCommand);
        return baseCommand;
    }
    
    /**
     * 获取文件锁
     */
    private FileLock acquireFileLock() {
        FileChannel channel = null;
        try {
            Path lockPath = Paths.get(LOCK_FILE_PATH);
            Files.createDirectories(lockPath.getParent());
            
            if (!Files.exists(lockPath)) {
                Files.createFile(lockPath);
            }
            
            channel = new RandomAccessFile(lockPath.toFile(), "rw").getChannel();
            FileLock lock = channel.tryLock();
            
            if (lock != null) {
                log.info("成功获取文件锁");
                return lock;
            } else {
                log.warn("文件锁被占用，无法获取");
                if (channel != null) {
                    channel.close();
                }
                return null;
            }
        } catch (Exception e) {
            log.error("获取文件锁失败", e);
            if (channel != null) {
                try {
                    channel.close();
                } catch (IOException ex) {
                    log.error("关闭文件通道失败", ex);
                }
            }
            return null;
        }
    }
    
    /**
     * 清理旧容器（轻量级版本）
     */
    private void cleanupOldContainers() {
        try {
            // 只清理停止状态的容器，不干扰运行中的容器
            String findCommand = "docker ps -a --filter name=" + CONTAINER_NAME_PREFIX + "* --filter status=exited --format '{{.Names}}'";
            Process findProc = Runtime.getRuntime().exec(findCommand);
            
            BufferedReader reader = new BufferedReader(new InputStreamReader(findProc.getInputStream()));
            String containerName;
            boolean hasCleaned = false;
            
            while ((containerName = reader.readLine()) != null) {
                if (!containerName.trim().isEmpty()) {
                    log.info("清理已停止的旧容器: {}", containerName);
                    
                    // 删除已停止的容器
                    String rmCommand = "docker rm " + containerName;
                    Runtime.getRuntime().exec(rmCommand);
                    hasCleaned = true;
                }
            }
            
            reader.close();
            findProc.waitFor(5, TimeUnit.SECONDS);
            
            if (!hasCleaned) {
                log.debug("没有发现需要清理的旧容器");
            }
            
        } catch (Exception e) {
            log.warn("清理旧容器时出现异常", e);
        }
    }
    
    /**
     * 强制终止进程并销毁相关容器
     */
    private void forceKillProcess(Process proc) {
        try {
            if (proc != null) {
                proc.destroy();
                
                // 等待进程终止
                if (!proc.waitFor(5, TimeUnit.SECONDS)) {
                    proc.destroyForcibly();
                    log.warn("强制终止进程");
                }
            }
            
            // 强制清理所有相关容器
            forceCleanupContainers();
            
        } catch (Exception e) {
            log.error("强制终止进程失败", e);
        }
    }
    
    /**
     * 强制清理所有相关容器
     */
    private void forceCleanupContainers() {
        try {
            log.info("开始强制清理相关容器...");
            
            // 清理带有特定前缀的容器
            cleanupContainersByPrefix();
            
            // 清理可能残留的headless-wps容器（基于镜像名称）
            cleanupContainersByImage("headless-wps-example");
            
            log.info("容器强制清理完成");
            
        } catch (Exception e) {
            log.error("强制清理容器失败", e);
        }
    }
    
    /**
     * 根据前缀清理容器
     */
    private void cleanupContainersByPrefix() {
        cleanupContainersByFilter("name=" + CONTAINER_NAME_PREFIX + "*", "前缀");
    }
    
    /**
     * 根据镜像名称清理容器
     */
    private void cleanupContainersByImage(String imageName) {
        cleanupContainersByFilter("ancestor=" + imageName, "镜像 " + imageName);
    }
    
    /**
     * 通用的容器清理方法
     * @param filter 过滤条件，如 name=prefix*" 或 "ancestor=imageName"
     * @param filterDesc 过滤条件描述，用于日志输出
     */
    private void cleanupContainersByFilter(String filter, String filterDesc) {
        try {
            log.info("清理{}容器", filterDesc);
            
            // 查找所有运行中的相关容器
            String runningCommand = "docker ps --filter " + filter + " --format '{{.Names}}'";
            Process runningProc = Runtime.getRuntime().exec(runningCommand);
            BufferedReader runningReader = new BufferedReader(new InputStreamReader(runningProc.getInputStream()));
            
            String containerName;
            while ((containerName = runningReader.readLine()) != null) {
                if (!containerName.trim().isEmpty()) {
                    log.warn("强制停止运行中的容器: {}", containerName);
                    
                    // 强制停止容器
                    String killCommand = "docker kill " + containerName;
                    Process killProc = Runtime.getRuntime().exec(killCommand);
                    killProc.waitFor(10, TimeUnit.SECONDS);
                    
                    // 强制删除容器
                    String rmCommand = "docker rm -f " + containerName;
                    log.info("执行命令: {}", rmCommand);

                    Process rmProc = Runtime.getRuntime().exec(rmCommand);
                    rmProc.waitFor(10, TimeUnit.SECONDS);
                    
                    log.info("已强制清理容器: {}", containerName);
                }
            }
            runningReader.close();
            runningProc.waitFor(10, TimeUnit.SECONDS);
            
            // 查找所有停止的相关容器并删除
            String stoppedCommand = "docker ps -a --filter " + filter + " --format '{{.Names}}'";
            Process stoppedProc = Runtime.getRuntime().exec(stoppedCommand);
            BufferedReader stoppedReader = new BufferedReader(new InputStreamReader(stoppedProc.getInputStream()));
            
            while ((containerName = stoppedReader.readLine()) != null) {
                if (!containerName.trim().isEmpty()) {
                    log.warn("强制删除停止的容器: {}", containerName);
                    
                    // 强制删除容器
                    String rmCommand = "docker rm -f " + containerName;
                    log.info("执行命令: {}", rmCommand);
                    Process rmProc = Runtime.getRuntime().exec(rmCommand);
                    rmProc.waitFor(10, TimeUnit.SECONDS);
                    
                    log.info("已强制删除容器: {}", containerName);
                }
            }
            stoppedReader.close();
            stoppedProc.waitFor(10, TimeUnit.SECONDS);
            
        } catch (Exception e) {
            log.error("根据{}清理容器失败", filterDesc, e);
        }
    }
    
    /**
     * 清理资源
     */
    private void cleanupResources(Process proc, FileLock lock) {
        try {
            if (proc != null) {
                forceKillProcess(proc);
            }
            
            if (lock != null) {
                lock.release();
                log.info("释放文件锁");
            }
        } catch (Exception e) {
            log.error("清理资源失败", e);
        }
    }
    
    /**
     * 进程输出读取器
     */
    private static class ProcessOutputReader extends Thread {
        private final BufferedReader reader;
        private final String streamType;
        
        public ProcessOutputReader(InputStream inputStream, String streamType) {
            this.reader = new BufferedReader(new InputStreamReader(inputStream, java.nio.charset.StandardCharsets.UTF_8));
            this.streamType = streamType;
        }
        
        @Override
        public void run() {
            try {
                String line;
                log.info("=== Docker {} ===", streamType);
                while ((line = reader.readLine()) != null) {
                    if ("STDERR".equals(streamType)) {
                        log.error("{}: {}", streamType, line);
                    } else {
                        log.info("{}: {}", streamType, line);
                    }
                }
            } catch (IOException e) {
                log.error("读取{}流失败", streamType, e);
            } finally {
                try {
                    reader.close();
                } catch (IOException e) {
                    log.error("关闭{}流失败", streamType, e);
                }
            }
        }
    }
    
    /**
     * 静态方法调用，方便使用
     * @param profile 配置文件路径
     * @param docx2pdfPath docker命令模板路径
     * @param fileName 文件名
     * 方式1：通过静态方法调用（推荐）
     * PdfDockerUtil.convertPDF(profile, docx2pdfPath, fileName);
     * 方式2：通过实例方法调用
     * PdfDockerUtil pdfDockerUtil = PdfDockerUtil.getInstance();
     * pdfDockerUtil.convertPDF(profile, docx2pdfPath, fileName);
     */
    public static void convertPDF(String profile, String docx2pdfPath, String fileName) {
        getInstance().dockerConvertPDF(profile, docx2pdfPath, fileName);
    }
}