package com.estate.expert.admin.utils.wordtopdf;

import lombok.extern.slf4j.Slf4j;
import org.apache.poi.xwpf.usermodel.IBodyElement;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFFooter;
import org.apache.poi.xwpf.usermodel.XWPFHeader;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
import org.apache.poi.xwpf.usermodel.XWPFTable;
import org.apache.poi.xwpf.usermodel.XWPFTableCell;
import org.apache.poi.xwpf.usermodel.XWPFTableRow;
import org.jodconverter.core.office.OfficeException;
import org.jodconverter.core.office.OfficeManager;
import org.jodconverter.local.LocalConverter;
import org.jodconverter.local.office.LocalOfficeManager;

import javax.annotation.PreDestroy;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
public class WordToPdfConverter {

    private static final String LIBRE_OFFICE_PATH = "/usr/lib/libreoffice";
    private static final String DEFAULT_FALLBACK_FONT = "Noto Sans CJK SC";
    private static final Set<String> WINDOWS_CJK_FONTS = new LinkedHashSet<>(Arrays.asList(
            "\u5b8b\u4f53", "SimSun",
            "\u5fae\u8f6f\u96c5\u9ed1", "Microsoft YaHei",
            "\u9ed1\u4f53", "SimHei",
            "\u4eff\u5b8b", "FangSong",
            "\u6977\u4f53", "KaiTi",
            "\u65b0\u5b8b\u4f53", "NSimSun",
            "\u7b49\u7ebf", "DengXian"
    ));
    private static final List<String> SUPPORTED_EXTENSIONS = Arrays.asList(
            ".doc", ".docx", ".rtf", ".txt", ".odt"
    );

    private static WordToPdfConverter instance;

    private final AtomicInteger conversionCount = new AtomicInteger(0);
    private OfficeManager officeManager;

    private WordToPdfConverter() {
        initializeOfficeManager();
    }

    public static synchronized WordToPdfConverter getInstance() {
        if (instance == null) {
            instance = new WordToPdfConverter();
        }
        return instance;
    }

    private void initializeOfficeManager() {
        try {
            log.info("Initializing LibreOffice manager");

            File officeHome = new File(LIBRE_OFFICE_PATH);
            if (!officeHome.exists() || !officeHome.isDirectory()) {
                throw new RuntimeException("LibreOffice home not found: " + LIBRE_OFFICE_PATH);
            }

            officeManager = LocalOfficeManager.builder()
                    .officeHome(officeHome)
                    .portNumbers(2002)
                    .processTimeout(300000L)
                    .taskExecutionTimeout(300000L)
                    .maxTasksPerProcess(20)
                    .install()
                    .build();

            officeManager.start();
            log.info("LibreOffice manager started on port 2002");
        } catch (Exception e) {
            log.error("Failed to initialize LibreOffice manager", e);
            throw new RuntimeException("Unable to start LibreOffice service: " + e.getMessage(), e);
        }
    }

    public boolean convert(String wordFilePath, String pdfFilePath) {
        return convert(new File(wordFilePath), new File(pdfFilePath));
    }

    public boolean convert(File wordFile, File pdfFile) {
        long startTime = System.currentTimeMillis();
        int currentCount = conversionCount.incrementAndGet();
        File conversionSource = wordFile;

        try {
            validateInputFile(wordFile);
            prepareOutputDirectory(pdfFile);
            conversionSource = prepareConversionSource(wordFile);

            log.info("Start conversion [{}]: {} -> {}", currentCount, wordFile.getName(), pdfFile.getName());

            LocalConverter.builder()
                    .officeManager(officeManager)
                    .build()
                    .convert(conversionSource)
                    .to(pdfFile)
                    .execute();

            boolean success = validateOutputFile(pdfFile);
            long costTime = System.currentTimeMillis() - startTime;
            if (success) {
                log.info("Conversion succeeded [{}]: {} -> {} ({} ms)",
                        currentCount, wordFile.getName(), pdfFile.getName(), costTime);
            } else {
                log.warn("Conversion finished with invalid output [{}]: {} ({} ms)",
                        currentCount, wordFile.getName(), costTime);
            }
            return success;
        } catch (Exception e) {
            log.error("Conversion failed [{}]: {}", currentCount, wordFile.getName(), e.getMessage(), e);
            return false;
        } finally {
            cleanupTemporarySource(wordFile, conversionSource);
        }
    }

    private File prepareConversionSource(File wordFile) {
        if (!shouldNormalizeDocxFonts(wordFile)) {
            return wordFile;
        }

        try {
            return normalizeDocxFonts(wordFile);
        } catch (Exception e) {
            log.warn("Docx font normalization failed, fallback to original file: {}", wordFile.getAbsolutePath(), e);
            return wordFile;
        }
    }

