/*
 *  TwoUpPDF
 *  a simple tool to format a PDF document's pages as 2Up pages that have been
 *  scaled/maximized for readablity when 2Up.
 *
 *  $URL: svn://svn.webarts.bc.ca/open/trunk/projects/WebARTS/ca/bc/webarts/tools/pdf/CropPDF.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.FileOutputStream;

import com.itextpdf.text.Document;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.pdf.PdfContentByte;
//import com.itextpdf.text.pdf.PdfDocument;
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 PDF files by cropping each page by the specified
 *  amounts.
 *  <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 CropPDF [leftPageCrop] [rightPageCrop] [topPageCrop] [bottomPageCrop] PDFFilename<br />
 *  where pageCrop is in inches<br>
 *
 * @author    tgutwin
 */
public class CropPDF
{
  /** Default input filename. **/
  public static final String DEFAULT_INPUT_FILENAME = "infile.pdf";

  /**  The input filename that will be cropped and saved in output filename.
   *   DEFAULT = infile.pdf**/
  private static String inFileName_ = DEFAULT_INPUT_FILENAME;

  /**  The output filename string. DEFAULT = infile-Crop.pdf**/
  private static String outFileName_ = "infile-Crop.pdf";

  /**  The left Cropped amount in inches. Default = 0.0**/
  private static float leftCropBorder_ = 0.0f;

  /**  The right Cropped amount in inches. Default = 0.0 **/
  private static float rightCropBorder_ = 0.0f;

  /**  The top Cropped amount in inches. Default = 0.0 **/
  private static float topCropBorder_ = 0.0f;

  /**  The bottom Cropped amount in inches. Default = 0.0 **/
  private static float bottomCropBorder_ = 0.0f;

  /**  EVEN Page left Cropped amount in inches. Default = 0.0**/
  private static float evenLeftCropBorder_ = 0.0f;

  /**  EVEN Page right Cropped amount in inches. Default = 0.0 **/
  private static float evenRightCropBorder_ = 0.0f;

  /**  EVEN Page top Cropped amount in inches. Default = 0.0 **/
  private static float evenTopCropBorder_ = 0.0f;

  /**  EVEN Page bottom Cropped amount in inches. Default = 0.0 **/
  private static float evenBottomCropBorder_ = 0.0f;

  /**  An angle in Radians to rotate the page after it has been cropped.
   *   For example: To change a Portrait page to landscape - set this to
   *                Math.toRadians(270)
   **/
  private static double rotation_ = Math.toRadians(0);

  /**  The size of the resultant page. */
  private static Rectangle outputPageSize_ = PageSize.LETTER;//PageSize.A4;

  /**  A scaling ratio to enlarge the newly cropped page
   *   if scaling is enabled. **/
  private static float scale_ = outputPageSize_.getWidth() /
               (outputPageSize_.getWidth() - (leftCropBorder_ + rightCropBorder_));

  /**
   * flags if there are different crop borders for the even pages as opposed to
   * the even pages.
   **/
  private static boolean evenOddPageCrops_ = false;

  /**  Flags the auto execution of acro reader after the cropping.
   *   DEFAULT = false **/
  private static boolean launchAcroread_ = false;

  /**  Flags whether the gui launches on startup.
   *   DEFAULT = false **/
  private static boolean launchGui_ = false;

  /**  Flags if the cropped page will also be scalled to max fit on the
   *   new output page. DEFAULT - false.  This is usefull if you want to crop
   *   the margins off a page and the expand all the remaining doc to fit
   *   on the output page.  If set to true, this will set the output page to
   *   the size of the input page and enlarge the cropped doc to fill the
   *   output page*/
  private static boolean doTheScale_ = false;

  /**  The path/command to run the acroreader. **/
  private static String acroCmd_ = "/home/tgutwin/bin/acro";

  /**  The usage string. **/
  private static String usage_ = "SYNTAX: CropPDF [leftPageCrop] [rightPageCrop] "+
      "[topPageCrop] [bottomPageCrop] [evenLeftPageCrop evenrightPageCrop "+
      "eventopPageCrop evenbottomPageCrop] PDFFilename\n" +
      "        where pageCrop is in inches";


  /**
   * Default Constructor assumes default values for EVERYTHING.
   **/
   public CropPDF()
   {

   }


  /**
   * Constructor that takes the edge crop sizes in inches.
   **/
   public CropPDF(float left, float right, float top, float bottom )
   {
     setLeftCropBorder(left);
     setRightCropBorder(right);
     setTopCropBorder(top);
     setBottomCropBorder(bottom);
   }


