package com.whatever;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager2;

/**
 * The layout manager that organizes the components into
 * columns. Each column contains a pair of components; one
 * "prompt" and one "input field". The prompts within any
 * single column has the same width (the width of the widest
 * label, if possible). Similarly, the width of the input
 * fields is the same for all of the fields of that same
 * column. The input fields are also aligned. The height of
 * the components in the same row will be set to the height
 * of the tallest component.
 * <P>
 * If there's any extra space available, it'll be
 * partitioned among the input fields, by taking into
 * account the "weights" of the columns. By default, the
 * weights are equal for all the columns, but upon
 * instantiation, it might be changed.
 * <P>
 * The number of columns might be determined upon
 * instantiation, and it's immutable, but it is possible to
 * set the weights at any time.
 * <P>
 * When calculating the "needed" space, the preferred size
 * of the components will be used. In case not enough space
 * is available, the minimum size of all the components will
 * be used, then the extra available space upon the minimum
 * will be partitioned among the input fields according to
 * the weights. The prompts won't grow ever.
 * <P>
 * If there isn't enough space to provide even when using
 * the minimum sizes, then the input fields will shrink. In
 * this case, the columns with more weight will shrink less
 * (broadly speaking, a column with half the weight of the
 * other shrinks twice as much). However, effort is taken so
 * that no input field be shorter than the size needed by
 * the capital letter "M" to appear. If the available space
 * needed for any column is even less, the layout manager
 * tries to shrink another columns with greater weights. If
 * the width of the input fields of all column reached this
 * minimum size, and the available space is even less, the
 * layout manager shrinks the prompts. When worst comes to
 * worst, the prompts will disappear sooner than the input
 * fields.
 * <P>
 * When adding components to the container managed by the
 * InputLayout, the components added to the odd indices are
 * the prompts, and the ones added to the even indices are
 * the input fields. The layout manager never checks the
 * actual type of the components.
 * <P>
 * The component serving as a "prompt" should be the
 * immediate previous one of the associated "input field" it
 * serves. That is, the component index of the prompt in the
 * container must be one less than the component index of
 * the associated input field.
 * <P>
 * When there are more columns, the first pair of components
 * is added to the first column, the second pair of
 * components is added to the second column, and so on until
 * all the columns are populated. If more components are
 * still available, the next pair will be added to the
 * second row of the first column, and so on. If the number
 * of components is odd (that is, no input field is
 * available for the last "pair"), then that space will be
 * left empty, but the corresponding prompt won't be taken
 * into account when the layout manager calculates the width
 * of the "prompt" subcolumn of the corresponding column.
 * Rather, that single prompt may grow and occupy the space
 * which otherwise would be occupied by its associated input
 * field.
 * <P>
 * If both the prompt and the associated input field is
 * invisible, it won't taken into account when calculating
 * the space they needed, but their place will be left empty
 * by default. Therefore, when they made visible, the order
 * of the component pairs won't change. However, it is
 * possible to switch on or off this feature. When it is
 * switched off (no place holders are allowed for the
 * invisible component pairs), then once the pair is made
 * visible again, all of the component pairs following will
 * be shifted one column (and consequently may appear in the
 * next row if were put into the last column previously).
 * <P>
 * As it is now, InputLayout lays out the components from
 * left to right, and from top to bottom. However, after
 * calculating all the necessary information, a method with
 * the sole purpose to size and position the components is
 * called. This method gets the calculated sizes as
 * parameters. Therefore, the offsprings of InputLayout has
 * to redefine this method only if they want to change the
 * order in which the components are positioned.
 *
 * @author Istvan KETLER, Tekla SINKÓ
 *
 **/
public class InputLayout implements LayoutManager2 {

	private static enum InputLayoutType {
		PREFERRED, MINIMUM, MAXIMUM
	}

	/**
	 * Number of columns (determined at instantiation). One
	 * column actually means two columns: the prompt column
	 * and the input fields column.
	 **/
	private final int nrOfColumns;

	/**
	 * The weights of the columns.
	 **/
	private final int[] columnWeights;

	/**
	 * Is the place should be reserved for the invisible
	 * components?
	 **/
	private boolean isPlaceHolderAllowed = true;

	// The required space
	Dimension needed = null;
	// The "must-have" space
	Dimension badlyNeeded = null;