    private boolean shouldNormalizeDocxFonts(File wordFile) {
        return isLinux() && wordFile.getName().toLowerCase(Locale.ROOT).endsWith(".docx");
    }

    private boolean isLinux() {
        return System.getProperty("os.name", "").toLowerCase(Locale.ROOT).contains("linux");
    }

    private File normalizeDocxFonts(File sourceFile) throws IOException {
        Path tempFile = Files.createTempFile("estate-word-font-normalized-", ".docx");
        String fallbackFont = resolveFallbackFont();
        int replacedRuns = 0;

        try (InputStream inputStream = Files.newInputStream(sourceFile.toPath());
             XWPFDocument document = new XWPFDocument(inputStream);
             OutputStream outputStream = Files.newOutputStream(tempFile)) {
            replacedRuns += normalizeParagraphs(document.getParagraphs(), fallbackFont);
            replacedRuns += normalizeTables(document.getTables(), fallbackFont);

            for (XWPFHeader header : document.getHeaderList()) {
                replacedRuns += normalizeParagraphs(header.getParagraphs(), fallbackFont);
                replacedRuns += normalizeTables(header.getTables(), fallbackFont);
            }

            for (XWPFFooter footer : document.getFooterList()) {
                replacedRuns += normalizeParagraphs(footer.getParagraphs(), fallbackFont);
                replacedRuns += normalizeTables(footer.getTables(), fallbackFont);
            }

            document.write(outputStream);
        }

        log.info("Docx font normalization finished, fallbackFont={}, replacedRuns={}, source={}, temp={}",
                fallbackFont, replacedRuns, sourceFile.getAbsolutePath(), tempFile);
        return tempFile.toFile();
    }

    private int normalizeParagraphs(List<XWPFParagraph> paragraphs, String fallbackFont) {
        int replacedRuns = 0;
        for (XWPFParagraph paragraph : paragraphs) {
            replacedRuns += normalizeParagraph(paragraph, fallbackFont);
        }
        return replacedRuns;
    }

    private int normalizeParagraph(XWPFParagraph paragraph, String fallbackFont) {
        int replacedRuns = 0;
        for (XWPFRun run : paragraph.getRuns()) {
            if (normalizeRunFont(run, fallbackFont)) {
                replacedRuns++;
            }
        }
        return replacedRuns;
    }

    private int normalizeTables(List<XWPFTable> tables, String fallbackFont) {
        int replacedRuns = 0;
        for (XWPFTable table : tables) {
            for (XWPFTableRow row : table.getRows()) {
                for (XWPFTableCell cell : row.getTableCells()) {
                    replacedRuns += normalizeBodyElements(cell.getBodyElements(), fallbackFont);
                }
            }
        }
        return replacedRuns;
    }

    private int normalizeBodyElements(List<IBodyElement> bodyElements, String fallbackFont) {
        int replacedRuns = 0;
        for (IBodyElement bodyElement : bodyElements) {
            if (bodyElement instanceof XWPFParagraph paragraph) {
                replacedRuns += normalizeParagraph(paragraph, fallbackFont);
            } else if (bodyElement instanceof XWPFTable table) {
                replacedRuns += normalizeTables(List.of(table), fallbackFont);
            }
        }
        return replacedRuns;
    }

    private boolean normalizeRunFont(XWPFRun run, String fallbackFont) {
        boolean shouldReplace = shouldReplaceFont(run.getFontFamily())
                || shouldReplaceFont(run.getFontFamily(XWPFRun.FontCharRange.ascii))
                || shouldReplaceFont(run.getFontFamily(XWPFRun.FontCharRange.cs))
                || shouldReplaceFont(run.getFontFamily(XWPFRun.FontCharRange.eastAsia))
                || shouldReplaceFont(run.getFontFamily(XWPFRun.FontCharRange.hAnsi));

        if (!shouldReplace) {
            return false;
        }

        run.setFontFamily(fallbackFont);
        run.setFontFamily(fallbackFont, XWPFRun.FontCharRange.ascii);
        run.setFontFamily(fallbackFont, XWPFRun.FontCharRange.cs);
        run.setFontFamily(fallbackFont, XWPFRun.FontCharRange.eastAsia);
        run.setFontFamily(fallbackFont, XWPFRun.FontCharRange.hAnsi);
        return true;
    }

    private boolean shouldReplaceFont(String fontName) {
        return fontName != null && WINDOWS_CJK_FONTS.contains(fontName.trim());
    }