  /**
   * Constructor that takes the edge crop sizes in inches.
   **/
   public CropPDF(float left, float right, float top, float bottom, String fName )
   {
     setLeftCropBorder(left);
     setRightCropBorder(right);
     setTopCropBorder(top);
     setBottomCropBorder(bottom);
     setInFileName(fName);
     setOutFileName(fName.substring(0, fName.length()-4)+"-Crop.pdf");
   }


  /**
   * Constructor that takes the edge crop sizes in inches for even pages and odd pages
   **/
   public CropPDF(float evenleft, float evenright, float eventop,
                  float evenbottom, float left, float right, float top,
                  float bottom )
   {
     setEvenLeftCropBorder(evenleft);
     setEvenRightCropBorder(evenright);
     setEvenTopCropBorder(eventop);
     setEvenBottomCropBorder(evenbottom);
     setLeftCropBorder(left);
     setRightCropBorder(right);
     setTopCropBorder(top);
     setBottomCropBorder(bottom);
   }


  /**
   * Constructor that takes the edge crop sizes in inches for even pages and odd pages
   **/
   public CropPDF(float evenleft, float evenright, float eventop,
                  float evenbottom, float left, float right, float top,
                  float bottom, String fName )
   {
     setEvenLeftCropBorder(evenleft);
     setEvenRightCropBorder(evenright);
     setEvenTopCropBorder(eventop);
     setEvenBottomCropBorder(evenbottom);
     setLeftCropBorder(left);
     setRightCropBorder(right);
     setTopCropBorder(top);
     setBottomCropBorder(bottom);
     setInFileName(fName);
     setOutFileName(fName.substring(0, fName.length()-4)+"-Crop.pdf");
   }


  /**
   *  The main program for the CropPDF class
   *
   * @param  args  The command line arguments
   */
  public static void main(String[] args)
  {
    CropPDF instance = new CropPDF();
    boolean validParms = instance.parseCmdlineParms(args);


    /*
     *  Parms are now parsed.... start the transform/crop
     */
    if (validParms)
    {
      if (launchGui_)
      {
        // launch gui for crop info
      }
      else
      {
        // just do the crop
        instance.doCrop();
      }
    }
    else
    {
      // nothing for now.
    }
  }


  /**
   * Parses the input commandline parameters and assigns the various class
   * variables.
   *
   * @return success or failure
   **/
  private boolean parseCmdlineParms(String [] args)
  {
    boolean retVal = false;
    switch (args.length)
    {
        /* Only the Filename Spec'd */
        /* ------------------------ */
        case (1):
          if (args[0].endsWith(".pdf"))
          {
            setInFileName(args[0]);
            setOutFileName(null);
            retVal = true;
          }
          else if (args[0].startsWith("-gui"))
          {
            this.launchGui_ = true;
            retVal = true;
          }
          break;

        /* Left Border and Filename Spec'd */
        /* ------------------------------- */
        case (2):
          try
          {
            leftCropBorder_ = Float.parseFloat(args[0]);
            if (args[args.length - 1].endsWith(".pdf"))
            {
              setInFileName(args[args.length - 1]);
              setOutFileName(null);
              retVal = true;
            }
          }
          catch (NumberFormatException numEx)
          {
            System.out.println("Left Crop Size error: ");
            System.out.println(usage_);
            retVal = false;
          }
          break;

        /* Left, Right Border and Filename Spec'd */
        /* -------------------------------------- */
        case (3):
          try
          {
            leftCropBorder_ = Float.parseFloat(args[0]);
            rightCropBorder_ = Float.parseFloat(args[1]);
            if (args[args.length - 1].endsWith(".pdf"))
            {
              setInFileName(args[args.length - 1]);
              setOutFileName(null);
              retVal = true;
            }
          }
          catch (NumberFormatException numEx)
          {
            System.out.println("Crop Size error: ");
            System.out.println(usage_);
            retVal = false;
          }
          break;

        /* Left, Right, Top Border and Filename Spec'd */
        /* ------------------------------------------- */
        case (4):
          try
          {
            leftCropBorder_ = Float.parseFloat(args[0]);
            rightCropBorder_ = Float.parseFloat(args[1]);
            topCropBorder_ = Float.parseFloat(args[2]);
            if (args[args.length - 1].endsWith(".pdf"))
            {
              setInFileName(args[args.length - 1]);
              setOutFileName(null);
              retVal = true;
            }
          }
          catch (NumberFormatException numEx)
          {
            System.out.println("Crop Size error: ");
            System.out.println(usage_);
            retVal = false;
          }
          break;

        /* Left, Right, Top, Bottom Border and Filename Spec'd */
        /* --------------------------------------------------- */
        case (5):
          try
          {
            leftCropBorder_ = Float.parseFloat(args[0]);
            rightCropBorder_ = Float.parseFloat(args[1]);
            topCropBorder_ = Float.parseFloat(args[2]);
            bottomCropBorder_ = Float.parseFloat(args[3]);
            if (args[args.length - 1].endsWith(".pdf"))
            {
              setInFileName(args[args.length - 1]);
              setOutFileName(null);
              retVal = true;
            }
          }
          catch (NumberFormatException numEx)
          {
            System.out.println("Crop Size error: ");
            System.out.println(usage_);
            retVal = false;
          }
          break;

        /* Left, Right, Top, Bottom Border and different border
           margins for the opposite pages and Filename Spec'd */
        /* --------------------------------------------------- */
        case (9):
          try
          {
            evenLeftCropBorder_ = Float.parseFloat(args[0]);
            evenRightCropBorder_ = Float.parseFloat(args[1]);
            evenTopCropBorder_ = Float.parseFloat(args[2]);
            evenBottomCropBorder_ = Float.parseFloat(args[3]);
            leftCropBorder_ = Float.parseFloat(args[4]);
            rightCropBorder_ = Float.parseFloat(args[5]);
            topCropBorder_ = Float.parseFloat(args[6]);
            bottomCropBorder_ = Float.parseFloat(args[7]);
            if (args[args.length - 1].endsWith(".pdf"))
            {
              evenOddPageCrops_ = true;
              setInFileName(args[args.length - 1]);
              setOutFileName(null);
              retVal = true;
            }
          }
          catch (NumberFormatException numEx)
          {
            System.out.println("Crop Size error: ");
            System.out.println(usage_);
            retVal = false;
          }
          break;

        default:
          System.out.println("Commandline parameter error: ");
          System.out.println(usage_);
          retVal = false;
    }

    if (!retVal)
    {
      System.out.println("Filename ERROR - must end with \".pdf\": ");
      System.out.println(usage_);

    }
    return retVal;
  }