	/**
	 * Allows or forbids the use of place holders in the
	 * place of the invisible component pairs.
	 *
	 * @param allow
	 *            True if the use of the place holders is
	 *            allowed, false otherwise.
	 **/
	public void allowPlaceHolders(final boolean allow) {
		isPlaceHolderAllowed = allow;
	}

	/**
	 * Creates a layout where the components are organized
	 * into one column. Each column contains a pair of
	 * components (the "prompt" and the "input field"), and
	 * each column has the same (zero) weight.
	 **/
	public InputLayout() {
		this(1, null);
	}

	/**
	 * Creates a layout where the components are organized
	 * into the given number of columns, and each column has
	 * equal weight. Each column contains a pair of
	 * components (the "prompt" and the "input field").
	 *
	 * @param cols
	 *            The number of columns. It must be less
	 *            than 100 (that is the strict limit),
	 *            although more than a few might not have a
	 *            reasonable visual appearance.
	 **/
	public InputLayout(final int cols) {
		this(cols, null);
	}

	/**
	 * Creates a layout where the components are organized
	 * into the given number of columns, and each column has
	 * its given weight. The weight information will be
	 * ignored if the total sum of the provided weights
	 * exceeds 100, or if any of the remaining columns with
	 * undefined weight would have 0 weight. (An example is
	 * if there are 4 columns, and the first two have the
	 * weights of 49 and 50). In this case equal weights
	 * will be used for each column, as if no weight
	 * information would have been provided at all. Also
	 * note that in cases when the number of columns makes
	 * it impossible to partition the 100 equally (eg. in
	 * case of 3 columns), the last column gets the extra
	 * weight so that the total sum will always be exactly
	 * 100. If the weight of each column is explicitly
	 * given, but the total sum is less than 100, then the
	 * last column picks up all the remaining weight units.
	 *
	 * @param cols
	 *            The number of columns. It must be less
	 *            than 100 (that is the strict limit),
	 *            although more than a few might not have a
	 *            reasonable visual appearance.
	 * @param weights
	 *            The array of the weights (given in
	 *            percents). The total sum of the weights
	 *            should be 100. It is allowed to provide an
	 *            array which has less or more number of
	 *            elements than the number of columns. In
	 *            case of less columns, the undefined ones
	 *            will share the remaining space equally. In
	 *            case of more elements, the unnecessary
	 *            ones are ignored.
	 **/
	public InputLayout(final int cols, final int[] weights) {
		// Actually the max number of columns should be much
		// less.
		assert (cols < 100) : "Too many columns";

		nrOfColumns = cols;
		columnWeights = new int[nrOfColumns];

		// if no weights are specified
		if (weights == null) {
			setEqualWeights(0);
			// otherwise, initialize the weight information
		} else {
			int total = 0;

			// Calculate the total sum of weights - it
			// should be <= 100
			for (int i = 0; i < columnWeights.length; i++) {
				// Oops, more weights than columns!
				if (i >= weights.length) {
					setEqualWeights(i);
					break;
				}
				total += (columnWeights[i] = weights[i]);
			}

			// More than 100%? How could it be? So ignore
			// it!
			if (total > 100) {
				setEqualWeights(0);
			} else if (total < 100) {
				// The last column gets all of the remaining
				// space
				columnWeights[columnWeights.length - 1] += 100 - total;
			}
		}
	}

	/**
	 * Sets equal weights to the remaining columns. The
	 * method calculates the weight of the columns not
	 * involved, and provides the remaining value in equal
	 * pieces to the remaining columns. The total sum of all
	 * the column weights should be 100.
	 *
	 * @param cols
	 *            The first column which is involved.
	 **/
	protected void setEqualWeights(int cols) {
		// This could never happen...
		assert (cols < columnWeights.length) : "The column index is greater than the number of columns!";

		int len = columnWeights.length;

		// Were it called from the constructor, this code
		// has no use...
		// If only the first few columns would have been
		// determined weight
		int used = 0;
		for (int i = 0; i < cols; i++) {
			used += columnWeights[i];
		}
		// Not enough space for the remaining columns
		if (used > (100 - (len - cols))) {
			used = 0;
			cols = 0;
		}
		// end of "has no use" code

		int free = 100 - used;
		int remcols = len - cols;

		// The percents of the remaining columns
		// Be aware, w * remcols may or may not equal to
		// free! (divide int)
		int w = free / remcols;
		for (int i = cols; i < (len - 1); i++) {
			used += w;
			columnWeights[i] = w;
		}
		// The last column gets all of the remaining space
		columnWeights[len - 1] = 100 - used;
	}