    private String resolveFallbackFont() {
        String systemProperty = System.getProperty("estate.word.pdf.font");
        if (systemProperty != null && !systemProperty.isBlank()) {
            return systemProperty.trim();
        }

        String environmentValue = System.getenv("ESTATE_WORD_PDF_FONT");
        if (environmentValue != null && !environmentValue.isBlank()) {
            return environmentValue.trim();
        }

        return DEFAULT_FALLBACK_FONT;
    }

    private void cleanupTemporarySource(File originalFile, File conversionSource) {
        if (conversionSource == null || conversionSource.equals(originalFile)) {
            return;
        }

        try {
            Files.deleteIfExists(conversionSource.toPath());
        } catch (IOException e) {
            log.warn("Failed to delete temporary docx: {}", conversionSource.getAbsolutePath(), e);
        }
    }

    private void validateInputFile(File wordFile) {
        if (wordFile == null) {
            throw new IllegalArgumentException("Input file must not be null");
        }

        if (!wordFile.exists()) {
            throw new IllegalArgumentException("Input file does not exist: " + wordFile.getAbsolutePath());
        }

        if (!wordFile.isFile()) {
            throw new IllegalArgumentException("Input path is not a file: " + wordFile.getAbsolutePath());
        }

        String fileName = wordFile.getName().toLowerCase(Locale.ROOT);
        boolean supported = SUPPORTED_EXTENSIONS.stream().anyMatch(fileName::endsWith);
        if (!supported) {
            throw new IllegalArgumentException("Unsupported file type: " + fileName + ", supported: " + SUPPORTED_EXTENSIONS);
        }

        long fileSize = wordFile.length();
        long maxSize = 1000L * 1024L * 1024L;
        if (fileSize > maxSize) {
            throw new IllegalArgumentException("File is too large: " + (fileSize / 1024 / 1024) + "MB, max is 1000MB");
        }
    }

    private void prepareOutputDirectory(File pdfFile) {
        File parentDir = pdfFile.getParentFile();
        if (parentDir != null && !parentDir.exists() && !parentDir.mkdirs()) {
            throw new RuntimeException("Unable to create output directory: " + parentDir.getAbsolutePath());
        }
    }

    private boolean validateOutputFile(File pdfFile) {
        if (!pdfFile.exists()) {
            log.error("Output file was not created: {}", pdfFile.getAbsolutePath());
            return false;
        }

        if (pdfFile.length() == 0) {
            log.error("Output file is empty: {}", pdfFile.getAbsolutePath());
            return false;
        }

        try (FileInputStream inputStream = new FileInputStream(pdfFile)) {
            byte[] header = new byte[4];
            int read = inputStream.read(header);
            if (read >= 4) {
                boolean isPdf = header[0] == '%'
                        && header[1] == 'P'
                        && header[2] == 'D'
                        && header[3] == 'F';
                if (!isPdf) {
                    log.warn("Output file is not a valid pdf: {}", pdfFile.getAbsolutePath());
                }
                return isPdf;
            }
        } catch (Exception e) {
            log.warn("Failed to validate pdf header", e);
        }

        return true;
    }

    public int batchConvert(List<File> wordFiles, File outputDir) {
        if (!outputDir.exists() && !outputDir.mkdirs()) {
            throw new RuntimeException("Unable to create batch output directory: " + outputDir.getAbsolutePath());
        }

        int successCount = 0;
        for (int i = 0; i < wordFiles.size(); i++) {
            File wordFile = wordFiles.get(i);
            try {
                String baseName = getFileBaseName(wordFile);
                File pdfFile = new File(outputDir, baseName + ".pdf");
                log.info("Batch conversion progress: {}/{} - {}", i + 1, wordFiles.size(), wordFile.getName());
                if (convert(wordFile, pdfFile)) {
                    successCount++;
                }
            } catch (Exception e) {
                log.error("Batch conversion failed: {}", wordFile.getName(), e);
            }
        }

        log.info("Batch conversion finished: {}/{}", successCount, wordFiles.size());
        return successCount;
    }

    private String getFileBaseName(File file) {
        String name = file.getName();
        int dotIndex = name.lastIndexOf('.');
        return dotIndex == -1 ? name : name.substring(0, dotIndex);
    }

    public int getConversionCount() {
        return conversionCount.get();
    }

    public void restart() {
        log.info("Restarting LibreOffice service");
        shutdown();
        initializeOfficeManager();
        log.info("LibreOffice service restarted");
    }

    @PreDestroy
    public void shutdown() {
        if (officeManager != null && officeManager.isRunning()) {
            try {
                officeManager.stop();
                log.info("LibreOffice service stopped");
            } catch (OfficeException e) {
                log.error("Failed to stop LibreOffice service", e);
            }
        }
    }

    public boolean isServiceRunning() {
        return officeManager != null && officeManager.isRunning();
    }
}