  /**
   * Executes the reading of a PDF file into a Document Object.
   *
   * @return success or failure
   **/
  public static 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 cropping/resizing as specified by the class parms.
   *
   * @return success or failure
   **/
  public boolean doCrop()
  {
    return doCrop(this.evenOddPageCrops_);
  }


  /**
   * Executes the cropping/resizing as specified by the class parms.
   *
   * @return success or failure
   **/
  public boolean doCrop(boolean doingEvenOddCrops)
  {
    boolean retVal = true;

    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 newEvenPageSize = null;
      Rectangle newOddPageSize = null;
      if (doTheScale_)
      {
        scale_ = (width) / (width - (leftCropBorder_ + rightCropBorder_));
        newOddPageSize = reader.getPageSize(1);
        scale_ = (width) / (width - (evenLeftCropBorder_ + evenRightCropBorder_));
        newEvenPageSize = reader.getPageSize(1);
      }
      else
      {
        scale_ = 1.0f;
        newOddPageSize = new Rectangle(
            width_DPI - (leftCropBorder_ + rightCropBorder_) * 72.0f,
            height_DPI - (topCropBorder_ + bottomCropBorder_) * 72.0f);
        newEvenPageSize = new Rectangle(
            width_DPI - (evenLeftCropBorder_ + evenRightCropBorder_) * 72.0f,
            height_DPI - (evenTopCropBorder_ + evenBottomCropBorder_) * 72.0f);
      }

      // we retrieve the total number of pages
      int numPages = reader.getNumberOfPages();
      System.out.println("Cropping " + numPages + " - " + width + "x" + height +
          " pages by (left=" + leftCropBorder_ + " right=" + rightCropBorder_ +
          " Top=" + topCropBorder_ + " bottom=" + bottomCropBorder_ +
          " scale=" + scale_ + ")");
      if (doingEvenOddCrops)
        System.out.println("Cropping Even pages" +
          " by (left=" + evenLeftCropBorder_ + " right=" + evenRightCropBorder_ +
          " Top=" + evenTopCropBorder_ + " bottom=" + evenBottomCropBorder_ +
          " scale=" + scale_ + ")");
      System.out.println("New Page Size: " +  newOddPageSize.getWidth()/ 72.0f + "x" +
                          newOddPageSize.getHeight()/ 72.0f);

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

      // step 2: we create a writer that listens to the document
      String outFileName =
          inFileName_.substring(0, inFileName_.length()-4)+"-Crop.pdf";
      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 importedPage;
      int currentPage = 0;

      // Calculate the Transfor parameters to use given the scale and postion
      float cosRotation = (new Float(Math.cos(rotation_))).floatValue();
      float sinRotation = (new Float(Math.sin(rotation_))).floatValue();
      float a = scale_ * cosRotation;
      float b = scale_ * sinRotation;
      float c = -1.0f * scale_ * sinRotation;
      float d = scale_ * cosRotation;
      //System.out.println("a= " +a);
      //System.out.println("b= " +b);
      //System.out.println("c= " +c);
      //System.out.println("d= " +d);

      /*
       *  step 5: Start Copying the pages to the new Doc (in 2Up format)
       *  ******* ******************************************************
       */
      while (currentPage < numPages)
      {
        document.newPage();
        importedPage = writer.getImportedPage(reader, ++currentPage);
        if (doingEvenOddCrops && currentPage%2 ==0)
          cb.addTemplate(importedPage, a, b, c, d, -(evenLeftCropBorder_* 72.0f),
                                                   -(evenBottomCropBorder_* 72.0f));
        else
          cb.addTemplate(importedPage, a, b, c, d, -(leftCropBorder_* 72.0f),
                                                   -(bottomCropBorder_* 72.0f));
      }

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

    return retVal;
  }