	/**
	 * Calculates the minimum, preferred, or maximum sizes
	 * of the columns.
	 *
	 * @param target
	 *            The container which size should be
	 *            calculated.
	 * @param nComp
	 *            The number of components added to the
	 *            container.
	 * @param nrOfRows
	 *            The number of rows the components will be
	 *            laid out.
	 * @param type
	 *            The actual size should be used. The value
	 *            might be MINIMUM, MAXIMUM, or PREFERRED.
	 * @returns An array of arrays containing the sizes. The
	 *          first two array gives the widths of the
	 *          columns: the widths of the prompt subcolumn
	 *          and the widths of the input field subcolumn.
	 *          The third array gives the heights of the
	 *          rows.
	 **/
	private int[][] calculateDimensions(final Container target, final int nComp, final int nrOfRows, final InputLayoutType type) {
		// The return array
		int[][] retArray = new int[3][];

		// By default, all of the elements of the arrays are
		// initialized by 0.
		// The width of the prompts
		int[] promptWidths = new int[nrOfColumns];
		// The width of the input fields
		int[] fieldWidths = new int[nrOfColumns];
		// The heights of the rows
		int[] heights = new int[nrOfRows];

		// Initialize the return array
		retArray[0] = promptWidths;
		retArray[1] = fieldWidths;
		retArray[2] = heights;

		// The next component
		Component theComponent = null;
		// Size of the prompt
		Dimension pdim = null;
		// Size of the input field
		Dimension fdim = null;
		// The actual component
		int currentComponent = 0;
		// For each row
		for (int currentRow = 0; currentRow < nrOfRows; currentRow++) {
			int height = 0;
			// for each column (However, the column is
			// increased only if
			// either the place holder is allowed, or one of
			// the two
			// components forming the column is visible)
			for (int col = 0; col < nrOfColumns;) {
				// checks which sub-column exists (prompt
				// and input field)
				int subcols = 0;

				if (currentComponent >= nComp) {
					// no more components are available
					break;
				}
				// The next component
				theComponent = target.getComponent(currentComponent++);
				// The component exists and is visible
				if ((theComponent != null) && theComponent.isVisible()) {
					// The prompt is visible
					subcols |= 1;
					// pdim gets the selected size of the
					// component
					switch (type) {
						case MINIMUM:
							pdim = theComponent.getMinimumSize();
							break;
						case MAXIMUM:
							pdim = theComponent.getMaximumSize();
							break;
						default:
						case PREFERRED:
							pdim = theComponent.getPreferredSize();
							break;
					}
				}

				// The very last input field may not exist
				if (currentComponent < nComp) {
					theComponent = target.getComponent(currentComponent++);
					// The component exists and is visible
					if ((theComponent != null) && theComponent.isVisible()) {
						// The input field is visible
						subcols |= 2;
						// fdim gets the selected size of
						// the component
						switch (type) {
							case MINIMUM:
								fdim = theComponent.getMinimumSize();
								break;
							case MAXIMUM:
								fdim = theComponent.getMaximumSize();
								break;
							default:
							case PREFERRED:
								fdim = theComponent.getPreferredSize();
								break;
						}
					}
				}

				// If the place holder is allowed, of if one
				// of the sub-columns is visible
				if (isPlaceHolderAllowed || (subcols > 0)) {
					// if only the label is visible, there's
					// nothing to do.
					// That is, no label is allowed to be
					// longer than the width
					// of the sum of the prompt and the
					// input field columns
					switch (subcols) {
						case 3: {
							// Finding the widest prompt in
							// the column
							promptWidths[col] = Math.max(promptWidths[col], pdim.width);
							// Finding the max height in
							// this row
							height = Math.max(height, pdim.height);
							// continues with the next case
						}
						case 2: {
							// Finding the widest input
							// field in the column
							fieldWidths[col] = Math.max(fieldWidths[col], fdim.width);
							// Finding the max height in
							// this row
							height = Math.max(height, fdim.height);
							break;
						}
					}
					// The column number is increased only
					// if either the place
					// holder is allowed, or at least one of
					// the components
					// out of the two is visible.
					col++;
				}
			}
			// Store the calculated max height of the row
			heights[currentRow] = height;
			// No more components
			if (currentComponent >= nComp) {
				break;
			}
		}

		return retArray;
	}

