package com.acumenvelocity.ath.filters.pdf;
   
   import java.io.InputStream;
   import java.util.ArrayList;
   import java.util.List;
   
   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.MimeTypeMapper;
  import net.sf.okapi.common.UsingParameters;
  import net.sf.okapi.common.encoder.EncoderManager;
  import net.sf.okapi.common.exceptions.OkapiIOException;
  import net.sf.okapi.common.filters.FilterConfiguration;
  import net.sf.okapi.common.filters.IFilter;
  import net.sf.okapi.common.filters.IFilterConfigurationMapper;
  import net.sf.okapi.common.filterwriter.IFilterWriter;
  import net.sf.okapi.common.resource.RawDocument;
  import net.sf.okapi.common.resource.StartDocument;
  import net.sf.okapi.common.skeleton.GenericSkeletonWriter;
  import net.sf.okapi.common.skeleton.ISkeletonWriter;
  import net.sf.okapi.filters.openxml.ConditionalParameters;
  import net.sf.okapi.filters.openxml.OpenXMLFilter;
  import net.sf.okapi.filters.openxml.OpenXMLFilterWriter;
  
  /**
   * Implements the IFilter interface for PDF files using Adobe PDF Services.
   * Converts PDF to DOCX, processes with OpenXML filter, and stores segments in Solr.
   */
  @UsingParameters(Parameters.class)
  public class AthPdfFilter implements IFilter {
    private EncoderManager encoderManager;
    private RawDocument input;
    private OpenXMLFilter docxFilter;
    private Parameters params;
    private LocaleId srcLoc;
  
    public AthPdfFilter() {
      super();
      params = new Parameters();
    }
  
    @Override
    public void cancel() {
      if (docxFilter != null) {
        docxFilter.cancel();
      }
    }
  
    @Override
    public void close() {
      if (input != null) {
        input.close();
      }
  
      if (docxFilter != null) {
        docxFilter.close();
      }
    }
  
    @Override
    public String getName() {
      return "okf_pdf";
    }
  
    @Override
    public String getDisplayName() {
      return "PDF Filter (Adobe services)";
    }
  
    @Override
    public String getMimeType() {
      return MimeTypeMapper.PDF_MIME_TYPE;
    }
  
    @Override
    public Parameters getParameters() {
      return params;
    }
  
    @Override
    public void setParameters(IParameters params) {
      this.params = (Parameters) params;
    }
  
    @Override
    public void setFilterConfigurationMapper(IFilterConfigurationMapper fcMapper) {
    }
  
    @Override
    public ISkeletonWriter createSkeletonWriter() {
      return new GenericSkeletonWriter();
    }
  
    @Override
    public IFilterWriter createFilterWriter() {
     return new AthPdfFilterWriter((OpenXMLFilterWriter) docxFilter.createFilterWriter());
   }
 
   @Override
   public List<FilterConfiguration> getConfigurations() {
     List<FilterConfiguration> list = new ArrayList<>();
 
     list.add(new FilterConfiguration("okf_pdf", MimeTypeMapper.PDF_MIME_TYPE, getClass().getName(),
         "PDF (Portable Document Format)",
         "Configuration for PDF documents using Adobe PDF Services",
         null, ".pdf;"));
 
     return list;
   }
 
   @Override
   public EncoderManager getEncoderManager() {
     if (encoderManager == null) {
       encoderManager = new EncoderManager();
 
       encoderManager.setMapping(MimeTypeMapper.PDF_MIME_TYPE,
           "net.sf.okapi.common.encoder.DefaultEncoder");
     }
 
     return encoderManager;
   }
 
   @Override
   public void open(RawDocument input) {
     open(input, true);
   }
 
   @Override
   public void open(RawDocument input, boolean generateSkeleton) {
     this.input = input;
 
     try {
       Log.info(getClass(), "Converting PDF to DOCX using Adobe PDF Services...");
 
       // Convert PDF to DOCX using Adobe PDF Services
       InputStream docxInputStream = PdfUtil.convertPdfToDocx(input.getStream(), srcLoc,
           params.getOcrMode());
 
       Log.info(getClass(), "PDF converted to DOCX successfully");
 
       // Process DOCX with OpenXML filter
       docxFilter = new OpenXMLFilter();
 
       ConditionalParameters docxParams = new ConditionalParameters();
       docxParams.fromString(params.toString());
 
       docxFilter.setParameters(docxParams);
 
       RawDocument docxRawDoc = new RawDocument(
           docxInputStream,
           input.getEncoding(),
           input.getSourceLocale());
 
       docxRawDoc.setFilterConfigId("okf_openxml");
       docxRawDoc.setId(input.getId());
 
       docxFilter.open(docxRawDoc, generateSkeleton);
       Log.info(getClass(), "OpenXML filter opened successfully");
 
     } catch (Exception e) {
       throw new OkapiIOException("Error processing PDF file", e);
     }
   }
 
   @Override
   public boolean hasNext() {
     return docxFilter != null && docxFilter.hasNext();
   }
 
   @Override
   public Event next() {
     Event e = docxFilter.next();
 
     if (e.isStartDocument()) {
       StartDocument sd = e.getStartDocument();
       sd.setMimeType(MimeTypeMapper.PDF_MIME_TYPE);
       sd.setName(input.getId());
       this.srcLoc = sd.getLocale();
       sd.setFilterWriter(createFilterWriter());
     }
 
     return e;
   }
 }