import java.awt.*;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;

/**
 *  The CompoundIcon will paint two, or more, Icons as a single Icon. The
 *  Icons are painted in the order in which they are added.
 *
 *  The Icons are layed out on the specified axis:
 * <ul>
 * <li>X-Axis (horizontally)
 * <li>Y-Axis (vertically)
 * <li>Z-Axis (stacked)
 * </ul>
 *
 */
public class CompoundIcon implements Icon
{
	public enum Axis
	{
		X_AXIS,
		Y_AXIS,
		Z_AXIS;
	}

	public final static float TOP = 0.0f;
	public final static float LEFT = 0.0f;
	public final static float CENTER = 0.5f;
	public final static float BOTTOM = 1.0f;
	public final static float RIGHT = 1.0f;

	private Icon[] icons;
	private Rectangle[] bounds;
	private HashMap<Component, Point> iconOffset = new HashMap<Component, Point>();

    private Axis axis;

	private int gap;

    private float alignmentX = CENTER;
    private float alignmentY = CENTER;

	/**
	 *  Convenience contructor for creating a CompoundIcon where the
	 *  icons are layed out on on the X-AXIS, the gap is 0 and the
	 *  X/Y alignments will default to CENTER.
	 *
	 *  @param icons  the Icons to be painted as part of the CompoundIcon
	 */
    public CompoundIcon(Icon... icons)
    {
    	this(Axis.X_AXIS, icons);
    }

	/**
	 *  Convenience contructor for creating a CompoundIcon where the
	 *  gap is 0 and the X/Y alignments will default to CENTER.
	 *
	 *  @param axis   the axis used to lay out the icons for painting.
	 *                Must be one of the Axis enums: X_AXIS, Y_AXIS, Z_Axis.
	 *  @param icons  the Icons to be painted as part of the CompoundIcon
	 */
    public CompoundIcon(Axis axis, Icon... icons)
    {
    	this(axis, 0, icons);
    }

	/**
	 *  Convenience contructor for creating a CompoundIcon where the
	 *  X/Y alignments will default to CENTER.
	 *
	 *  @param axis   the axis used to lay out the icons for painting
	 *                Must be one of the Axis enums: X_AXIS, Y_AXIS, Z_Axis.
	 *  @param gap    the gap between the icons
	 *  @param icons  the Icons to be painted as part of the CompoundIcon
	 */
	public CompoundIcon(Axis axis, int gap, Icon... icons)
	{
    	this(axis, gap, CENTER, CENTER, icons);
	}

	/**
	 *  Create a CompoundIcon specifying all the properties.
	 *
	 *  @param axis        the axis used to lay out the icons for painting
	 *                     Must be one of the Axis enums: X_AXIS, Y_AXIS, Z_Axis.
	 *  @param gap         the gap between the icons
	 *  @param alignmentX  the X alignment of the icons. Common values are
	 *                     LEFT, CENTER, RIGHT. Can be any value between 0.0 and 1.0
	 *  @param alignmentY  the Y alignment of the icons. Common values are
	 *                     TOP, CENTER, BOTTOM. Can be any value between 0.0 and 1.0
	 *  @param icons       the Icons to be painted as part of the CompoundIcon
	 */
	public CompoundIcon(Axis axis, int gap, float alignmentX, float alignmentY, Icon... icons)
	{
		this.axis = axis;
		this.gap = gap;
		this.alignmentX = alignmentX > 1.0f ? 1.0f : alignmentX < 0.0f ? 0.0f : alignmentX;
		this.alignmentY = alignmentY > 1.0f ? 1.0f : alignmentY < 0.0f ? 0.0f : alignmentY;

		for (int i = 0; i < icons.length; i++)
		{
			if (icons[i] == null)
			{
				String message = "Icon (" + i + ") cannot be null";
				throw new IllegalArgumentException( message );
			}
		}

		this.icons = icons;

		determineIconBounds();
	}

	/**
	 *  Get the Axis along which each icon is painted.
	 *
	 *  @return the Axis
	*/
	public Axis getAxis()
	{
		return axis;
	}

