/*
 * PrintText.java - Short Description
 * Copyright (C) 1999 Scot Bellamy, ACTS, Inc.
 *
 * 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 org.jext.print;

import java.util.*;
import java.awt.print.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.font.*;
import javax.swing.*;
import javax.swing.text.*;


/**
 * A simple printing class to handle basic text printing.
 * Accepts an array of Strings or a PlainDocument and
 * prints all the lines contained there in.  Each String
 * in the array is assumed to be a separate line.
*/
public class PrintText
{

  private int numberOfpages_ = 0; // The number of pages
  private Book pages_ = new Book(); // This holds each page
  private int wrapOffset_ = 0; // Used to determine where to begin a wrapped line.
  private String docTitle_; // Used for document title (i.e. file name) when including the page header
  private String[] text_; // Text to print.
  private PrintingOptions printOptions_; // Print options (i.e. font, print header, etc.)
  private boolean softTabs_ = true; // Indicates whether soft or hard tabs are used.
  private int tabSize_ = 4; // Tab stop if hard tabs are used.

  /**
   * Constructor - Accepts a plain document and uses default font.
   * No header information will be printed.
  */
  public PrintText(PlainDocument document)
  {
    this(document, "", new PrintingOptions(), false, 4);
  }

  /**
   * Constructor - Accepts a plain document as well as  other print options,
   * including font, page title, and header indicator (true if printing header, false otherwise).
  */
  public PrintText(PlainDocument document, String docTitle, PrintingOptions printOptions, boolean softTabs, int tabSize)
  {
    printOptions_ = printOptions;
    softTabs_ = softTabs;
    tabSize_ = tabSize;

    if (docTitle != null)
    {
      docTitle_ = docTitle;
    } else {
      // If a new doc and no title, set docTitle to "New Document"
      docTitle_ = "New Document";
    }

    //  Get Root element of the document
    Element root = document.getDefaultRootElement();

    //get the number of lines (i.e. child elements)
    int count = root.getElementCount();

    //Allocate the array
    String lines[] = new String[count];

    Segment segment = new Segment();

    // Get each line element, get its text and put it in the string array
    for (int i = 0; i < count; i++)
    {
      Element lineElement = (Element) root.getElement(i);
      try
      {
        document.getText(lineElement.getStartOffset(), lineElement.getEndOffset() - lineElement.getStartOffset(),
                segment);
        lines[i] = segment.toString();
      }
      catch (BadLocationException ble)
      {
      } // Nothing gets added to the Array if there is a bad location
    }
    text_ = lines;
    printTextArray();
  }


  /**
   * Constructor - accepts an array of Strings, uses the default font, no header.
  */
  PrintText(String[] text)
  {
    printOptions_ = new PrintingOptions();
    text_ = text;
    printTextArray();
  }

  /**
   * Constructor - accepts an array of Strings and a font, no header.
  */
  PrintText(String[] text, Font font)
  {
    printOptions_ = new PrintingOptions();
    text_ = text;
    printTextArray();
  }


  /**
   * Where the print processing begins.
  */
  void printTextArray()
  {
    PageFormat pgfmt = printOptions_.getPageFormat();
    Font pageFont = printOptions_.getPageFont();
    try
    {
      PrinterJob job = PrinterJob.getPrinterJob(); // create a printjob
      //            pgfmt = job.pageDialog(pgfmt);                  // set a page format. Comment this if you do not want this to show
      //            pgfmt = job.validatePage(pgfmt);                // make sure the pageformat is ok

      text_ = removeEOLChar();

      if (printOptions_.getPrintLineNumbers() == true)
      {
        text_ = addLineNumbers();
      }
      if (printOptions_.getWrapText() == true)
      {
        text_ = wrapText();
      }

      pages_ = pageinateText(); // do the pagination

      try
      {
        job.setPageable(pages_); // set the book pageable so the printjob knows we are printing more than one page (maybe)
        if (job.printDialog())
        {
          job.print(); // print.  This calls each Page object's print method
        }
      }

      // catch any errors and be as ambiguous about them as possible :)
      catch (Exception e)
      {
        JOptionPane.showMessageDialog(null, "Printer Error", "Error", JOptionPane.OK_OPTION);
      }
    }
    catch (Exception e)
    {
      JOptionPane.showMessageDialog(null, "Printer Error", "Error", JOptionPane.OK_OPTION);
    }
  }

