package com.acumenvelocity.ath.pagematcher;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.UncheckedIOException;
   import java.nio.file.Files;
   import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.nio.file.StandardCopyOption;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  import java.util.zip.ZipOutputStream;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.transform.OutputKeys;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import org.apache.pdfbox.Loader;
  import org.apache.pdfbox.pdmodel.PDDocument;
  import org.jodconverter.local.LocalConverter;
  import org.jodconverter.local.office.LocalOfficeManager;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  
  public class DocxPageMatcherTest {
  
    private static final String WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
    private static final LocalOfficeManager officeManager = LocalOfficeManager.builder().build();
  
    public static void main(String[] args) throws Exception {
      if (args.length != 2) {
        System.out.println("Usage: java DocxPageMatcher <original.docx> <translation.docx>");
        return;
      }
  
      String originalPath = args[0];
      String translationPath = args[1];
  
      startOfficeManager();
      try {
        // if (!isLibreOfficeAvailable()) {
        // System.err.println("LibreOffice UNO API is not available.\n\n"
        // + "sudo apt-get install -y --no-install-recommends \\\n"
        // + " libreoffice \\\n"
        // + " libreoffice-writer \\\n"
        // + " libreoffice-java-common \\\n"
        // + " ure \\\n"
        // + " fonts-dejavu fonts-liberation fonts-crosextra-carlito fonts-crosextra-caladea
        // fontconfig");
        //
        // return;
        // }
  
        System.out.println("Starting page count matching process...");
        matchPageCount(originalPath, translationPath);
  
      } finally {
        stopOfficeManager();
      }
    }
  
    /**
     * Translation DOCX is modified by the method.
     * @param originalDocxPath
     * @param translationDocxPath
     * @throws Exception
     */
    public static void matchPageCount(String originalDocxPath, String translationDocxPath)
        throws Exception {
      int originalPages = getPageCount(originalDocxPath);
      int translationPages = getPageCount(translationDocxPath);
  
      System.out.printf("Original pages: %d%n", originalPages);
      System.out.printf("Translation pages: %d%n", translationPages);
  
      if (translationPages <= originalPages) {
        System.out.println("Translation page count is acceptable. No changes needed.");
        return;
      }
  
      // Phase 1: Try adjusting styles.xml
      System.out.println("\nPhase 1: Attempting to adjust styles.xml...");
      boolean stylesSuccess = shrinkFontToFitPages(translationDocxPath, originalPages, true);
  
      if (!stylesSuccess) {
        // Phase 2: Try adjusting document.xml
        System.out.println("\nPhase 2: Adjusting document.xml...");
        shrinkFontToFitPages(translationDocxPath, originalPages, false);
      }
  
      int finalPages = getPageCount(translationDocxPath);
     System.out.printf("\nFinal result: %d pages (target: %d)%n", finalPages, originalPages);
   }
 
   private static boolean shrinkFontToFitPages(String docxPath, int targetPages, boolean useStyles)
       throws Exception {
 
     String backupPath = docxPath + ".backup";
 
     // Create initial backup (in case we need to revert)
     Files.copy(Paths.get(docxPath), Paths.get(backupPath), StandardCopyOption.REPLACE_EXISTING);
 
     int currentPages = getPageCount(docxPath);
     System.out.printf("Initial page count: %d (target: %d)%n", currentPages, targetPages);
 
     if (currentPages <= targetPages) {
       System.out.println("No adjustment needed – page count already acceptable.");
       Files.delete(Paths.get(backupPath));
       return true;
     }
 
     int iteration = 0;
     double totalDelta = 0.0;
 
     while (currentPages > targetPages) {
       iteration++;
       double deltaThisStep = -1.0; // Decrease font size by 1 point
       totalDelta += deltaThisStep;
 
       System.out.printf("Iteration %d: Applying delta=%.1fpt (total delta=%.1fpt)%n",
           iteration, deltaThisStep, totalDelta);
 
       // Restore from backup before each adjustment to apply cumulative delta correctly
       Files.copy(Paths.get(backupPath), Paths.get(docxPath), StandardCopyOption.REPLACE_EXISTING);
 
       // Apply the cumulative delta
       if (useStyles) {
         adjustStylesFontSize(docxPath, totalDelta);
 
       } else {
         adjustDocumentFontSize(docxPath, totalDelta);
       }
 
       currentPages = getPageCount(docxPath);
       System.out.printf("  Result: %d pages (target: %d)%n", currentPages, targetPages);
 
       if (currentPages <= targetPages) {
         System.out.println("  ✓ Target page count achieved or exceeded!");
         Files.delete(Paths.get(backupPath));
         return true;
       }
 
       // Safety limit to prevent infinite loop or excessive shrinking
       if (iteration >= 10) {
         System.out.println("  Maximum iterations reached. Stopping to avoid over-shrinking.");
         break;
       }
     }
 
     // If we exited loop without reaching target, apply the best (last) result
     if (currentPages > targetPages) {
       System.out.println("Could not reach target page count. Applying the best result so far.");
       // Already applied in last iteration, just clean up backup
     }
 
     Files.delete(Paths.get(backupPath));
     return currentPages <= targetPages;
   }
 
   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)) {
       System.out.println("styles.xml not found");
       return;
     }
 
     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     factory.setNamespaceAware(true);
     DocumentBuilder builder = factory.newDocumentBuilder();
     Document doc = builder.parse(stylesPath.toFile());
 
     NodeList szNodes = doc.getElementsByTagNameNS(WORD_NS, "sz");
     NodeList szCsNodes = doc.getElementsByTagNameNS(WORD_NS, "szCs");
 
     AtomicInteger modified = new AtomicInteger(0);
 
     java.util.function.Consumer<Element> adjustFontSize = szElement -> {
       String valAttr = szElement.getAttribute("w:val");
       if (!valAttr.isEmpty()) {
         try {
           double currentSize = Double.parseDouble(valAttr) / 2.0; // half-points → points
           double newSize = Math.max(1.0, currentSize + delta);
           szElement.setAttribute("w:val", String.valueOf((int) (newSize * 2)));
           modified.incrementAndGet();
         } catch (NumberFormatException e) {
           // Skip invalid values
         }
       }
     };
 
     // Process all <w:sz> elements
     for (int i = 0; i < szNodes.getLength(); i++) {
       adjustFontSize.accept((Element) szNodes.item(i));
     }
 
     // Process all <w:szCs> elements (complex script font sizes)
     for (int i = 0; i < szCsNodes.getLength(); i++) {
       adjustFontSize.accept((Element) szCsNodes.item(i));
     }
 
     System.out.printf("  Modified %d font size entries (sz + szCs) in styles.xml%n",
         modified.get());
 
     TransformerFactory transformerFactory = TransformerFactory.newInstance();
     Transformer transformer = transformerFactory.newTransformer();
     transformer.setOutputProperty(OutputKeys.INDENT, "yes");
     transformer.transform(new DOMSource(doc), new StreamResult(stylesPath.toFile()));
 
     zip(tempDir.toString(), docxPath);
     deleteDirectory(tempDir.toFile());
   }
 
   private static void adjustDocumentFontSize(String docxPath, double delta) throws Exception {
     Path tempDir = Files.createTempDirectory("docx_");
     unzip(docxPath, tempDir.toString());
 
     Path documentPath = tempDir.resolve("word/document.xml");
     if (!Files.exists(documentPath)) {
       System.out.println("document.xml not found");
       return;
     }
 
     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     factory.setNamespaceAware(true);
     DocumentBuilder builder = factory.newDocumentBuilder();
     Document doc = builder.parse(documentPath.toFile());
 
     NodeList szNodes = doc.getElementsByTagNameNS(WORD_NS, "sz");
     NodeList szCsNodes = doc.getElementsByTagNameNS(WORD_NS, "szCs");
 
     AtomicInteger modified = new AtomicInteger(0);
 
     java.util.function.Consumer<Element> adjustFontSize = szElement -> {
       String valAttr = szElement.getAttribute("w:val");
       if (!valAttr.isEmpty()) {
         try {
           double currentSize = Double.parseDouble(valAttr) / 2.0; // half-points → points
           double newSize = Math.max(1.0, currentSize + delta);
 
           szElement.setAttribute("w:val", String.valueOf((int) (newSize * 2)));
           modified.incrementAndGet();
 
         } catch (NumberFormatException e) {
           // Skip invalid values
         }
       }
     };
 
     // Process all <w:sz> elements
     for (int i = 0; i < szNodes.getLength(); i++) {
       adjustFontSize.accept((Element) szNodes.item(i));
     }
 
     // Process all <w:szCs> elements (complex script font sizes)
     for (int i = 0; i < szCsNodes.getLength(); i++) {
       adjustFontSize.accept((Element) szCsNodes.item(i));
     }
 
     System.out.printf("Modified %d font size entries (sz + szCs) in document.xml%n",
         modified.get());
 
     TransformerFactory transformerFactory = TransformerFactory.newInstance();
     Transformer transformer = transformerFactory.newTransformer();
     transformer.setOutputProperty(OutputKeys.INDENT, "yes");
     transformer.transform(new DOMSource(doc), new StreamResult(documentPath.toFile()));
 
     zip(tempDir.toString(), docxPath);
     deleteDirectory(tempDir.toFile());
   }
 
   private static int getPageCount(String docxPath) throws Exception {
     // try (FileInputStream fis = new FileInputStream(docxPath);
     // XWPFDocument document = new XWPFDocument(fis)) {
     //
     // int pages = document.getProperties().getExtendedProperties().getUnderlyingProperties()
     // .getPages();
     //
     // if (pages == 0) {
     // // Fallback: estimate based on content
     // pages = Math.max(1, document.getParagraphs().size() / 30);
     // }
     //
     // return pages;
     // }
 
     return getAccuratePageCount(docxPath);
   }
 
   // public static boolean isLibreOfficeAvailable() {
   // LocalOfficeManager officeManager = null;
   // try {
   // // Auto-detects LibreOffice at /usr/lib/libreoffice on Ubuntu
   // // If auto-detection ever fails, uncomment the line below:
   // // officeManager = LocalOfficeManager.builder().officeHome("/usr/lib/libreoffice").build();
   // officeManager = LocalOfficeManager.builder().build();
   //
   // officeManager.start(); // This will throw if soffice not found or unusable
   //
   // return true;
   //
   // } catch (OfficeException e) {
   // System.err.println("LibreOffice not available: " + e.getMessage());
   // return false;
   //
   // } finally {
   // if (officeManager != null && officeManager.isRunning()) {
   // try {
   // officeManager.stop();
   // } catch (OfficeException ignored) {
   // }
   // }
   // }
   // }
 
   public static void startOfficeManager() {
     try {
       officeManager.start();
       System.out.println("LibreOffice manager started successfully");
     } catch (Exception e) {
       // Optional: retry a few times
       e.printStackTrace();
     }
   }
 
   public static void stopOfficeManager() {
     try {
       officeManager.stop();
       System.out.println("LibreOffice manager stopped successfully");
 
     } catch (Exception e) {
       // Optional: retry a few times
       e.printStackTrace();
     }
   }
 
   // private static int getAccuratePageCount(String docxPath) throws Exception {
   // // Bootstrap local LibreOffice context
   // com.sun.star.uno.XComponentContext xContext = com.sun.star.comp.helper.Bootstrap.bootstrap();
   //
   // // Get the Desktop service (XComponentLoader)
   // Object desktop = xContext.getServiceManager().createInstanceWithContext(
   // "com.sun.star.frame.Desktop", xContext);
   // XComponentLoader xLoader = (XComponentLoader) UnoRuntime.queryInterface(
   // XComponentLoader.class, desktop);
   //
   // // Prepare load properties: Hidden = true (load without UI)
   // PropertyValue[] loadProps = new PropertyValue[1];
   // loadProps[0] = new PropertyValue();
   // loadProps[0].Name = "Hidden";
   // loadProps[0].Value = Boolean.TRUE;
   //
   // // Convert path to file URL
   // String fileUrl = "file:///" + new java.io.File(docxPath).getAbsolutePath()
   // .replace("\\", "/");
   //
   // // Load the document
   // XComponent xComponent = xLoader.loadComponentFromURL(
   // fileUrl, "_blank", 0, loadProps);
   //
   // try {
   // // Get document properties
   // XDocumentPropertiesSupplier supplier = (XDocumentPropertiesSupplier) UnoRuntime
   // .queryInterface(XDocumentPropertiesSupplier.class, xComponent);
   // XDocumentProperties props = supplier.getDocumentProperties();
   //
   // // Get statistics (includes accurate PageCount after layout)
   // NamedValue[] stats = props.getDocumentStatistics();
   // for (NamedValue stat : stats) {
   // if ("PageCount".equals(stat.Name)) {
   // // Value is usually Short or Integer
   // return ((Number) stat.Value).intValue();
   // }
   // }
   // } finally {
   // // Always dispose the component
   // xComponent.dispose();
   // }
   //
   // // Fallback if not found (should not happen)
   // return -1;
   // }
 
   private static int getAccuratePageCount(String docxPath) throws Exception {
     File inputFile = new File(docxPath);
     File tempPdf = File.createTempFile("pagecount_", ".pdf");
 
     try {
       // Build the converter explicitly using your shared officeManager
       LocalConverter.builder()
           .officeManager(officeManager)
           .build()
           .convert(inputFile)
           .to(tempPdf)
           .execute();
 
       try (PDDocument pdfDoc = Loader.loadPDF(tempPdf)) {
         return pdfDoc.getNumberOfPages();
       }
 
     } finally {
       if (tempPdf.exists() && !tempPdf.delete()) {
         tempPdf.deleteOnExit(); // Safety net
       }
     }
   }
 
   private static void unzip(String zipFilePath, String destDir) throws IOException {
     File dir = new File(destDir);
     if (!dir.exists())
       dir.mkdirs();
 
     try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFilePath))) {
       ZipEntry entry;
       while ((entry = zis.getNextEntry()) != null) {
         File file = new File(destDir, entry.getName());
         if (entry.isDirectory()) {
           file.mkdirs();
         } else {
           file.getParentFile().mkdirs();
           try (FileOutputStream fos = new FileOutputStream(file)) {
             byte[] buffer = new byte[4096];
             int len;
             while ((len = zis.read(buffer)) > 0) {
               fos.write(buffer, 0, len);
             }
           }
         }
         zis.closeEntry();
       }
     }
   }
 
   private static void zip(String sourceDirPath, String zipFilePath) throws IOException {
     Path source = Paths.get(sourceDirPath);
     try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFilePath))) {
       Files.walk(source).filter(path -> !Files.isDirectory(path)).forEach(path -> {
         ZipEntry entry = new ZipEntry(source.relativize(path).toString().replace("\\", "/"));
         try {
           zos.putNextEntry(entry);
           Files.copy(path, zos);
           zos.closeEntry();
         } catch (IOException e) {
           throw new UncheckedIOException(e);
         }
       });
     }
   }
 
   private static void deleteDirectory(File dir) {
     File[] files = dir.listFiles();
     if (files != null) {
       for (File file : files) {
         if (file.isDirectory()) {
           deleteDirectory(file);
         } else {
           file.delete();
         }
       }
     }
     dir.delete();
   }
 }