package jas.plot;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Hashtable;
/**
 * This class simply displays a given array of strings.  Use for a histogram with a string
 * partition, or if there are very specific labels (numeric or other) you want on the axis.
 * This class displays strings in two formats, represented by two static constants:
 * <ul>
 *  <li><code>CENTER_TEXT_IN_DIVISION</code>: a tick mark and label will be centered in a division</li>
 *  <li><code>TEXT_BESIDE_DIVISION</code>: a tick mark and label will be on either side of a division</li>
 * </ul>
 * <p>Use the method <code>setLabelPlacementStyle(int)</code> to change the setting.
 * <p>Labels are displayed in the order as they appear in the array given to the method
 * <code>setLabels(String[])</code> from left to right on a horizontal axis and from bottom to top
 * on a vertical axis.
 *  @see #CENTER_TEXT_IN_DIVISION
 *  @see #TEXT_BESIDE_DIVISION
 *  @see #setLabelPlacementStyle(int)
 *  @see #setLabels(String[])
 *  @author Jonas Gifford
 */
public final class StringAxis extends AxisType implements StringCoordinateTransformation
{
	/** Represents a display style where a tick and label are centered in a division. */
	public static final int CENTER_TEXT_IN_DIVISION = 1;

	/** Represents a display style where a tick and label are on either side of a division. */
	public static final int TEXT_BESIDE_DIVISION    = 2;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * begin constructors
 */
	/**
	 * Creates a new string axis type object, with labels and ticks centered in a division.
	 *  @see #CENTER_TEXT_IN_DIVISION
	 */
	public StringAxis()
	{
		this(CENTER_TEXT_IN_DIVISION);
	}

	/**
	 * Creates a new string axis type object.
	 *  @param labelPlacementStyle how to place labels (supply either <code>CENTER_TEXT_IN_DIVISION</code> or
	 *                             <code>TEXT_BESIDE_DIVISION</code>)
	 *  @see #CENTER_TEXT_IN_DIVISION
	 *  @see #TEXT_BESIDE_DIVISION
	 */
	public StringAxis(final int labelPlacementStyle)
	{
		this.labelPlacementStyle = labelPlacementStyle;
	}
/*
 * end constructors
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * begin public interface
 */
	/**
	 * Sets the label placement style.  Supply either <code>CENTER_TEXT_IN_DIVISION</code> or
	 * <code>TEXT_BESIDE_DIVISION</code>.
	 *  @see #CENTER_TEXT_IN_DIVISION
	 *  @see #TEXT_BESIDE_DIVISION
	 */
	public void setLabelPlacementStyle(final int labelPlacementStyle)
	{
		this.labelPlacementStyle = labelPlacementStyle;
	}

	/**
	 * Returns the label placement style: either <code>CENTER_TEXT_IN_DIVISION</code> or
	 * <code>TEXT_BESIDE_DIVISION</code>.
	 *  @see #CENTER_TEXT_IN_DIVISION
	 *  @see #TEXT_BESIDE_DIVISION
	 */
	public int getLabelPlacementStyle()
	{
		return labelPlacementStyle;
	}

	/** 
	 * Sets the labels to display.
	 */
	public void setLabels(String[] labels)
	{
		if (hash == null)
			hash = new Hashtable(labels.length);
		else
			hash.clear();
		this.labels = labels;
		for (int i = 0; i < labels.length; i++)
			hash.put(labels[i], new Integer(i));
		if (axis != null && axis.getAxisOrientation() == Axis.HORIZONTAL && (layers == null || layers.length != labels.length))
			layers = new int[labels.length];
		labelsValid = false; // we set this flag so that when the Axis object gets told to assume a new length
		                     // it knows that we need to calculate new space requirements (because of the new
		                     // labels)
	}

