/*
 *  ConcatPDF.java
 *  $URL: svn://svn.webarts.bc.ca/open/trunk/projects/WebARTS/ca/bc/webarts/tools/pdf/ConcatPDF.java $
 *  $REVISION: $
 *  $Date: 2019-04-18 18:30:08 -0700 (Thu, 18 Apr 2019) $
 *  Copyright (c) 2003 Tom B. Gutwin P.Eng.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package ca.bc.webarts.tools.pdf;

import java.io.File;

import com.itextpdf.text.*;
import com.itextpdf.text.pdf.*;

import java.io.*;


/**
 *  This is a simple application class that concatenates pdf files.
 *  <br>It has 3 modes of operation.<br><ol>
 *  <li>DEFAULT operation simply concat's files one file after the other.</li>
 *  <li>Merge one file into another at a specified page.</li>
 *  <li>Concat ALL files in a given directory.</li></ol>
 *  <br><b><u>Syntax for basic concatenation (one file after the other) into
 *  a NEW PDF file:</u>
 *  </b><br>
 *  <pre>java ca.bc.webarts.tools.ConcatPDF destfile file1 file2 [file3 ...]</pre>
 *  <br><br><b><u>Syntax for 'insert into' concatenation (one into the other at the
 *  spec'd page) into a NEW PDF file:</u></b><br>
 *  <pre>java ca.bc.webarts.tools.ConcatPDF destfile file1 file2 insertPageNum</pre>
 *  <br><br><b><u>Syntax for directory concatenation (all files in a dir
 *  concat'd into one NEW file):</u></b><br>
 *  <pre>java ca.bc.webarts.tools.ConcatPDF destfile directoryName</pre>
 *
 * @author    TGutwin
 */
public class ConcatPDF
{
  /**
   * An optional page number at which to insert the the 2nd file into the first.
   * For example if this field is 14, the 2nd PDF file will be concat'd into
   * the first starting at page 14.<br>The resultant file will have 13 pages of
   * the 1st PDF, all of the 2nd PDF and then the rest of the 1st PDF.
   **/
   private int insertPage_ = 0;

   private static String eol_ = System.getProperty("line.separator");


  /**
   * The simple usage help message..
   **/
   private static final String usage_ =
     "This is a simple application class that concatenates pdf files."+
     eol_+
     "It has 3 modes of operation:"+eol_+
     "   1) DEFAULT operation simply concat's files one file after the other."+
     eol_+
     "   2) Merge 2nd file into 1st at a specified page."+eol_+
     "   3) Concat ALL files in a given directory."+eol_+
     eol_+
     "Syntax for basic concatenation (one file after the other) into"+
     "a NEW PDF file:"+eol_+
     "   java ca.bc.webarts.tools.ConcatPDF destfile file1 file2 [file3 ...]"+
     eol_+eol_+
     "Syntax for 'insert into' concatenation (one into the other at the"+
     "spec'd page) into a NEW PDF file:"+eol_+
     "   java ca.bc.webarts.tools.ConcatPDF destfile insertIntoFile insertedFile insertPageNum"+
     eol_+eol_+
     "Syntax for directory concatenation (all files in a dir concat'd into "+
     "one NEW file):"+eol_+
     "   java ca.bc.webarts.tools.ConcatPDF destfile directoryName";


  /**
   *  A basic empty constructor for ConcatPDF class that does nothing but
   *  instantiate the class.
   */
  public ConcatPDF()
  {
    // the worker methods will have to be called on the instantiated object.
  }


  /**
   *  A constructor for ConcatPDF class that takes a array of filenames and
   *  concatenates them all into the targetPDF file.
   *
   * @param  targetPdf  The resultant target PDF file after concatenation.
   * @param  filenames  the pdf files to concat.
   */
  public ConcatPDF(String targetPdf, String[] filenames)
  {
    concatFiles(targetPdf, filenames);
  }


  /**
   *  A constructor for ConcatPDF class that takes a directory  and
   *  concatenates ALL the pdf files into the targetPDF file.
   *
   * @param  targetPdf  The resultant target PDF file after concatenation.
   * @param  pdfDirectory  A directory to search for PDFs.
   */
  public ConcatPDF(String targetPdf, String pdfDirectory)
  {
    concatFilesFromDirectory(targetPdf, pdfDirectory, false);
  }


