package tio;

import java.io.*;
import java.text.*;

/**
 * The class <code>FormattedWriter</code> contains
 * methods that allow for formatted printing. 
 * It includes support for setting the width of the
 * output field, using left or right justification in
 * the output field, using an arbitrary fill
 * character, and setting the number of digits to the
 * right of the decimal point in floating point
 * values.
 *
 * @author C. E. McDowell
 * @version 1.2 corrected problem with floats with exponents.
 */
public class FormattedWriter extends PrintWriter {
  // constants for specifying justification
  public static final int LEFT = 1;
  public static final int RIGHT = 2;

  /**
   * Constructs a FormattedWriter object for an
   * OutputStream.
   *
   * @param os the OutputStream to write to
   */
  public FormattedWriter(OutputStream os) {
    super(os, true); // make default auto-flushing
  }

  /**
   * Constructs a FormattedWriter object for a
   * FileWriter.
   *
   * @param writer the FileWriter to write to
   */
  public FormattedWriter(FileWriter writer) {
    super(writer, true);
  }

  /**
   * Constructs a FormattedWriter object for writing
   * to a file.
   *
   * @param filename the name of the file to write to
   */
  public FormattedWriter(String filename)
    throws java.io.IOException
  {
    this(new FileWriter(filename));
  }

  /**
   * Set the output field width. If the value being
   * printed is less than the width of the field, then
   * the field will be padded with the pad character
   * (see setPadChar()). The field can be either left
   * or right justified (see setJustify()).
   *
   * @param width the width of the output field
   */
  public void setWidth(int width) {
    if (width < 0)
      this.width = 0;
    else if (width > MAX_WIDTH)
      this.width = MAX_WIDTH;
    else 
      this.width = width;
  }

  /**
   * Set the number of digits to be printed to the
   * right of the decimal point in floating point
   * values.
   *
   * @param places the number of places to the right
   *    of the decimal point
   */
  public void setDigits(int places) {
    decimalPlaces = places;
    form.setMaximumFractionDigits(decimalPlaces);
  }

  /**
   * Set the justification to be LEFT or RIGHT.
   *
   * @param leftOrRight use FormattedWriter.LEFT 
   *    or FormattedWriter.RIGHT
   * @exception IllegalArgumentException if not LEFT 
   *    or RIGHT
   */
  public void setJustify(int leftOrRight) {
    if (leftOrRight != LEFT && leftOrRight != RIGHT)
      throw new IllegalArgumentException(
        "use FormattedWriter.LEFT or" +
        " FormattedWriter.RIGHT");
    justify = leftOrRight;
  }

  /**
   * Set the character to be used in padding. 
   * The default padding character is a blank.
   *
   * @param pad the character to use in padding
   */
  public void setPadChar(char pad) { 
    if (pad == ' ')
      padding = spaces;
    else if (pad == '0')
      padding = zeros;
    else
      padding = buildPadding(MAX_WIDTH, pad);
  }

  /**
   * Print a String in a field of the current
   * width using the current padding character 
   * and justification.
   *
   * @param s the String to print
   */
  public void printf(String s) {
    if (s.length() >= width)
      super.print(s);
    else if (justify == LEFT)
      super.print(s + 
          padding.substring(0, width - s.length()));
    else
      super.print(
          padding.substring(0, width - s.length()) + s);
  }


  /**
   * Print a boolean in a field of the current 
   * width, using the current padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(boolean value) {
    printf(String.valueOf(value));
  }

  /**
   * Print a char in a field of the current 
   * width, using the current padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(char value) {
    printf(String.valueOf(value));
  }

  /**
   * Print an array of characters in a field of the current 
   * width, using the current padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(char[] value) {
    printf(String.valueOf(value));
  }

  /**
   * Print an int in a field of the current 
   * width, using the current padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(int value) {
    printf(String.valueOf(value));
  }

  /**
   * Print a long in a field of the current 
   * width, using the current padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(long value) {
    printf(String.valueOf(value));
  }

  /**
   * Print any Object in a field of the current 
   * width, using the current padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(Object value) {
    printf(value.toString());
  }

  /**
   * Print a double in a field of the current 
   * width, with the current number of digits to the
   * right of the decimal point and using the current
   * padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(double value) { 
    printf(trimDigits(String.valueOf(value)));
  }

  /**
   * Print a float in a field of the current 
   * width, with the current number of digits to the
   * right of the decimal point and using the current
   * padding character and justification.
   *
   * @param value the value to print
   */
  public void printf(float value) {
    printf(trimDigits(String.valueOf(value)));
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(String s) {
    printf(s);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(boolean value) {
    printf(value);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(char value) {
    printf(value);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(char[] value) {
    printf(value);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(int value) {
    printf(value);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(long value) {
    printf(value);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(Object value) {
    printf(value);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(double value) {
    printf(value);
    println();
  }

  /**
   * Same as printf() with a newline added at the end.
   */
  public void printfln(float value) {
    printf(value);
    println();
  }

  /*
   * Trim the number of digits to the right of the
   * decimal point if there is one.
  */
  private String trimDigits(String value) {
    int places;

    if (decimalPlaces == -1)
      return value;
    int pos = value.indexOf(".");
    int exp = value.indexOf("E");
    if (exp == -1)
      places = value.length() - pos - 1;
    else
      places = exp - pos - 1;
    if (places <= decimalPlaces)
        return value;
    if (exp == -1)
      return round(value);
    else {
	String needsRounding = value.substring(0, exp);
      return round(needsRounding) +
          value.substring(exp);
    }
  }

  /*
   * Round the last digit of s. E.g. 1.2345 would be
   * returned as 1.235 and 1.234 would be returned as
   * 1.23.
   * This is done using a java.text.NumberFormat 
   * object that had its decimal places set in
   * setDigits() above.
   */
  private String round(String s) {
    // form is a java.text.NumberFormat object
    return form.format(Double.parseDouble(s));
  }

  /*
   * Create an array of pad characters used for
   * quickly building strings of pad characters
   * by a call to substring (see printfln(String s))
  */
  private static String buildPadding(int width,
                                     char pad)
  {
    StringBuffer sbuf = new StringBuffer(width);
    for (int i = 0; i < width; ++i)
      sbuf.append(pad);
    return sbuf.toString();
  }

  private static int MAX_WIDTH = 40;
  private static final String spaces =
      buildPadding(MAX_WIDTH, ' ');
  private static final String zeros =
      buildPadding(MAX_WIDTH, '0');
  private String padding = spaces;
  private int width = 0;
  private int justify = LEFT;

  // -1 means use max precision
  private int decimalPlaces = -1;
  // used in trimming decimal digits
  private NumberFormat form =
       NumberFormat.getInstance();
}