/*
 *  InterMergePDF
 *
 *  $URL: svn://svn.webarts.bc.ca/open/trunk/projects/WebARTS/ca/bc/webarts/tools/pdf/InterMergePDF.java $
 *  $REVISION: $
 *  Copyright (C) 2003 Tom Gutwin
 *  tgutwin@webarts.bc.ca
 *
 *
 *  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 the jEdit 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 java.io.FileNotFoundException;
import java.io.FileOutputStream;

import com.itextpdf.text.Document;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.pdf.PdfContentByte;
import com.itextpdf.text.pdf.PdfImportedPage;
import com.itextpdf.text.pdf.PdfReader;
import com.itextpdf.text.pdf.PdfWriter;
import com.itextpdf.text.Rectangle;


/**
 *  A tool to manipulate combine 2 PDF docs Page by page. One page from the
 * first doc then one page from the second doc.
 *  <br>
 *  This class can be called from the commandline or instantiated and used from
 *  other Java Objects.<br><br>
 *  <b><u>Commandline Syntax:</u></b><br>
 *  java InterMergePDF OddPagesPDFFilename EvenPagesPDFFilename MergedPDFFilename <br />
 *
 * @author    tgutwin
 */
public class InterMergePDF
{
  /** the filename for the resultant merged PDF. **/
  private String mergedPDFName_ = null;

  /** the filename to use for the ODD pages. **/
  private String oddPagePDFName_ = null;

  /** the filename to use for the EVEN pages. **/
  private String evenPagePDFName_ = null;


  /**
   * Constructor that takes the 3 required filename.
   **/
   public InterMergePDF(String oddPagePDFName,
                        String evenPagePDFName,
                        String mergedPDFName) throws FileNotFoundException
   {
     setMergedPDFName(mergedPDFName);
     setOddPagePDFName(oddPagePDFName);
     setEvenPagePDFName(evenPagePDFName);
   }


  /**
   *  The main program for the InterMergePDF class
   *
   * @param  args  The command line arguments (file names)
   */
  public static void main(String[] args)
  {
    if (args!=null && args.length == 3)
    {
      //System.out.println("Merging "+args[0] + ", "+ args[1] + " and "+ args[2]);
      try
      {
        InterMergePDF instance = new InterMergePDF(args[0], args[1], args[2]);
        instance.doMerge();
      }
      catch (FileNotFoundException FNFEx)
      {
        System.out.println("You provided crappy commandline arguments.");
        System.out.println("SYNTAX: java InterMergePDF OddPagesPDFFilename EvenPagesPDFFilename MergedPDFFilename");
      }
      catch (Exception ex)
      {
        System.out.println("You provided crappy commandline arguments.");
        ex.printStackTrace();
        System.out.println("SYNTAX: java InterMergePDF OddPagesPDFFilename EvenPagesPDFFilename MergedPDFFilename");
      }
    }
    else
    {
      System.out.println("You provided the wrong number of crappy commandline arguments.");
      System.out.println("SYNTAX: java InterMergePDF OddPagesPDFFilename EvenPagesPDFFilename MergedPDFFilename");
    }
  }


  /**
   * Executes the reading of a PDF file into a Document Object.
   *
   * @return success or failure
   **/
  private Document parsePDFFile(String inFileName)
  {
    Document retVal = null;
    String outFileName =
        inFileName.substring(0, inFileName.length()-4)+".tmp.pdf";
    try
    {
      // we create a reader for a certain document
      System.out.println("Reading: " + inFileName);
      PdfReader reader = new PdfReader(inFileName);
      float width_DPI = reader.getPageSize(1).getWidth();
      float height_DPI = reader.getPageSize(1).getHeight();
      float width = width_DPI / 72.0f;
      float height = height_DPI / 72.0f;

      // step 1: creation of a document-object
      Rectangle newPageSize = null;
      newPageSize = reader.getPageSize(1);

      // we retrieve the total number of pages
      int numPages = reader.getNumberOfPages();

      Document document =
          new Document(newPageSize, 0, 0, 0, 0);// Margins: left, right,top, bottom

      // step 2: we create a writer that listens to the document
      System.out.println("Writing: " + outFileName);
      FileOutputStream outFileStream = new FileOutputStream(outFileName);
      PdfWriter writer = PdfWriter.getInstance(document, outFileStream);

      // step 3: we open the document
      document.open();

      // step 4: calculate the new scaling / layout postion
      PdfContentByte cb = writer.getDirectContent();
      System.out.println("There are " + numPages +
          " pages in the document.");
      PdfImportedPage currentPDFPage;
      int currentPageNum = 0;

      /*
       *  step 5: Start Copying the pages to the new Doc
       *  ******* ***************************************
       */
      while (currentPageNum < numPages)
      {
        document.newPage();
        currentPDFPage = writer.getImportedPage(reader, ++currentPageNum);
        cb.addTemplate(currentPDFPage, 0.0f, 0.0f);
      }

      // step 6: we close the document
      document.close();
      retVal = document;
    }
    catch (Exception de)
    {
      de.printStackTrace();
      retVal = null;
    }

    return retVal;
  }