	private Dimension calculateLayoutSize(final Container target, final InputLayoutType inputLayout,
			final int columnSeparatingWidth, final int rowSeparatingHeight){
		int nComp = target.getComponentCount();

		// The number of actual rows might be less if there
		// are invisible components added to the container.
		int nrOfRows = (((nComp / 2) + nrOfColumns) - 1) / nrOfColumns;

		int[][] dims = calculateDimensions(target, nComp, nrOfRows, inputLayout);
		int[] promptWidths = dims[0];
		int[] fieldWidths = dims[1];
		int[] heights = dims[2];

		// Sum up the widths of the columns
		// (the columns are separated by columnSeparatingWidth pixels):
		int w = columnSeparatingWidth;
		for (int i = 0; i < nrOfColumns; i++) {
			w += promptWidths[i];
			w += fieldWidths[i];
			w += columnSeparatingWidth;
		}

		// If the number of rows is less than it was
		// calculated, the unoccupied
		// rows will have the height of 0 due to how
		// Java initializes the arrays.
		int h = rowSeparatingHeight;
		for (int i = 0; i < nrOfRows; i++) {
			h += heights[i];
			h += rowSeparatingHeight;
		}

		// The insets values should be taken into account
		Insets ins = target.getInsets();
		w += ins.left + ins.right;
		h += ins.top + ins.bottom;

		return new Dimension(w, h);
	}

	/**
	 * Calculates the minimum size this container needs in
	 * order to lay out all of the components it contains.
	 * Upon calculation, only the space needed by the
	 * visible components will taken into account. If both
	 * element of a prompt/input field pair are invisible,
	 * then depending on the current setting of the place
	 * holders, the next pair still appears in its own
	 * column, or replaces the invisible pair.
	 *
	 * @param target
	 *            The container of which the minimum size
	 *            should be calculated.
	 * @returns The dimension minimally needed to lay out
	 *          the container.
	 * @see #allowPlaceHolders(boolean)
	 *
	 * @see java.awt.LayoutManager#minimumLayoutSize(java.awt.Container)
	 */
	@Override
	public Dimension minimumLayoutSize(final Container target) {
		InputLayoutType inputLayout = InputLayoutType.MINIMUM;
		int columnSeparatingWidth = 0;
		int rowSeparatingHeight = 0;
		return calculateLayoutSize(target, inputLayout, columnSeparatingWidth, rowSeparatingHeight);
	}

	/**
	 * Calculates the preferred size this container needs in
	 * order to lay out all of the components it contains.
	 * Upon calculation, only the space needed by the
	 * visible components will taken into account. If both
	 * element of a prompt/input field pair are invisible,
	 * then depending on the current setting of the place
	 * holders, the next pair still appears in its own
	 * column, or replaces the invisible pair.
	 *
	 * @param target
	 *            The container of which the preferred size
	 *            should be calculated.
	 * @returns The dimension preferably needed to lay out
	 *          the container.
	 * @see #allowPlaceHolders(boolean)
	 *
	 * @see java.awt.LayoutManager#preferredLayoutSize(java.awt.Container)
	 */
	@Override
	public Dimension preferredLayoutSize(final Container target) {
		InputLayoutType inputLayout = InputLayoutType.PREFERRED;
		// the columns are separated by 4 pixels:
		int columnSeparatingWidth = 4;
		// the rows are separated by 4 pixels:
		int rowSeparatingHeight = 4;
		return calculateLayoutSize(target, inputLayout, columnSeparatingWidth, rowSeparatingHeight);
	}