  /**
   * Setter.
   **/
  public void setLeftCropBorder(float leftCropBorder)
  {
    this.leftCropBorder_ = leftCropBorder;
  }


  /**
   * Getter.
   **/
  public float getLeftCropBorder()
  {
    return leftCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setEvenLeftCropBorder(float evenLeftCropBorder)
  {
    this.evenLeftCropBorder_ = evenLeftCropBorder;
  }


  /**
   * Getter.
   **/
  public float getEvenLeftCropBorder()
  {
    return evenLeftCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setRightCropBorder(float rightCropBorder)
  {
    this.rightCropBorder_ = rightCropBorder;
  }


  /**
   * Getter.
   **/
  public float getRightCropBorder()
  {
    return rightCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setEvenRightCropBorder(float evenRightCropBorder)
  {
    this.evenRightCropBorder_ = evenRightCropBorder;
  }


  /**
   * Getter.
   **/
  public float getEvenRightCropBorder()
  {
    return evenRightCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setTopCropBorder(float topCropBorder)
  {
    this.topCropBorder_ = topCropBorder;
  }


  /**
   * Getter.
   **/
  public float getTopCropBorder()
  {
    return topCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setEvenTopCropBorder(float evenTopCropBorder)
  {
    this.evenTopCropBorder_ = evenTopCropBorder;
  }


  /**
   * Getter.
   **/
  public float getEvenTopCropBorder()
  {
    return evenTopCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setBottomCropBorder(float bottomCropBorder)
  {
    this.bottomCropBorder_ = bottomCropBorder;
  }


  /**
   * Getter.
   **/
  public float getBottomCropBorder()
  {
    return bottomCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setEvenBottomCropBorder(float evenBottomCropBorder)
  {
    this.evenBottomCropBorder_ = evenBottomCropBorder;
  }


  /**
   * Getter.
   **/
  public float getEvenBottomCropBorder()
  {
    return evenBottomCropBorder_;
  }


  /**
   * Setter.
   **/
  public void setDoTheScale(boolean doTheScale)
  {
    this.doTheScale_ = doTheScale;
  }


  /**
   * Getter.
   **/
  public boolean getDoTheScale()
  {
    return doTheScale_;
  }


  /**
   * Setter for input filename. IT MUST END WITH A ".pdf".
   **/
  public void setInFileName(String inFileName)
  {
    if (inFileName == null ||
        inFileName.equals("") ||
        !inFileName.endsWith(".pdf"))
      this.inFileName_ = DEFAULT_INPUT_FILENAME;
    else
      this.inFileName_ = inFileName;
  }


  /**
   * Getter.
   **/
  public String getInFileName()
  {
    return inFileName_;
  }


  /**
   * Setter.
   **/
  public void setOutFileName()
  {
    setOutFileName(null);
  }


  /**
   * Setter.
   **/
  public void setOutFileName(String outFileName)
  {
    if (outFileName == null || outFileName.equals(""))
      this.outFileName_ = this.inFileName_.substring(
                              0, this.inFileName_.length() - 4) + "-Crop.pdf";
    else
      this.outFileName_ = outFileName;
  }


  /**
   * Getter.
   **/
  public String getOutFileName()
  {
    return outFileName_;
  }


}