	/** Returns the labels used for this axis. */
	public String[] getLabels()
	{
		return labels;
	}
/*
 * end public interface
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * begin axis type methods
 */
	CoordinateTransformation getCoordinateTransformation()
	{
		return this;
	}
	void assumeAxisLength(final int lengthOfAxisLine)
	{
      if ( labels == null || labels.length == 0) return;
		labelsValid = true;

      Font font = axis.getFont();
		final FontMetrics fm = axis.getToolkit().getFontMetrics(font);

		final int distanceFromEnd = labelPlacementStyle == CENTER_TEXT_IN_DIVISION ?
			lengthOfAxisLine / labels.length / 2 : 0;

		if (axis.getAxisOrientation() == Axis.HORIZONTAL)
		{
			// the overflow is set here...
			if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
			{
				spaceRequirements.flowPastEnd = Math.max(fm.stringWidth(labels[labels.length - 1]) / 2 -
					lengthOfAxisLine / labels.length / 2, 0);
			}
			else
				spaceRequirements.flowPastEnd = fm.stringWidth(labels[labels.length - 1]) / 2;

			// then the width...
			spaceRequirements.width = Math.max(0, fm.stringWidth(labels[0]) / 2 - distanceFromEnd);

			// now for the height...
			// extraRows is the number of rows of text besides the first one
			int extraRows = 0;
			if (lengthOfAxisLine > 0)
			// this test fails only when the plot has been shrunk so far that the x axis has been
			// pushed to the right of the y axis but it is important to test for this because
			// if lengthOfAxisLine is negative we get an infinite regress where the int array
			// gets bigger and bigger until all of the memory is gone
			{
				int[] lastTakenPixelOnRow = new int[3];
				// we wouldn't really expect more than three rows, but we will expand if necessary

				final int n = labelPlacementStyle == TEXT_BESIDE_DIVISION ? labels.length - 1 : labels.length;
				int xStart = spaceRequirements.width + Axis.padAroundEdge;
				if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
					xStart += lengthOfAxisLine / labels.length / 2;
				for (int i = 0; i < labels.length; i++)
				{
					final int x = xStart + i * lengthOfAxisLine / n;
					int row = 0;
					final int halfOfStringWidth = fm.stringWidth(labels[i]) / 2;
					if (i != 0)
					{
						while (x - halfOfStringWidth < lastTakenPixelOnRow[row])
						{
							if (++row >= lastTakenPixelOnRow.length)
							{
								int[] newArray = new int[lastTakenPixelOnRow.length * 2];
								System.arraycopy(lastTakenPixelOnRow, 0, newArray, 0, lastTakenPixelOnRow.length);
								lastTakenPixelOnRow = newArray;
							}
						}
					}
					if (row > extraRows)
						extraRows = row;
					lastTakenPixelOnRow[row] = x + halfOfStringWidth + minSpaceBetweenLabels;
					layers[i] = row;
				}
			}
			spaceRequirements.height = fm.getMaxAscent() + fm.getMaxDescent() + Axis.padFromAxis
				// for each additional row we add the line height
				+ extraRows * fm.getHeight();
		}
		else
		{
			spaceRequirements.width = longestStringLength(fm,labels) + Axis.padFromAxis;
			spaceRequirements.height = Math.max(0, fm.getAscent() / 2 + fm.getMaxDescent() - distanceFromEnd);

			if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
			{
				spaceRequirements.flowPastEnd = Math.max(fm.getMaxAscent() - fm.getAscent() / 2 -
					lengthOfAxisLine / labels.length / 2, 0);
			}
			else
				spaceRequirements.flowPastEnd = fm.getMaxAscent() - fm.getAscent() / 2;
		}
	}
	void paintAxis(final PlotGraphics g, 
		final double originX, final double originY, final double length,
		final Color textColor, final Color majorTickColor, final Color minorTickColor)
	{
		if (labels != null)
		{
			final int n = labelPlacementStyle == TEXT_BESIDE_DIVISION ? labels.length - 1 : labels.length;
			final FontMetrics fm = g.getFontMetrics();
			if (axis.getAxisOrientation() == Axis.HORIZONTAL)
			{
				final double xStart = labelPlacementStyle == TEXT_BESIDE_DIVISION ? originX : originX + (length / labels.length) / 2;
				final double y = originY + fm.getMaxAscent() + Axis.padFromAxis;
				final double lineHeight = fm.getHeight();
				for (int i = 0; i < labels.length; i++)
				{
					final double x = xStart + i * length / n;
					g.setColor(majorTickColor);
					g.drawLine(x, originY + majorTickLength, x, originY - majorTickLength);
					g.setColor(textColor);
					g.drawString(labels[i], x - fm.stringWidth(labels[i]) / 2, y + layers[i] * lineHeight);
				}
			}
			else
			{
				final double x = axis.onLeftSide ? originX - Axis.padFromAxis : originX + Axis.padFromAxis;
				final double yStart = (labelPlacementStyle == TEXT_BESIDE_DIVISION ? originY : originY - (length / labels.length) / 2);
				final double height = fm.getAscent() / 2;
				for (int i = 0; i < labels.length; i++)
				{
					final double y = yStart - i * length / n;
					g.setColor(textColor);
					g.drawString(labels[i], axis.onLeftSide ? x - fm.stringWidth(labels[i]) : x, y + height);
					g.setColor(majorTickColor);
					g.drawLine(originX + majorTickLength, y, originX - majorTickLength, y);
				}
			}
		}
	}
	int getMajorTickMarkLength()
	{
		return majorTickLength;
	}
/*
 * end axis type methods
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * begin private methods
 */
   private int longestStringLength(FontMetrics fm, final String[] labels)
	{
		int longestLength = 0;
		for (int i = 0; i < labels.length; i++)
		{
			int length = fm.stringWidth(labels[i]);
			if (length > longestLength)
				longestLength = length;
		}
		return longestLength;
	}
	private double indexToLocation(int index)
	{
		final double minL = axis.getMinLocation();
		final double maxL = axis.getMaxLocation();
		if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
			return minL + (maxL - minL) * index / labels.length + ((maxL - minL) / labels.length) / 2;
		else
			return minL + (maxL - minL) * index / labels.length;
	}
/*
 * end private methods
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * begin coordinate transformation methods
 */
	public double convert(String s)
	{
		try
		{
			return indexToLocation(((Integer) hash.get(s)).intValue());
		}
		catch (Exception e)
		{
			return -1;
		}
	}
	public double binWidth()
	{
		return (double) (axis.getMaxLocation() - axis.getMinLocation()) / labels.length;
	}
/*
 * end coordinate transformation methods
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * begin externalization methods
 */
	public void writeExternal(final ObjectOutput out) throws IOException
	{
		out.writeInt(labelPlacementStyle);
	}
	public void readExternal(final ObjectInput in) throws IOException
	{
		labelPlacementStyle = in.readInt();
	}
/*
 * end externalization methods
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	private int labelPlacementStyle;
	private Hashtable hash;
	private final int majorTickLength = 5;
	private final int minorTickLength = 3;
	private final int minSpaceBetweenLabels = 3;
	private String[] labels;
	private int[] layers; // each element in this array holds the layer for the label in the corresponding
	                      // element of the above array
}