	/**
	 * Calculates the maximum size this container needs in
	 * order to lay out all of the components it contains.
	 * Upon calculation, only the space needed by the
	 * visible components will taken into account. If both
	 * element of a prompt/input field pair are invisible,
	 * then depending on the current setting of the place
	 * holders, the next pair still appears in its own
	 * column, or replaces the invisible pair.
	 *
	 * @param target
	 *            The container of which the maximum size
	 *            should be calculated.
	 * @returns The maximum dimension needed to lay out the
	 *          container.
	 * @see #allowPlaceHolders(boolean)
	 *
	 * @see java.awt.LayoutManager2#maximumLayoutSize(java.awt.Container)
	 */
	@Override
	public Dimension maximumLayoutSize(final Container target) {
		InputLayoutType inputLayout = InputLayoutType.MAXIMUM;
		int columnSeparatingWidth = 0;
		// the rows are separated by 4 pixels:
		int rowSeparatingHeight = 0;
		return calculateLayoutSize(target, inputLayout, columnSeparatingWidth, rowSeparatingHeight);
	}

	/**
	 * Laying out the components in the container.
	 *
	 * @see java.awt.LayoutManager#layoutContainer(java.awt.Container)
	 */
	@Override
	public void layoutContainer(final Container target) {
		// Number of components
		int nComp = target.getComponentCount();

		// The number of actual rows might be less if there
		// are invisible
		// components added to the container.
		int nrOfRows = (((nComp / 2) + nrOfColumns) - 1) / nrOfColumns;

		// The current size of the container
		Dimension dim = target.getSize();
		Insets insets = target.getInsets();

		// The space remaining for the components. Note that
		// in case of
		// negative insets, the space is bigger
		int currentWidth = dim.width - (insets.left + insets.right);
//		int currentHeight = dim.height - (insets.top + insets.bottom);

		if (needed == null) {
			needed = preferredLayoutSize(target);
			needed.setSize(needed.width - (insets.left + insets.right), needed.height - (insets.top + insets.bottom));
		}

		if (currentWidth >= needed.width) {
			int[][] dims = calculateDimensions(target, nComp, nrOfRows, InputLayoutType.PREFERRED);
			double extra = currentWidth - needed.width;
			createActualLayout(target, extra, dims, 2);
		} else {
			if (badlyNeeded == null) {
				badlyNeeded = minimumLayoutSize(target);
				badlyNeeded.setSize(badlyNeeded.width - (insets.left + insets.right), badlyNeeded.height
						- (insets.top + insets.bottom));
			}
			if (currentWidth >= badlyNeeded.width) {
				int[][] dims = calculateDimensions(target, nComp, nrOfRows, InputLayoutType.MINIMUM);
				double extra = currentWidth - badlyNeeded.width;
				createActualLayout(target, extra, dims, 0);
			} else {
				// shrink
				int[][] dims = calculateDimensions(target, nComp, nrOfRows, InputLayoutType.MINIMUM);
				createActualLayout(target, 0.0d, dims, 0);
			}
		}
	}

	/**
	 * Distributes the extra space among the columns.
	 *
	 * @param target
	 *            The container which contains the
	 *            components.
	 * @param extra
	 *            The extra space that should be distributed.
	 * @param dims
	 *            The array of int arrays which contains the
	 *            already calculated width and height
	 *            informations. The first subarray is the
	 *            widths of the prompt subcolumns, and the
	 *            second one is the widths of the input
	 *            field subcolumns. The third subarray
	 *            contains the heights of the rows.
	 * @param ins
	 *            The gap between the subcolumns. This gap
	 *            should be used before and after of each
	 *            component. The same gap also should be
	 *            used above and below of each component.
	 */
	private void createActualLayout(final Container target, final double extra, final int[][] dims, final int ins) {
		int[] fieldWidths = dims[1];
		int all = 0;
		if (extra > 0) {
			for (int i = 0; i < nrOfColumns; i++) {
				int add = (int) ((extra * columnWeights[i]) / 100);
				all += add;
				fieldWidths[i] += add;
			}
		}
		if (all != extra) {
			fieldWidths[nrOfColumns - 1] += extra - all;
		}
		layoutComponents(target, dims, ins);
	}