	/**
	 *  Get the gap between each icon
	 *
	 *  @return the gap in pixels
	 */
	public int getGap()
	{
		return gap;
	}

	/**
	 *  Get the alignment of the icon on the x-axis
	 *
	 *  @return the alignment
	 */
	public float getAlignmentX()
	{
		return alignmentX;
	}

	/**
	 *  Get the alignment of the icon on the y-axis
	 *
	 *  @return the alignment
	 */
	public float getAlignmentY()
	{
		return alignmentY;
	}

	/**
	 *  Get the number of Icons contained in this CompoundIcon.
	 *
	 *  @return the total number of Icons
	 */
	public int getIconCount()
	{
		return icons.length;
	}

	/**
	 *  Get the Icon at the specified index.
	 *
	 *  @param index  the index of the Icon to be returned
	 *  @return  the Icon at the specifed index
	 *  @exception IndexOutOfBoundsException  if the index is out of range
	 */
	public Icon getIcon(int index)
	{
		return icons[ index ];
	}

	/**
	 *  Get IconInformation at the specified point for a given component. The
	 *  icon information will include the icon, the bounds of the icon and the
	 *  Point relative to the icon. null is returned when no icon is found at
	 *  the specified point.
	 *
	 *  @param point  A specific point of the component.
	 *  @param component the component which is displaying the CompoundIcon
	 *  @return  IconInfo of the Icon at the specifed point or null.
	 */
	public IconInfo getIconInfoAtPoint(Point point, Component component)
	{
		//  An Icon can be shared by multiple components. Get the offset where
		//  this Icon was painted.

		Point offset = iconOffset.get(component);

		if (offset != null)
		{
			point.x -= offset.x;
			point.y -= offset.y;
		}

		//  Start searching Icon bound from the last Icon painted in case
		//  Icons overlap one another.

		for (int i = bounds.length - 1; i >= 0; i--)
		{
			Rectangle r = bounds[i];

			if ( r.contains(point) )
			{
				Icon icon = icons[i];

				//  Recursively invoke this method, this time with a null
				//  component, since the offset has been recalculated.

				if (icon instanceof CompoundIcon)
				{
					CompoundIcon compound = (CompoundIcon)icon;
					return compound.getIconInfoAtPoint(new Point(point.x - r.x, point.y - r.y), null);
				}
				else
				{
                	Point p = new Point(point.x - r.x, point.y - r.y);
                	return new IconInfo(icon, r, p);
				}
			}
		}

		return null;
	}


	/*
	 *  Get IconInfo for every Icon
	 *
	 *  @return  IconInfo for every Icon.
	 *
	 */
	public List<IconInfo> getIconInfo()
	{
		ArrayList<IconInfo> list = new ArrayList<IconInfo>();
		Point offset = new Point(0, 0);
        getIconInfo(list, offset);

		return list;
	}

	private void getIconInfo(ArrayList<IconInfo> list, Point offset)
	{
		for (int i = 0; i < icons.length; i++)
		{
			Rectangle r = bounds[i];

			if (icons[i] instanceof CompoundIcon)
			{
				CompoundIcon compound = (CompoundIcon)icons[i];
				compound.getIconInfo(list, new Point(offset.x + r.x, offset.y + r.y));
			}
			else
			{
				r = new Rectangle(r.x + offset.x, r.y + offset.y, r.width, r.height);
				list.add( new IconInfo(icons[i], r, null) );
			}
		}
	}

	/*
	 *  Helper class to contain information about an Icon contained in the
	 *  CompoundIcon. The bounds will always be returned for the specified
	 *  Icon. The relative point is only returned when a lookup for a single
	 *  Icon was done for a specific point. Otherwise (0, 0) is returned.
	 */
	static class IconInfo
	{
		private Icon icon;
		private Rectangle bounds;
		private Point point;

		public IconInfo(Icon icon, Rectangle bounds, Point point)
		{
			this.icon = icon;
			this.bounds = bounds;
			this.point = point;
		}