  /**
   *  A constructor for ConcatPDF class that does 'insert into' concatenation
   * (one into the other at the spec'd page) into a NEW PDF file.
   *
   * @param  targetPdf  The resultant target PDF file after concatenation.
   * @param  first  The 1st PDF file for concatenation.
   * @param  second  The 2nd PDF file for concatenation.
   * @param  insertIntoPage  the page number to insert the 2nd PDF at..
   */
  public ConcatPDF(String targetPdf, String first, String second, int insertIntoPage)
  {
    insertPage_ = insertIntoPage;
    insertConcat(targetPdf, first, second, insertIntoPage);
  }


  /**
   *  A helper method to do the DEFAULT concating of individual files one
   *  after the other.
   *
   * @param  targetPdf  The resultant target PDF file after concatenation.
   * @param  filenames  the pdf files to concat.
   */
  public boolean concatFiles(String targetPdf,  String[] filenames)
  {

    boolean retVal = true;
    // first test if all the files are available for readings
    File tmpFile = null;
    boolean fileFailure = false;
    String errorMsg = "";
    for (int i=0; !fileFailure && i<filenames.length; i++)
    {
      try
      {
        tmpFile = new File(filenames[i]);
        if (!tmpFile.exists() || !tmpFile.canRead())
        {
          fileFailure = true;
          errorMsg = "Cannot read file: "+filenames[i];
        }
      }
      catch (NullPointerException npe)
      {
        fileFailure = true;
        errorMsg = "File ERROR encountered for file: "+filenames[i];
      }
    }

    // On with the concat
    if (!fileFailure)
    {
      try
      {
        int i = 0;
        PdfReader pdfreader = new PdfReader(filenames[i]);
        int numPagesInCurrPdf = pdfreader.getNumberOfPages();
        System.out.println("There are " + numPagesInCurrPdf
             + " pages in "+filenames[i]);
        Document document
             = new Document(pdfreader.getPageSizeWithRotation(1));

        // Open the target PDF file for writing
        PdfWriter pdfwriter
             = PdfWriter.getInstance(document,
            new FileOutputStream(targetPdf));
        document.open();
        PdfContentByte pdfcontentbyte = pdfwriter.getDirectContent();

        // loop through the files
        while (i < filenames.length)
        {
          int currPageNum = 0;

          // Loop through all the pages in the current file to merge in
          while (currPageNum < numPagesInCurrPdf)
          {
            currPageNum++;
            document.setPageSize
                (pdfreader.getPageSizeWithRotation(currPageNum));
            document.newPage();

            // get the page to merge in
            PdfImportedPage pdfimportedpage
                 = pdfwriter.getImportedPage(pdfreader, currPageNum);
            int currPageRotationDegrees = pdfreader.getPageRotation(currPageNum);

            // merge it in
            if (currPageRotationDegrees == 90 || currPageRotationDegrees == 270)
            {
              pdfcontentbyte.addTemplate(
                  pdfimportedpage, 0.0F, -1.0F, 1.0F, 0.0F, 0.0F,
                  pdfreader.getPageSizeWithRotation(currPageNum).getHeight());
            }
            else
            {
              pdfcontentbyte.addTemplate(
                  pdfimportedpage, 1.0F, 0.0F, 0.0F, 1.0F, 0.0F,
                  0.0F);
            }
            //System.out.println("Processed page " + currPageNum);
          } // more pages?

          // Is there more files to do? Then increment and do anaother file
          if (++i < filenames.length)
          {
            pdfreader = new PdfReader(filenames[i]);
            numPagesInCurrPdf = pdfreader.getNumberOfPages();
            System.out.println("There are " + numPagesInCurrPdf
             + " pages in "+filenames[i]);
          }
        }

        // Done All files
        document.close();
      }
      catch (Exception exception)
      {
        retVal = false;
        System.err.println(exception.getClass().getName() + ": "
             + exception.getMessage());
      }
    }
    else
    {
      retVal = false;
      System.out.println(errorMsg);
    }
    return retVal;
  }


  /**
    * Set Method for class field 'insertPage_'.
    *
    * @param insertPage is the value to set this class field to.
    *
    **/
  public  void setInsertPage(int insertPage)
  {
    this.insertPage_ = insertPage;
  }  // setInsertPage Method


  /**
    * Get Method for class field 'insertPage_'.
    *
    * @return int - The value the class field 'insertPage_'.
    *
    **/
  public int getInsertPage()
  {
    return insertPage_;
  }  // getInsertPage Method


  /** Prints the Class usage to System.out.**/
  public static void printUsage()
  {
    System.out.println(usage_);
  }