	/**
	 * Lays out the components on the container. Sizing and
	 * locating the components is done from left to right,
	 * and from top to bottom.
	 *
	 * @param target
	 *            The container which contains the
	 *            components.
	 * @param dims
	 *            The array of int arrays which contains the
	 *            already calculated width and height
	 *            informations. The first subarray is the
	 *            widths of the prompt subcolumns, and the
	 *            second one is the widths of the input
	 *            field subcolumns. The third subarray
	 *            contains the heights of the rows.
	 * @param ins
	 *            The gap between the subcolumns. This gap
	 *            should be used before and after of each
	 *            component. The same gap also should be
	 *            used above and below of each component.
	 **/
	protected void layoutComponents(final Container target, final int[][] dims, final int ins) {
		int nComp = target.getComponentCount();

		int[] promptWidths = dims[0];
		int[] fieldWidths = dims[1];
		int[] heights = dims[2];

		Insets insets = target.getInsets();

		int gap = ins + ins;

		Component prompt = null;
		Component field = null;

		int currentComponent = 0;
		int top = insets.top + gap;
		for (int currentRow = 0; currentRow < heights.length; currentRow++) {
			int left = insets.left + ins;
			for (int col = 0; col < nrOfColumns;) {
				int subcols = 0;
				if (currentComponent >= nComp) {
					// no more components are available
					break;
				}
				prompt = target.getComponent(currentComponent++);
				if ((prompt != null) && prompt.isVisible()) {
					subcols |= 1;
				}

				if (currentComponent < nComp) {
					field = target.getComponent(currentComponent++);
					if ((field != null) && field.isVisible()) {
						subcols |= 2;
					}
				}

				if (isPlaceHolderAllowed || (subcols > 0)) {
					switch (subcols) {
						// Only the prompt exists and/or is
						// visible.
						case 1: {
							prompt.setBounds(left, top, promptWidths[col] + fieldWidths[col] + gap, heights[currentRow]);
							break;
						}
						// Both the prompt and the input
						// field exist and are visible.
						case 3: {
							prompt.setBounds(left, top, promptWidths[col], heights[currentRow]);
							// continues with the next case
						}
						// Only the input field exists
						// and/or is visible.
						case 2: {
							field.setBounds(left + promptWidths[col] + gap, top, fieldWidths[col], heights[currentRow]);
							break;
						}
					}
					left += promptWidths[col] + gap;
					left += fieldWidths[col] + ins;
					col++;
				}
			}
			top += heights[currentRow] + gap;
			if (currentComponent >= nComp) {
				break;
			}
		}
	}

	/**
	 * Adds the component to the layout. This method is
	 * provided for compatibility considerations, and
	 * delegates the call to the newer form of the
	 * overloaded method.
	 *
	 * @see #addLayoutComponent(java.awt.Component,
	 *      java.lang.Object)
	 **/
	@Override
	public void addLayoutComponent(final String name, final Component comp) {
		this.addLayoutComponent(comp, name);
	}

	/**
	 * Adds the component to the layout. This operation
	 * invalidates the layout.
	 *
	 * @see java.awt.LayoutManager2#addLayoutComponent(java.awt.Component, java.lang.Object)
	 **/
	@Override
	public void addLayoutComponent(final Component comp, final Object constraints) {
		doInvalidate();
	}

	/**
	 * Removes the component from the layout. This operation
	 * invalidates the layout.
	 *
	 * @see java.awt.LayoutManager#removeLayoutComponent(java.awt.Component)
	 */
	@Override
	public void removeLayoutComponent(final Component comp) {
		doInvalidate();
	}

	/**
	 * Invalidates the information stored by the layout
	 * manager. The only information currently cached is the
	 * dimension of the preferred and the minimum size of
	 * the container.
	 *
	 * @see java.awt.LayoutManager2#invalidateLayout(java.awt.Container)
	 */
	@Override
	public void invalidateLayout(final Container target) {
		doInvalidate();
	}

	/**
	 * Performs the invalidate layout functionality. That
	 * is, deletes all of the cached information about the
	 * layout.
	 **/
	private void doInvalidate() {
		needed = null;
		badlyNeeded = null;
	}

	/**
	 * Provides alignment information. This is a no-op.
	 *
	 * @see java.awt.LayoutManager2#getLayoutAlignmentX(java.awt.Container)
	 */
	@Override
	public float getLayoutAlignmentX(final Container target) {
		return 0.0f;
	}

	/**
	 * Provides alignment information. This is a no-op.
	 *
	 * @see java.awt.LayoutManager2#getLayoutAlignmentY(java.awt.Container)
	 */
	@Override
	public float getLayoutAlignmentY(final Container target) {
		return 0.0f;
	}

}