		public Icon getIcon()
		{
			return icon;
		}

		public Rectangle getBounds()
		{
			return bounds;
		}

		public Point getPoint()
		{
			return point;
		}
	}
//
//  Implement the Icon Interface
//
	/**
	 *  Gets the width of this icon.
	 *
	 *  @return the width of the icon in pixels.
	 */
	@Override
    public int getIconWidth()
    {
		int width = 0;

		//  Add the width of all Icons while also including the gap

    	if (axis == Axis.X_AXIS)
    	{
    		width += (icons.length - 1) * gap;

			for (Icon icon : icons)
				width += icon.getIconWidth();
    	}
		else  //  Just find the maximum width
		{
			for (Icon icon : icons)
				width = Math.max(width, icon.getIconWidth());
		}

		return width;
    }

	/**
	 *  Gets the height of this icon.
	 *
	 *  @return the height of the icon in pixels.
	 */
	@Override
    public int getIconHeight()
    {
		int height = 0;

		//  Add the height of all Icons while also including the gap

    	if (axis == Axis.Y_AXIS)
    	{
    		height += (icons.length - 1) * gap;

			for (Icon icon : icons)
				height += icon.getIconHeight();
    	}
		else  //  Just find the maximum height
		{
			for (Icon icon : icons)
				height = Math.max(height, icon.getIconHeight());
		}

		return height;
    }

   /**
    *  Paint the icons of this compound icon at the specified location
    *
    *  @param c The component on which the icon is painted
    *  @param g the graphics context
    *  @param x the X coordinate of the icon's top-left corner
    *  @param y the Y coordinate of the icon's top-left corner
    */
	@Override
    public void paintIcon(Component c, Graphics g, int x, int y)
    {
    	//  An Icon can be used by multiple components. The Icon can be
    	//  painted at a different offset in each of these components.
    	//  Save the offset for each component.

		iconOffset.put(c, new Point(x, y));

		for (int i = 0; i < icons.length; i++)
		{
			Icon icon = icons[i];
			Rectangle r = bounds[i];
			icon.paintIcon(c, g, r.x + x, r.y + y);
		}
    }

	/*
	 *	Determine the bounds of each Icon contained within the CompoundIcon
	 */
	private void determineIconBounds()
	{
		bounds = new Rectangle[icons.length];
		int index = 0;

    	if (axis == Axis.X_AXIS)
    	{
    		int x = 0;
    		int height = getIconHeight();

			for (Icon icon : icons)
			{
				int iconY = getOffset(height, icon.getIconHeight(), alignmentY);
				bounds[index] = new Rectangle(x, iconY, icon.getIconWidth(), icon.getIconHeight());
				x += icon.getIconWidth() + gap;
				index++;
			}
    	}
    	else if (axis == Axis.Y_AXIS)
    	{
    		int y = 0;
    		int width = getIconWidth();

			for (Icon icon : icons)
			{
				int iconX = getOffset(width, icon.getIconWidth(), alignmentX);
				bounds[index] = new Rectangle(iconX, y, icon.getIconWidth(), icon.getIconHeight());
				y += icon.getIconHeight() + gap;
				index++;
			}
    	}
    	else // must be Z_AXIS
    	{
    		int width = getIconWidth();
    		int height = getIconHeight();

			for (Icon icon : icons)
			{
				int iconX = getOffset(width, icon.getIconWidth(), alignmentX);
				int iconY = getOffset(height, icon.getIconHeight(), alignmentY);
				bounds[index] = new Rectangle(iconX, iconY, icon.getIconWidth(), icon.getIconHeight());
				index++;
			}
    	}
	}

	/*
	 *  When the icon value is smaller than the maximum value of all icons the
	 *  icon needs to be aligned appropriately. Calculate the offset to be used
	 *  when painting the icon to achieve the proper alignment.
	 */
	private int getOffset(int maxValue, int iconValue, float alignment)
	{
		float offset = (maxValue - iconValue) * alignment;
		return Math.round(offset);
	}
}