  /**
   *  A helper method to take a directory name, search it for PDF files and then
   *  concatenate them into the targetPdf.
   *
   * @param  targetPdf  The resultant target PDF file after concatenation.
   * @param  pdfDirectory  A directory to search for PDFs.
   * @param  recurse  recurse into the sub-dirs (NOT IMPLEMENTED YET).
   */
  public boolean concatFilesFromDirectory(String targetPdf,
                                          String pdfDirectory,
                                          boolean recurse)
  {
    // this method simply reads the dir for the pdf files and then calls the
    // concatFiles(String targetPdf,  String[] filenames) method.
    boolean retVal = true;
    String [] filesToConcat = null;
    int concatFilesCount = 0;
    File dirFile = new File(pdfDirectory);
    if (dirFile != null && dirFile.isDirectory())
    {
      String srcFileNames[] = dirFile.list();
      if (srcFileNames != null)
      {
        filesToConcat = new String[countPdfsInDir(pdfDirectory)];
        for (int i = 0; i < srcFileNames.length; i++)
        {
          File currFile = new File(srcFileNames[i]);
          if (currFile != null &&
             !currFile.isDirectory() &&
             isThisAPdfFile(currFile))
          {
            filesToConcat[concatFilesCount++] = currFile.getAbsolutePath();
          }
        }

        // Now send this array off to the helper method
        retVal = concatFiles(targetPdf,  filesToConcat);
      }
    }
    else
    {
      retVal = false;
      System.out.println(
         "Commandline parameter specified is NOT a directoryname");
    }

    return retVal;
  }


  /**
   *  A helper method to concats the 2nd PDF into the 1st at the spec'd page
   * into the targetPdf.
   *
   * @param  targetPdf  The resultant target PDF file after concatenation.
   * @param  firstPDF  The first PDF to concat the second into.
   * @param  secondPDF  The PDF to insert into the first at the spec'd page.
   * @param  insertPage  the page to insert the 2nd file at.
   */
  public boolean insertConcat(String targetPdf,
                              String firstPDF,
                              String secondPDF,
                              int insertPage)
  {
    boolean retVal = true;
    // first test if all the files are available for readings
    File tmpFile = null;
    boolean fileFailure = false;
    String errorMsg = "";
    try
    {
      tmpFile = new File(firstPDF);
      if (!tmpFile.exists() || !tmpFile.canRead())
      {
        fileFailure = true;
        errorMsg = "Cannot read file: "+firstPDF;
      }
      tmpFile = new File(secondPDF);
      if (!tmpFile.exists() || !tmpFile.canRead())
      {
        fileFailure = true;
        errorMsg = "Cannot read file: "+secondPDF;
      }
    }
    catch (NullPointerException npe)
    {
      fileFailure = true;
      errorMsg = "File ERROR encountered for file: " +
                 tmpFile.getAbsolutePath();
    }

    // On with the concat
    if (!fileFailure)
    {
      try
      {
        PdfReader firstPpdfreader = new PdfReader(firstPDF);
        PdfReader secondPpdfreader = new PdfReader(secondPDF);
        PdfReader pdfreader = firstPpdfreader;
        int numPagesInFirstPdf = firstPpdfreader.getNumberOfPages();
        int numPagesInSecondPdf = secondPpdfreader.getNumberOfPages();
        System.out.println("There are " + numPagesInFirstPdf
             + " pages in "+firstPDF);
        System.out.println("There are " + numPagesInSecondPdf
             + " pages in "+secondPDF);
        Document document
             = new Document(firstPpdfreader.getPageSizeWithRotation(1));

        // Open the target PDF file for writing
        PdfWriter pdfwriter
             = PdfWriter.getInstance(document,
            new FileOutputStream(targetPdf));
        document.open();
        PdfContentByte pdfcontentbyte = pdfwriter.getDirectContent();

        int currPageNum1 = 1;
        int currPageNum2 = 1;
        int currPageNumResult = 1;
        float currPageSizeWithRotation;
        int currPageRotationDegrees =0;
        PdfImportedPage pdfImportedpage = null;
        // Loop through all the pages in the FIRST file
        while (currPageNumResult <= numPagesInFirstPdf+numPagesInSecondPdf)
        {
          document.setPageSize
              (firstPpdfreader.getPageSizeWithRotation(currPageNum1));
          document.newPage();

          // get the page to merge in
          if (currPageNumResult < insertPage ||
             currPageNumResult >= insertPage + numPagesInSecondPdf)
          {
            // then just get the first file page
            System.out.println(currPageNumResult +"> Insert " + currPageNum1 + " from 1st PDF.");
            pdfreader = firstPpdfreader;
            pdfImportedpage
                 = pdfwriter.getImportedPage(pdfreader, currPageNum1);
            currPageRotationDegrees = pdfreader.getPageRotation(currPageNum1);
            currPageSizeWithRotation =
                pdfreader.getPageSizeWithRotation(currPageNum1).getHeight();
            currPageNum1++;
          }
          else
          {
            // insert a 2nd file page
            System.out.println(currPageNumResult +"> Insert " + currPageNum2 + " from 2nd PDF.");
            pdfreader = secondPpdfreader;
            pdfImportedpage
                 = pdfwriter.getImportedPage(pdfreader, currPageNum2);
            currPageRotationDegrees = pdfreader.getPageRotation(currPageNum2);
            currPageSizeWithRotation =
                pdfreader.getPageSizeWithRotation(currPageNum2).getHeight();

            // increment the page counter and continue with the rest of the 1st PDF
            currPageNum2++;
          }

          // merge it in
          if (currPageRotationDegrees == 90 || currPageRotationDegrees == 270)
          {
            pdfcontentbyte.addTemplate(
                pdfImportedpage, 0.0F, -1.0F, 1.0F, 0.0F, 0.0F,
                currPageSizeWithRotation);
          }
          else
          {
            pdfcontentbyte.addTemplate(
                pdfImportedpage, 1.0F, 0.0F, 0.0F, 1.0F, 0.0F,
                0.0F);
          }

          // increment the meged PDF page counter and keep going
          //System.out.println("   Processed page " + currPageNumResult);
          currPageNumResult++;
        } // more pages?


        // Done All files
        document.close();
      }
      catch (Exception exception)
      {
        retVal = false;
        System.err.println(exception.getClass().getName() + ": "
             + exception.getMessage());
      }
    }
    else
    {
      retVal = false;
      System.out.println(errorMsg);
    }

    return retVal;
  }


