package com.acumenvelocity.ath.pagematcher;
   
   import java.io.File;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.nio.file.Files;
   import java.nio.file.Path;
   import java.nio.file.StandardCopyOption;
   import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.Callable;
  import java.util.concurrent.CopyOnWriteArrayList;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.Future;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.pdfbox.Loader;
  import org.apache.pdfbox.pdmodel.PDDocument;
  import org.jodconverter.core.document.DefaultDocumentFormatRegistry;
  import org.jodconverter.core.document.DocumentFormat;
  import org.jodconverter.local.LocalConverter;
  import org.jodconverter.local.office.LocalOfficeManager;
  
  import com.acumenvelocity.ath.common.AthUtil;
  import com.acumenvelocity.ath.common.Log;
  import com.acumenvelocity.ath.common.exception.AthRuntimeException;
  import com.acumenvelocity.ath.filters.pdf.AthPdfFilter;
  
  import net.sf.okapi.common.StreamUtil;
  import net.sf.okapi.common.filters.IFilter;
  import net.sf.okapi.filters.openxml.OpenXMLFilter;
  
  public class DocxPageMatcher {
  
    private static final DocumentFormat PDF = DefaultDocumentFormatRegistry.PDF;
    private static final DocumentFormat DOCX = DefaultDocumentFormatRegistry.DOCX;
  
    private static final Pattern FONT_SIZE_PATTERN = Pattern.compile(
        "(<w:(?:sz|szCs)\\b[^>]*\\sw:val=\")(\\d+)(\")");
  
    private static final int NUM_PARALLEL_THREADS = 3;
    private static final int DELTAS_PER_SET = 3;
    private static final int MAX_SETS = 4; // Max delta = -12
  
    private static LocalOfficeManager officeManager;
  
    private static class AdjustmentResult {
      final File docxFile;
      final int pageCount;
      final double delta;
      final File pdfFile;
  
      AdjustmentResult(File docxFile, int pageCount, double delta, File pdfFile) {
        this.docxFile = docxFile;
        this.pageCount = pageCount;
        this.delta = delta;
        this.pdfFile = pdfFile;
      }
    }
  
    public static void init() throws Exception {
      Log.info(DocxPageMatcher.class, "Initializing LibreOffice manager...");
  
      System.setProperty("user.installation", "file:///app/lo-profile");
  
      officeManager = LocalOfficeManager.builder()
          .officeHome("/usr/lib/libreoffice")
          .workingDir(new File("/app/lo-profile"))
          .portNumbers(2002, 2003, 2004)
          .maxTasksPerProcess(50)
          .taskExecutionTimeout(60000L)
          .processTimeout(120000L)
          .build();
  
      officeManager.start();
      Log.info(DocxPageMatcher.class, "LibreOffice manager started successfully with 3 instances");
    }
  
    public static void done() throws Exception {
      if (officeManager != null) {
        officeManager.stop();
      }
    }
  
    /**
     * Matches page count and returns the final PDF file (always PDF).
     * 
     * @param originalStream  - the original document stream (PDF)
     * @param translationDocx - the translated DOCX file to be adjusted
     * @return File - PDF file with matched page count (caller is responsible for cleanup)
     */
    @SuppressWarnings("unused")
    public static File matchPageCount(InputStream originalStream, File translationDocx)
        throws Exception {
 
     File originalPdf = null;
     File translationPdf = null;
 
     try {
       originalPdf = AthUtil.createTempFile(".pdf");
       StreamUtil.copy(originalStream, originalPdf);
       int originalPageCount = getPdfPageCount(originalPdf);
 
       // Adobe PDF Services insert manual page breaks in the converted DOCX, so we count target
       // pages by parsing the translated DOCX file
       int translationPageCount = getDocxPageCount(translationDocx, true);
 
       translationPdf = AthUtil.createTempFile(".pdf");
       convertDocxToPdf(translationDocx, translationPdf);
 
       return translationPdf;
 
     } catch (Exception e) {
       AthUtil.deleteFile(translationPdf);
       AthRuntimeException.logAndThrow(DocxPageMatcher.class, e,
           "Cannot adjust page count in translation");
 
     } finally {
       AthUtil.deleteFile(originalPdf);
     }
 
     return null;
   }
 
   /**
    * Matches page count and returns the PDF or DOCX final translation file.
    * 
    * @param originalStream - the original document stream (PDF or DOCX)
    * @param translation    - the translated DOCX file to be adjusted
    * @param filter         - the filter type (OpenXMLFilter or AthPdfFilter)
    * @return File - PDF/DOCX file with matched page count (caller is responsible for cleanup)
    */
   public static File matchPageCount(InputStream originalStream, File translation,
       IFilter filter) throws Exception {
 
     File originalPdf = null;
     File translationPdf = null;
 
     int originalPageCount = 0;
     int translationPageCount = 0;
 
     List<File> tempPdfs = new CopyOnWriteArrayList<>();
     boolean isPdf = false;
 
     try {
       if (filter instanceof OpenXMLFilter) {
         File tempDocx = AthUtil.createTempFile(".docx");
         File tempPdf = AthUtil.createTempFile(".pdf");
 
         try {
           Log.info(DocxPageMatcher.class, "Getting original page count");
           StreamUtil.copy(originalStream, tempDocx);
           convertDocxToPdf(tempDocx, tempPdf);
           originalPageCount = getPdfPageCount(tempPdf);
 
         } finally {
           AthUtil.deleteFile(tempPdf);
           AthUtil.deleteFile(tempDocx);
         }
 
       } else if (filter instanceof AthPdfFilter) {
         // Save the PDF so we can reuse it instead of converting multiple times
         originalPdf = AthUtil.createTempFile(".pdf");
         StreamUtil.copy(originalStream, originalPdf);
         originalPageCount = getPdfPageCount(originalPdf);
         isPdf = true;
 
       } else {
         // Unknown format - just return the passed translation file
         Log.warn(DocxPageMatcher.class,
             "Unknown filter type - returning the translation file without adjustment");
 
         return translation;
       }
 
       // // Set the DOCX file page size/orientation and margins based on the original PDF
       // if (isPdf) {
       // PageSetupConverter.copyPageSetupFromPdfToDocx(originalPdf, translation);
       // }
 
       // Get translation page count (convert DOCX -> PDF to count pages)
       Log.info(DocxPageMatcher.class, "Getting translation page count");
       translationPdf = AthUtil.createTempFile(".pdf");
       convertDocxToPdf(translation, translationPdf);
       translationPageCount = getPdfPageCount(translationPdf);
 
       if (translationPageCount <= originalPageCount) {
         Log.info(DocxPageMatcher.class,
             "Translation page count acceptable ({} ≤ {}). No adjustment needed.",
             translationPageCount, originalPageCount);
 
         return isPdf ? translationPdf : translation;
       }
 
       // Translation has too many pages - need to shrink fonts
       Log.info(DocxPageMatcher.class,
           "Starting page matching: current {} pages → target ≤ {} pages",
           translationPageCount, originalPageCount);
 
       // Perform font adjustment
       AdjustmentResult result = shrinkFontToFitPagesAdaptive(translation, originalPageCount);
       int finalPages;
 
       if (result != null) {
         finalPages = result.pageCount;
 
         Log.info(DocxPageMatcher.class, "✓ SUCCESS: Achieved {} pages with delta {}",
             finalPages, result.delta);
 
         AthUtil.deleteFile(translationPdf);
         Log.info(DocxPageMatcher.class, "Returning final PDF with {} pages", finalPages);
         return isPdf ? result.pdfFile : result.docxFile;
 
       } else {
         Log.warn(DocxPageMatcher.class,
             "Failed to reach target after {} sets (max delta -{}): Final {} pages",
             MAX_SETS, MAX_SETS * DELTAS_PER_SET, translationPageCount);
 
         return isPdf ? translationPdf : translation;
       }
 
     } finally {
       // Clean up PDFs if we created ones
       if (translationPdf != null && tempPdfs != null) {
         for (File tempPdf : tempPdfs) {
           if (!translationPdf.equals(tempPdf)) {
             AthUtil.deleteFile(tempPdf);
           }
         }
       }
 
       AthUtil.deleteFile(originalPdf);
     }
 
   }
 
   private static AdjustmentResult shrinkFontToFitPagesAdaptive(File originalDocx, int targetPages)
       throws Exception {
 
     AdjustmentResult best = null;
     boolean targetReached = false;
 
     for (int set = 1; set <= MAX_SETS; set++) {
       double startDelta = -1.0 * (set * DELTAS_PER_SET - 2); // -1, -4, -7, -10
       double endDelta = startDelta - (DELTAS_PER_SET - 1); // -3, -6, -9, -12
 
       Log.info(DocxPageMatcher.class, "Trying delta set {}: {} to {}", set, startDelta, endDelta);
 
       AdjustmentResult setResult = tryDeltaSet(originalDocx, targetPages, startDelta, endDelta);
 
       if (setResult != null) {
         if (best == null || setResult.delta > best.delta) {
           targetReached = setResult.pageCount <= targetPages;
 
           if (best != null) {
             cleanupAdjustmentResult(best);
           }
 
           best = setResult;
         }
       }
 
       if (setResult != null && targetReached) {
         Log.info(DocxPageMatcher.class, "Target reached in set {} with delta {} – stopping",
             set, setResult.delta);
 
         break;
       }
     }
 
     if (best != null) {
       Log.info(DocxPageMatcher.class,
           "✓ Best overall result: Delta {} → {} pages – applying to original file",
           best.delta, best.pageCount);
 
       adjustStylesFontSize(originalDocx.getAbsolutePath(), best.delta);
       adjustDocumentFontSize(originalDocx.getAbsolutePath(), best.delta);
 
       cleanupAdjustmentResult(best);
       return new AdjustmentResult(originalDocx, best.pageCount, best.delta, best.pdfFile);
     }
 
     return null;
   }
 
   private static AdjustmentResult tryDeltaSet(File originalDocx, int targetPages,
       double startDelta, double endDelta) throws Exception {
 
     List<Callable<AdjustmentResult>> tasks = new ArrayList<>();
     ExecutorService executor = Executors.newFixedThreadPool(NUM_PARALLEL_THREADS);
 
     for (double delta = startDelta; delta >= endDelta; delta -= 1.0) {
       final double currentDelta = delta;
 
       tasks.add(() -> {
         File tempCopy = AthUtil.createTempFile(".docx");
 
         try {
           Files.copy(originalDocx.toPath(), tempCopy.toPath(), StandardCopyOption.REPLACE_EXISTING);
 
           adjustStylesFontSize(tempCopy.getAbsolutePath(), currentDelta);
           adjustDocumentFontSize(tempCopy.getAbsolutePath(), currentDelta);
 
           Log.info(DocxPageMatcher.class, "Getting page count for Delta {}", currentDelta);
           File tempPdf = AthUtil.createTempFile(".pdf");
           convertDocxToPdf(tempCopy, tempPdf);
 
           int pageCount = getPdfPageCount(tempPdf);
           Log.info(DocxPageMatcher.class, "Delta {} → {} pages", currentDelta, pageCount);
 
           return new AdjustmentResult(tempCopy, pageCount, currentDelta, tempPdf);
 
         } catch (Exception e) {
           if (tempCopy.exists()) {
             tempCopy.delete();
           }
 
           throw e;
         }
       });
     }
 
     AdjustmentResult bestInSet = null;
 
     try {
       List<Future<AdjustmentResult>> futures = executor.invokeAll(tasks);
 
       for (Future<AdjustmentResult> future : futures) {
         try {
           AdjustmentResult result = future.get();
 
           if (result.pageCount <= targetPages) {
             // Prefer smallest delta (least aggressive) among acceptable results
             if (bestInSet == null || Math.abs(result.delta) < Math.abs(bestInSet.delta)) {
               if (bestInSet != null) {
                 cleanupAdjustmentResult(bestInSet);
               }
 
               bestInSet = result;
 
             } else {
               cleanupAdjustmentResult(result);
             }
 
           } else {
             // Not acceptable, clean up
             cleanupAdjustmentResult(result);
           }
 
         } catch (Exception e) {
           Log.error(DocxPageMatcher.class, "Task execution failed: {}", e.getMessage());
         }
       }
 
     } finally {
       executor.shutdownNow();
     }
 
     return bestInSet;
   }
 
   private static void cleanupAdjustmentResult(AdjustmentResult result) {
     if (result == null)
       return;
 
     if (result.docxFile != null && result.docxFile.exists()) {
       if (!result.docxFile.delete())
         result.docxFile.deleteOnExit();
     }
   }
 
   public static int getPdfPageCount(InputStream pdfStream) throws Exception {
     File tempPdf = AthUtil.createTempFile(".pdf");
 
     try {
       StreamUtil.copy(pdfStream, tempPdf);
       return getPdfPageCount(tempPdf);
 
     } finally {
       if (tempPdf.exists()) {
         tempPdf.delete();
       }
     }
   }
 
   public static int getPdfPageCount(File pdfFile) throws Exception {
     try (PDDocument pdfDoc = Loader.loadPDF(pdfFile)) {
       return pdfDoc.getNumberOfPages();
     }
   }
 
   public static int getDocxPageCount(File docxFile, boolean byPageBreaks) throws Exception {
     if (!byPageBreaks) {
       return getDocxPageCount(docxFile);
     }
 
     Path tempDir = Files.createTempDirectory("docx_");
 
     try {
       AthUtil.unzip(docxFile.getAbsolutePath(), tempDir.toString());
 
       Path documentPath = tempDir.resolve("word/document.xml");
 
       if (!Files.exists(documentPath)) {
         Log.warn(DocxPageMatcher.class, "document.xml not found in DOCX");
         return 0;
       }
 
       Log.info(DocxPageMatcher.class, "Counting manual page breaks in document.xml...");
 
       String content = Files.readString(documentPath);
 
       // Pattern to match page breaks: <w:br w:type="page"/>
       // Handles both <w:br w:type="page"/> and <w:br w:type="page" />
       Pattern pageBreakPattern = Pattern.compile("<w:br\\s+w:type=\"page\"");
       Matcher matcher = pageBreakPattern.matcher(content);
 
       int pageBreakCount = 0;
 
       while (matcher.find()) {
         pageBreakCount++;
       }
 
       // Number of pages = number of page breaks + 1 (first page before any break)
       int pageCount = pageBreakCount + 1;
 
       Log.info(DocxPageMatcher.class, "Found {} page breaks, total pages: {}",
           pageBreakCount, pageCount);
 
       return pageCount;
 
     } finally {
       AthUtil.deleteDirectory(tempDir.toFile());
     }
   }
 
   public static int getDocxPageCount(File docxFile) throws Exception {
     File tempPdf = AthUtil.createTempFile(".pdf");
 
     try {
       convertDocxToPdf(docxFile, tempPdf);
       return getPdfPageCount(tempPdf);
 
     } finally {
       AthUtil.deleteFile(tempPdf);
     }
   }
 
   public static void convertToPdf(File docxFile, OutputStream output) throws Exception {
     File tempPdf = AthUtil.createTempFile(".pdf");
 
     try {
       convertDocxToPdf(docxFile, tempPdf);
       StreamUtil.copy(tempPdf, output);
 
     } finally {
       if (tempPdf.exists())
         tempPdf.delete();
     }
   }
 
   private static void convertDocxToPdf(File docxFile, File pdfFile) throws Exception {
     Map<String, Object> pdfProps = new HashMap<>();
 
     pdfProps.put("EmbedStandardFonts", true);
     pdfProps.put("SelectPdfVersion", 1);
     pdfProps.put("ExportFormFields", false);
 
     LocalConverter.builder()
         .officeManager(officeManager)
         .storeProperties(pdfProps)
         .build()
         .convert(docxFile)
         .as(DOCX)
         .to(pdfFile)
         .as(PDF)
         .execute();
   }
 
   private static void adjustStylesFontSize(String docxPath, double delta) throws Exception {
     // Path tempDir = Files.createTempDirectory("docx_");
     // unzip(docxPath, tempDir.toString());
     //
     // Path stylesPath = tempDir.resolve("word/styles.xml");
     //
     // if (!Files.exists(stylesPath)) {
     // Log.warn(DocxPageMatcher.class, "styles.xml not found in DOCX");
     // deleteDirectory(tempDir.toFile());
     // return;
     // }
     //
     // Log.info(DocxPageMatcher.class, "Modifying font size entries in styles.xml...");
     //
     // String content = Files.readString(stylesPath);
     // Matcher matcher = FONT_SIZE_PATTERN.matcher(content);
     // StringBuffer sb = new StringBuffer();
     // AtomicInteger modified = new AtomicInteger(0);
     //
     // while (matcher.find()) {
     // String valStr = matcher.group(2);
     //
     // try {
     // double currentHalfPoints = Double.parseDouble(valStr);
     // double currentPoints = currentHalfPoints / 2.0;
     // double newPoints = Math.max(1.0, currentPoints + delta);
     // int newHalfPoints = (int) (newPoints * 2);
     //
     // matcher.appendReplacement(sb, matcher.group(1) + newHalfPoints + matcher.group(3));
     // modified.incrementAndGet();
     //
     // } catch (NumberFormatException e) {
     // matcher.appendReplacement(sb, matcher.group(0));
     // }
     // }
     //
     // matcher.appendTail(sb);
     //
     // Log.info(DocxPageMatcher.class, "Modified {} font size entries in styles.xml (regex)",
     // modified.get());
     //
     // Files.writeString(stylesPath, sb.toString());
     //
     // zip(tempDir.toString(), docxPath);
     // deleteDirectory(tempDir.toFile());
   }
 
   private static void adjustDocumentFontSize(String docxPath, double delta) throws Exception {
     Path tempDir = Files.createTempDirectory("docx_");
     AthUtil.unzip(docxPath, tempDir.toString());
 
     Path documentPath = tempDir.resolve("word/document.xml");
 
     if (!Files.exists(documentPath)) {
       Log.warn(DocxPageMatcher.class, "document.xml not found");
       AthUtil.deleteDirectory(tempDir.toFile());
       return;
     }
 
     Log.info(DocxPageMatcher.class, "Modifying font size entries in document.xml...");
 
     String content = Files.readString(documentPath);
     Matcher matcher = FONT_SIZE_PATTERN.matcher(content);
     StringBuffer sb = new StringBuffer();
     AtomicInteger modified = new AtomicInteger(0);
 
     while (matcher.find()) {
       String valStr = matcher.group(2);
 
       try {
         double currentHalfPoints = Double.parseDouble(valStr);
         double currentPoints = currentHalfPoints / 2.0;
         double newPoints = Math.max(1.0, currentPoints + delta);
         int newHalfPoints = (int) (newPoints * 2);
 
         matcher.appendReplacement(sb, matcher.group(1) + newHalfPoints + matcher.group(3));
         modified.incrementAndGet();
 
       } catch (NumberFormatException e) {
         matcher.appendReplacement(sb, matcher.group(0));
       }
     }
 
     matcher.appendTail(sb);
 
     Log.info(DocxPageMatcher.class, "Modified {} font size entries in document.xml (regex)",
         modified.get());
 
     Files.writeString(documentPath, sb.toString());
 
     AthUtil.zip(tempDir.toString(), docxPath);
     AthUtil.deleteDirectory(tempDir.toFile());
   }  
 }