package com.acumenvelocity.ath.filters.pdf;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   
  import com.acumenvelocity.ath.common.AthUtil;
  import com.acumenvelocity.ath.common.Log;
  import com.acumenvelocity.ath.common.PdfUtil;
  
  import net.sf.okapi.common.Event;
  import net.sf.okapi.common.IParameters;
  import net.sf.okapi.common.LocaleId;
  import net.sf.okapi.common.StreamUtil;
  import net.sf.okapi.common.encoder.EncoderManager;
  import net.sf.okapi.common.exceptions.OkapiIOException;
  import net.sf.okapi.common.filterwriter.IFilterWriter;
  import net.sf.okapi.common.skeleton.ISkeletonWriter;
  import net.sf.okapi.filters.openxml.OpenXMLFilterWriter;
  
  /**
   * Filter writer for PDF files that merges translations back into the original format.
   * Uses Adobe PDF Services to convert DOCX back to PDF.
   */
  public class AthPdfFilterWriter implements IFilterWriter {
    
    private OutputStream output;
    private LocaleId targetLocale;
    private String defaultEncoding;
    private IParameters parameters;
    private boolean isStarted;
    private boolean isCancelled;
    private boolean ownsOutputStream;
  
    private OpenXMLFilterWriter docxWriter;
    private File tempDocxFile;
    private OutputStream docxOutputStream;
  
    public AthPdfFilterWriter(OpenXMLFilterWriter docxWriter) {
      this.docxWriter = docxWriter;
      this.isStarted = false;
      this.isCancelled = false;
      this.ownsOutputStream = false;
    }
  
    @Override
    public String getName() {
      return "AthPdfFilterWriter";
    }
  
    @Override
    public void setOptions(LocaleId locale, String defaultEncoding) {
      this.targetLocale = locale;
      this.defaultEncoding = defaultEncoding;
    }
  
    @Override
    public void setOutput(String path) {
      try {
        File file = new File(path);
        File parent = file.getParentFile();
        
        if (parent != null && !parent.exists()) {
          parent.mkdirs();
        }
        
        this.output = new FileOutputStream(file);
        this.ownsOutputStream = true;
        
      } catch (IOException e) {
        throw new OkapiIOException("Error creating output file: " + path, e);
      }
    }
  
    @Override
    public void setOutput(OutputStream output) {
      this.output = output;
      this.ownsOutputStream = false;
    }
  
    @Override
    public Event handleEvent(Event event) {
      if (isCancelled) {
        return event;
      }
  
      switch (event.getEventType()) {
      case START_DOCUMENT:
        handleStartDocument(event);
        break;
  
      case END_DOCUMENT:
        handleEndDocument(event);
        break;
  
      case TEXT_UNIT:
     case DOCUMENT_PART:
     case START_SUBDOCUMENT:
     case END_SUBDOCUMENT:
     case START_GROUP:
     case END_GROUP:
     case START_SUBFILTER:
     case END_SUBFILTER:
       // Forward all events to DOCX writer
       if (docxWriter != null) {
         docxWriter.handleEvent(event);
       }
       
       break;
 
     default:
       break;
     }
 
     return event;
   }
 
   private void handleStartDocument(Event event) {
     isStarted = true;
     isCancelled = false;
 
     Log.info(getClass(), "=== PDF Filter Writer Started ===");
     Log.info(getClass(), "Target locale: " + targetLocale);
 
     try {
       // Create temporary file for DOCX
       tempDocxFile = AthUtil.createTempFile();      
       docxOutputStream = new FileOutputStream(tempDocxFile);
 
       // Create DOCX writer
 
       if (docxWriter == null) {
         throw new OkapiIOException("OpenXML filter writer not available");
       }
 
       docxWriter.setOptions(targetLocale, defaultEncoding);
       docxWriter.setOutput(docxOutputStream);
 
       // Forward START_DOCUMENT to DOCX writer
       docxWriter.handleEvent(event);
 
       Log.info(getClass(), "DOCX writer initialized with temp file: " + tempDocxFile.getAbsolutePath());
 
     } catch (Exception e) {
       cleanupTempFile();
       throw new OkapiIOException("Error initializing DOCX writer", e);
     }
   }
 
   private void handleEndDocument(Event event) {
     if (!isStarted || isCancelled || output == null) {
       return;
     }
 
     InputStream docxInputStream = null;
     
     try {
       Log.info(getClass(), "\n=== Writing PDF ===");
 
       // Forward END_DOCUMENT to DOCX writer to finalize DOCX
       if (docxWriter != null) {
         docxWriter.handleEvent(event);
         docxWriter.close();
       }
 
       // Close the DOCX output stream
       if (docxOutputStream != null) {
         docxOutputStream.close();
         docxOutputStream = null;
       }
 
       Log.info(getClass(), "DOCX generation completed. Size: " + tempDocxFile.length() + " bytes");
 
       // Open input stream from temp file
       docxInputStream = new FileInputStream(tempDocxFile);
 
       // Convert DOCX to PDF using Adobe PDF Services
       InputStream pdfInputStream = PdfUtil.convertDocxToPdf(docxInputStream, targetLocale);
       
       // Copy PDF to output stream using utility method
       StreamUtil.copy(pdfInputStream, output);
 
       Log.info(getClass(), "PDF written successfully!");
 
     } catch (Exception e) {
       Log.error(getClass(), "Error writing PDF", e);
       throw new OkapiIOException("Error writing translated PDF", e);
       
     } finally {
       if (docxInputStream != null) {
         try {
           docxInputStream.close();
           
         } catch (IOException e) {
           // Ignore
         }
       }
       
       cleanupTempFile();
     }
   }
 
   private void cleanupTempFile() {
     if (tempDocxFile != null && tempDocxFile.exists()) {
       try {
         tempDocxFile.delete();
         Log.info(getClass(), "Temporary DOCX file deleted");
         
       } catch (Exception e) {
         Log.error(getClass(), "Failed to delete temp file: " + tempDocxFile.getAbsolutePath(), e);
       }
       
       tempDocxFile = null;
     }
   }
 
   @Override
   public void close() {
     Log.info(getClass(), "=== PDF Filter Writer Closed ===\n");
 
     isStarted = false;
     isCancelled = false;
 
     if (docxWriter != null) {
       try {
         docxWriter.close();
         
       } catch (Exception e) {
         Log.error(getClass(), "Error closing DOCX writer", e);
       }
       
       docxWriter = null;
     }
 
     if (docxOutputStream != null) {
       try {
         docxOutputStream.close();
         
       } catch (IOException e) {
         // Ignore
       }
       
       docxOutputStream = null;
     }
 
     cleanupTempFile();
 
     if (output != null && ownsOutputStream) {
       try {
         output.close();
         
       } catch (IOException e) {
         throw new OkapiIOException("Error closing output stream", e);
       }
     }
 
     output = null;
   }
 
   @Override
   public IParameters getParameters() {
     return parameters;
   }
 
   @Override
   public void setParameters(IParameters params) {
     this.parameters = params;
   }
 
   @Override
   public void cancel() {
     isCancelled = true;
 
     if (docxWriter != null) {
       docxWriter.cancel();
     }
 
     cleanupTempFile();
     Log.info(getClass(), "PDF Filter Writer cancelled");
   }
 
   @Override
   public EncoderManager getEncoderManager() {
     return null;
   }
 
   @Override
   public ISkeletonWriter getSkeletonWriter() {
     return null;
   }
 
   public LocaleId getTargetLocale() {
     return targetLocale;
   }
 
   public String getDefaultEncoding() {
     return defaultEncoding;
   }
 
   public boolean isCancelled() {
     return isCancelled;
   }
 }