    /**
    *Counts the PDFs in a given dir.
    @return the number of PDF files in the spec'd directory
    **/
  public int countPdfsInDir(String pdfDirectory)
  {
    File dirFile = new File(pdfDirectory);
    int filesCount = 0;
    if (dirFile != null && dirFile.isDirectory())
    {
      String srcFileNames[] = dirFile.list();
      if (srcFileNames != null)
      {
        for (int i = 0; i < srcFileNames.length; i++)
        {
          File currFile = new File(srcFileNames[i]);
          if (currFile != null &&
             !currFile.isDirectory() &&
             isThisAPdfFile(currFile))
          {
            filesCount++;
          }
        }
      }
    }
    return filesCount;
  }


  /** Checks if the passef File is a PDF file (ie has a pdf extension).
    **/
  protected boolean isThisAPdfFile(File fileToCheck)
  {
    boolean retVal = false;

    try
    {
      String filename = fileToCheck.getAbsolutePath();
      if (filename.trim().toLowerCase().endsWith(".pdf"))
      {
        retVal = true;
      }
    }
    catch (Exception exception)
    {
      retVal = false;
      System.err.println(exception.getClass().getName() + ": "
           + exception.getMessage());
    }

    return retVal;
  }


  /**
   *  The main program for the ConcatPDF class. <br>
 *  <br><b><u>Syntax for basic concatenation (one file after the other) into
 *  a NEW PDF file:</u>
 *  </b><br>
 *  <pre>java ca.bc.webarts.tools.ConcatPDF destfile file1 file2 [file3 ...]</pre>
 *  <br><br><b><u>Syntax for 'insert into' concatenation (one into the other at the
 *  spec'd page) into a NEW PDF file:</u></b><br>
 *  <pre>java ca.bc.webarts.tools.ConcatPDF destfile file1 file2 insertPageNum</pre>
 *  <br><br><b><u>Syntax for directory concatenation (all files in a dir
 *  concat'd into one NEW file):</u></b><br>
 *  <pre>java ca.bc.webarts.tools.ConcatPDF destfile directoryName</pre>
   *
   * @param  args  The command line arguments
   */
  public static void main(String[] args)
  {
    if (args.length < 2)
    {
      // WRONG
      printUsage();
    }
    else if (args.length < 3)
    {
      // the concat dir mode
      new ConcatPDF(args[0], args[1]);
    }
    else // more than 2 args were passed
    {
      // this can be DEFAULT concat or insert into concat mode
      try
      {
        int insertPage =  Integer.parseInt(args[3]);
        // if we get here without exception then INSERT concat mode
        new ConcatPDF(args[0], args[1], args[2], insertPage);
      }
      catch (java.lang.NumberFormatException numFormatEx)
      {
        String [] cFilenames = new String [args.length-1];
        for (int i = 1; i <args.length; i++)
          cFilenames[i-1] = args[i];
        new ConcatPDF(args[0], cFilenames);
      }
    }
  }
}