  /**
   * Eliminates end of line characters
  */
  private String[] removeEOLChar()
  {
    String temp1, temp2, temp3;
    int lineCount = text_.length;
    String [] newText = new String[lineCount];
    int offset = 0;

    for (int i = 0; i < lineCount; i++)
    {
      if (text_[i].length() == 1)
      {
        newText[i] = " ";
      }
      else
      {
        temp1 = text_[i].substring(text_[i].length() - 2, text_[i].length() - 1);
        temp2 = text_[i].substring(text_[i].length() - 1, text_[i].length());
        if (temp1.compareTo("\r") == 0 || temp1.compareTo("\n") == 0)
        {
          offset = 2;
        }
        else if (temp2.compareTo("\r") == 0 || temp2.compareTo("\n") == 0)
        {
          offset = 1;
        }
        else
        {
          offset = 0;
        }
        temp3 = text_[i].substring(0, text_[i].length() - offset);

        // Process tabs.  Assume tab stops.
        StringBuffer temp4 = new StringBuffer();
        int length = temp3.length();
        for (int j = 0; j < length; j++)
        {
          if ("\t".equals(temp3.substring(j, j + 1)) == true)
          {
            // Calcualte the numbe of spaces to the tab stop.
            int numSpaces = (temp4.length()) % tabSize_;

            if (numSpaces == 0)
            {
              numSpaces = tabSize_;
            }
            for (int x = 0; x < numSpaces; x++)
            {
              temp4.append(" ");
            }
          }
          else
          {
            temp4.append(temp3.substring(j, j + 1));
          }
        }
        newText[i] = temp4.toString();
      }
    }
    return newText;
  }



  /**
   * Addes line numbers to the beginning of each line.
  */
  private String[] addLineNumbers()
  {
    int numLines = text_.length;
    int totalNumSpaces = 0;
    String temp;
    String [] newText = new String[numLines];


    // Get the total number of digits in last line number
    // So that spacing and alignment can be done properly.
    Integer lines = new Integer(numLines);
    temp = lines.toString();
    totalNumSpaces = temp.length();

    // Set the wrap offset so that we can start wrapped lines in the proper place.
    wrapOffset_ = totalNumSpaces + 3;


    for (int i = 0; i < numLines; i++)
    {
      StringBuffer num = new StringBuffer();
      num.append(i + 1);
      int numLen = num.length();

      StringBuffer lineNum = new StringBuffer();

      for (int j = 0; j < (totalNumSpaces - numLen); j++)
      {
        lineNum.append(' ');
      }
      lineNum.append(num.toString());

      newText[i] = lineNum.toString() + ".  " + text_[i];
    }

    return newText;

  }

  /**
   * Creates a new array of lines that all fit the width of the page.
  */
  private String[] wrapText()
  {
    String currentLine = null;
    String tempString = null;
    Vector temp = new Vector();
    int lineCount = text_.length;
    int newLineCount = 0;
    StringBuffer wrapSpaces = new StringBuffer("");
    int i = 0;
    PageFormat pgfmt = printOptions_.getPageFormat();
    Font pageFont = printOptions_.getPageFont();
    double pageWidth = pgfmt.getImageableWidth();

    for (i = 0; i < wrapOffset_; i++)
    {
      wrapSpaces.append(' ');
    }

    for (i = 0; i < lineCount; i++)
    {
      currentLine = text_[i];
      while (pageFont.getStringBounds(currentLine,
              new FontRenderContext(pageFont.getTransform(), false, false)).getWidth() > pageWidth)
      {
        int numChars = (int)(currentLine.length() * pageWidth / pageFont.getStringBounds(currentLine,
                new FontRenderContext(pageFont.getTransform(), false, false)).getWidth());
        temp.add(currentLine.substring(0, numChars));
        currentLine = wrapSpaces.toString() + currentLine.substring(numChars, currentLine.length());
      }
      temp.add(currentLine);
    }

    newLineCount = temp.size();
    String [] newText = new String[newLineCount];

    for (int j = 0; j < newLineCount; j++)
    {
      newText[j] = (String) temp.get(j);
    }


    return newText;

  }