  /**
   * Executes the merge as specified by the class parms.
   *
   * @return success or failure
   **/
  public boolean doMerge()
  {
    boolean retVal = true;
    //System.out.println("Merging "+oddPagePDFName_ + " and "+ evenPagePDFName_);
    try
    {
      // we create a reader for a certain document
      PdfReader oddReader = new PdfReader(oddPagePDFName_);
      PdfReader evenReader = new PdfReader(evenPagePDFName_);


      float oddWidth_DPI = oddReader.getPageSize(1).getWidth();
      float oddHeight_DPI = oddReader.getPageSize(1).getHeight();
      float oddWidth = oddWidth_DPI / 72.0f;
      float oddHeight = oddHeight_DPI / 72.0f;
      float evenWidth_DPI = evenReader.getPageSize(1).getWidth();
      float evenHeight_DPI = evenReader.getPageSize(1).getHeight();
      float evenWidth = evenWidth_DPI / 72.0f;
      float evenHeight = evenHeight_DPI / 72.0f;

      // step 1: creation of a document-object
      Rectangle newPageSize = oddReader.getPageSize(1);
      Document document =
          new Document(newPageSize, 0, 0, 0, 0);// Margins: left, right,top, bottom

      // we retrieve the total number of pages
      int numPages = oddReader.getNumberOfPages() + evenReader.getNumberOfPages();
      /*System.out.println("Cropping " + numPages + " - " + width + "x" + height +
          " pages by (left=" + leftCropBorder_ + " right=" + rightCropBorder_ +
          " Top=" + topCropBorder_ + " bottom=" + bottomCropBorder_ +
          " scale=" + scale_ + ")");
      System.out.println("New Page Size: " +  newPageSize.getWidth()/ 72.0f + "x" +
                          newPageSize.getHeight()/ 72.0f);*/

      // step 2: we create a writer that listens to the document
      System.out.println("Writing: " + mergedPDFName_);
      FileOutputStream outFileStream = new FileOutputStream(mergedPDFName_);
      PdfWriter writer = PdfWriter.getInstance(document, outFileStream);

      // step 3: we open the document
      document.open();

      // step 4: calculate the new scaling / layout postion
      PdfContentByte cb = writer.getDirectContent();
      System.out.println("There are " + numPages +
          " pages in the document.");
      PdfImportedPage leftPage;
      PdfImportedPage rightPage;
      int currentLeftPage = 1;
      int currentRightPage = 1;
      int numPagesTransfered = 0;

      /*
       *  step 5: Start Copying the pages to the new Doc (in 2Up format)
       *  ******* ******************************************************
       */
      while (numPagesTransfered < numPages)
      {
        //System.out.println(currentLeftPage+" "+currentRightPage);
        if ((currentLeftPage+currentRightPage) % 2 !=0)
        {
          // Even Page
          document.newPage();
          leftPage = writer.getImportedPage(evenReader, currentLeftPage);
          // Check if there are still pages left to merge in
          if ( leftPage != null )
          {
            cb.addTemplate(leftPage, 0,0);
            currentLeftPage++;
            numPagesTransfered++;
          }
          else
          {
            // put a oddPage in instead
            leftPage = writer.getImportedPage(oddReader, currentRightPage);
            if ( leftPage != null )
            {
              cb.addTemplate(leftPage, 0,0);
              currentRightPage++;
              numPagesTransfered++;
            }
            else
            {
              System.out.println("Page numeber error");
              break;
            }
          }
        }
        else
        {
          //ODD Page
          document.newPage();
          rightPage = writer.getImportedPage(oddReader, currentRightPage);
          // Check if there are still pages left to merge in
          if ( rightPage != null )
          {
            cb.addTemplate(rightPage, 0,0);
            currentRightPage++;
            numPagesTransfered++;
          }
          else
          {
            // put a leftPage in
            rightPage = writer.getImportedPage(evenReader, currentLeftPage);
            if ( rightPage != null )
            {
              cb.addTemplate(rightPage, 0,0);
              currentLeftPage++;
              numPagesTransfered++;
            }
            else
            {
              System.out.println("Page numeber error");
              break;
            }
          }
        }
      }

      // step 6: we close the document
      document.close();
    }
    catch (Exception de)
    {
      de.printStackTrace();
      retVal = false;
    }

    return retVal;
  }


  /**
   * Setter for the mergedPDFName_ field.
   **/
  public void setMergedPDFName(String mergedPDFName)
  {
    this.mergedPDFName_ = mergedPDFName;
  }


  /**
   * Getter for the mergedPDFName_ field.
   **/
  public String getMergedPDFName()
  {
    return mergedPDFName_;
  }


  /**
   * Setter for the oddPagePDFName_ field.
   **/
  public void setOddPagePDFName(String oddPagePDFName)
  {
    this.oddPagePDFName_ = oddPagePDFName;
  }


  /**
   * Getter for the oddPagePDFName_ field.
   **/
  public String getOddPagePDFName_()
  {
    return oddPagePDFName_;
  }


  /**
   * Setter for the evenPagePDFName_ field.
   **/
  public void setEvenPagePDFName(String evenPagePDFName)
  {
    this.evenPagePDFName_ = evenPagePDFName;
  }


  /**
   * Getter for the evenPagePDFName_ field.
   **/
  public String getEvenPagePDFName_()
  {
    return evenPagePDFName_;
  }



}