  /**
   * The pagination method, Paginate the text onto Printable page objects
  */
  private Book pageinateText()
  {

    Book book = new Book();
    int linesPerPage = 0; // lines on one page
    int currentLine = 0; // line I am  currently reading
    int pageNum = 0; // page #
    PageFormat pgfmt = printOptions_.getPageFormat();
    Font pageFont = printOptions_.getPageFont();
    int height = (int) pgfmt.getImageableHeight(); // height of a page
    int pages = 0; // number of pages

    linesPerPage = height / (pageFont.getSize() + 2); // number of lines on a page
    pages = ((int) text_.length / linesPerPage); // set number of pages
    String[] pageText; // one page of text
    String readString; // a temporary string to read from master string

    convertUnprintables(); // method to keep out errors

    if (printOptions_.getPrintHeader() == true)
    {
      linesPerPage = linesPerPage - 2;
    }

    while (pageNum <= pages)
    {

      pageText = new String[linesPerPage]; // create a new page
      for (int x = 0; x < linesPerPage; x++)
      {
        try
        {
          readString = text_[currentLine]; // read the string
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
          readString = " ";
        }
        pageText[x] = readString; // add to the page

        currentLine++;
      }
      pageNum++; // increase the page number I am on
      book.append(new Page(pageText, pageNum), pgfmt); // create a new page object with the text and add it to the book

    }
    return book; // return the completed book

  }

  /**
   * Converts unprintable things to a space.  stops some errors.
  */
  private void convertUnprintables()
  {
    String tempString;
    int i = text_.length;
    while (i > 0)
    {
      i--;
      tempString = text_[i];
      if (tempString == null || "".equals(tempString))
      {
        text_[i] = " ";
      }
    }
  }

  /**
   * An inner class that defines one page of text based
   * on data about the PageFormat etc. from the book defined
   * in the parent class
  */
  class Page implements Printable
  {

    private String[] pageText_; // the text for the page
    private int pageNumber_ = 0;

    Page(String[] text, int pageNum)
    {
      this.pageText_ = text; // set the page's text
      this.pageNumber_ = pageNum; // set page number.
    }

    /**
     * Defines the Printable print method, for printing a Page
    */
    public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) throws PrinterException // the printing part

    {
      int pos;
      int posOffset = 1;
      double pageWidth = pageFormat.getImageableWidth();
      Font pageFont = printOptions_.getPageFont();

      if (printOptions_.getPrintHeader() == true)
      {
        StringBuffer header = new StringBuffer();
        StringBuffer pageNumText = new StringBuffer();
        int i = 0;
        int headerPos = 0;
        int numSpaces = 0;

        Calendar date = Calendar.getInstance();
        header.append(date.get(Calendar.DAY_OF_MONTH));
        header.append('/');
        header.append(date.get(Calendar.MONTH) + 1);
        header.append('/');
        header.append(date.get(Calendar.YEAR));

        pageNumText.append("Page ");
        pageNumText.append(pageNumber_);

        int xPos;
        double margin = (pageFormat.getWidth() - pageFormat.getImageableWidth()) / 2;
        graphics.setFont(printOptions_.getHeaderFont());
        graphics.setColor(Color.black);
        pos = (int) pageFormat.getImageableY() + (printOptions_.getHeaderFont().getSize() + 2);
        graphics.drawString(header.toString(), (int) pageFormat.getImageableX(), pos); // draw a line of text
        xPos = (int)((pageFormat.getWidth() / 2) - (graphics.getFontMetrics().stringWidth(docTitle_) / 2));
        graphics.drawString(docTitle_, xPos, pos);
        xPos = (int)(pageFormat.getWidth() - margin - graphics.getFontMetrics().stringWidth(pageNumText.toString()));
        graphics.drawString(pageNumText.toString(), xPos, pos);
        posOffset = 3;
      }

      graphics.setFont(pageFont); // Set the font
      graphics.setColor(Color.black); // set color

      for (int x = 0; x < (pageText_.length); x++)
      {
        pos = (int) pageFormat.getImageableY() + (pageFont.getSize() + 2) * (x + posOffset);
        graphics.drawString(this.pageText_[x], (int) pageFormat.getImageableX(), pos); // draw a line of text
      }

      return Printable.PAGE_EXISTS; // print the page
    }

  }

  /**
   * An inner class that defines one section of printable text.
   * This allows the flexability to assign different fonts to
   * individual words or phrases (i.e. for headers/footers or
   * Syntax highlighting (pretty print).
  */
  class PrintableText
  {
    private Font font_;
    private boolean newLine_ = true;
    private String text_;

    PrintableText()
    {
    }

    PrintableText(String text, Font font, boolean newLine)
    {
      text_ = text;
      font_ = font;
      newLine_ = newLine;
    }

    String getText()
    {
      return text_;
    }

    void setText(String text)
    {
      text_ = text;
    }

    Font getFont()
    {
      return font_;
    }

    void setFont(Font font)
    {
      font_ = font;
    }

    boolean isNewLine()
    {
      return newLine_;
    }

    void setNewLine(boolean newLine)
    {
      newLine_ = newLine;
    }
  }
}

// End of PrintText.java