package mage.client.components.layout;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager2;
import java.util.HashMap;
import java.util.Map;

/**
 *  The <code>RelativeLayout</code> class is a layout manager that
 *  lays out a container's components on the specified X or Y axis.
 *
 *  Components can be layed out at their preferred size or at a
 *  relative size. When relative sizing is used the component must be added
 *  to the container using a relative size constraint, which is simply a
 *  Float value.
 *
 *  The space available for relative sized components is determined by
 *  subtracting the preferred size of the other components from the space
 *  available in the container. Each component is then assigned a size
 *  based on its relative size value. For example:
 *
 *  container.add(component1, new Float(1));
 *  container.add(component2, new Float(2));
 *
 *  There is a total of 3 relative units. If the container has 300 pixels
 *  of space available then component1 will get 100 and component2, 200.
 *
 *  It is possible that rounding errors will occur in which case you can
 *  specify a rounding policy to use to allocate the extra pixels.
 *
 *  By defaults components are center aligned on the secondary axis
 *  however this can be changed at the container or component level.
 */
public class RelativeLayout implements LayoutManager2, java.io.Serializable {

    private static final long serialVersionUID = 1L;
    //  Used in the constructor
    public static final int X_AXIS = 0;
    public static final int Y_AXIS = 1;

    //  See setAlignment() method
    public static final float LEADING = 0.0f;
    public static final float CENTER = 0.5f;
    public static final float TRAILING = 1.0f;
    public static final float COMPONENT = -1.0f;

    //  See setRoundingPolicy() method
    public static final int DO_NOTHING = 0;
    public static final int FIRST = 1;
    public static final int LAST = 2;
    public static final int LARGEST = 3;
    public static final int EQUAL = 4;

    private static final int MINIMUM = 0;
    private static final int PREFERRED = 1;

    private Map<Component, Float> constraints = new HashMap<Component, Float>();

    /**
     * The axis of the Components within the Container.
     */
    private int axis;

    /**
     * The alignment of the Components on the other axis of the Container.
     * For X-AXIS this would refer to the Y alignment.
     * For Y-AXIS this would refer to the X alignment.
     */
    private float alignment = CENTER;

    /**
     * This is the gap (in pixels) which specifies the space between components
     * It can be changed at any time and should be a non-negative integer.
     */
    private int gap;

    /**
     * The gap (in pixels) used before the leading component and after the trailing component.
     * It can be changed at any time and should be a non-negative integer.
     */
    private int borderGap;

    //  Fill space available for relative components
    private boolean fill = false;

    //  Gap to prevent the component from completely filling the space available
    private int fillGap;

    //  Specify the rounding policy when rounding problems happen.
    private int roundingPolicy = LARGEST;

    /**
     * Creates a relative layout with the components layed out on the X-Axis using the default gap
     */
    public RelativeLayout() {
        this(X_AXIS, 0);
    }

    /**
     * Creates a relative layout with the components layed out on the specified axis
     * using the default gap
     *
     * @param axis X-AXIS or Y_AXIS
     */
    public RelativeLayout(int axis) {
        this(axis, 0);
    }

    /**
     * Creates a relative layout with the components layed out on the specified axis
     * using the specfied gap
     * <p/>
     * All <code>RelativeLayout</code> constructors defer to this one.
     *
     * @param axis X-AXIS or Y_AXIS
     * @param gap the gap
     */
    public RelativeLayout(int axis, int gap) {
        setAxis(axis);
        setGap(gap);
        setBorderGap(gap);
    }

    /**
     * Gets the layout axis.
     *
     * @return the layout axis
     */
    public int getAxis() {
        return axis;
    }

    /**
     * Sets the layout axis
     *
     * @param axis the layout axis
     */
    public final void setAxis(int axis) {
        if (axis != X_AXIS && axis != Y_AXIS) {
            throw new IllegalArgumentException("invalid axis specified");
        }

        this.axis = axis;
    }

    /**
     * Gets the gap between components.
     *
     * @return the gap between components
     */
    public int getGap() {
        return gap;
    }

    /**
     * Sets the gap between components to the specified value.
     *
     * @param gap the gap between components
     */
    public final void setGap(int gap) {
        this.gap = gap < 0 ? 0 : gap;
    }

    /**
     * Gets the initial gap. This gap is used before the leading component
     * and after the trailing component.
     *
     * @return the leading/trailing gap
     */
    public int getBorderGap() {
        return borderGap;
    }

    /**
     * Sets the initial gap. This gap is used before the leading component
     * and after the trailing component. The default is set to the gap.
     *
     * @param borderGap the leading/trailing gap
     */
    public final void setBorderGap(int borderGap) {
        this.borderGap = borderGap < 0 ? 0 : borderGap;
    }

    /**
     * Gets the alignment of the components on the opposite axis.
     *
     * @return the alignment
     */
    public float getAlignment() {
        return alignment;
    }

    /*
     *  Set the alignment of the component on the opposite axis.
     *
     *  For X-AXIS this would refer to the Y alignemt.
     *  For Y-AXIS this would refer to the X alignment.
     *
     *  Must be between 0.0 and 1.0, or -1. Values can be specified using:
     *
     *  RelativeLayout.LEADING
     *  RelativeLayout.CENTER
     *  RelativeLayout.TRAILING
     *  RelativeLayout.COMPONENT - the getAlignemntX/Y method for the opposite axis will be used
     */
    public void setAlignment(float alignment) {
        this.alignment = alignment > 1.0f ? 1.0f : alignment < 0.0f ? -1.0f : alignment;
    }

    /**
     * Gets the fill property for the component size on the opposite edge.
     *
     * @return the fill property
     */
    public boolean isFill() {
        return fill;
    }

    /**
     * Change size of relative components to fill the space available For X-AXIS aligned components the height will be
     * filled. For Y-AXIS aligned components the width will be filled.
     */
    public void setFill(boolean fill) {
        this.fill = fill;
    }

    /**
     * Gets the fill gap amount.
     *
     * @return the fill gap value
     */
    public int getFillGap() {
        return fillGap;
    }

    /**
     * Specify the number of pixels by which the fill size is decreased when setFill(true) has been specified.
     */
    public void setFillGap(int fillGap) {
        this.fillGap = fillGap;
    }

    /**
     * Gets the rounding policy.
     *
     * @return the rounding policy
     */
    public int getRoundingPolicy() {
        return roundingPolicy;
    }

    /**
     * Specify the rounding policy to be used when all the avialable pixels have not been allocated to a component.
     *
     * DO_NOTHING FIRST - extra pixels added to the first relative component LAST - extra pixels added to the last
     * relative component LARGEST (default) - extra pixels added to the larger relative component EQUAL - a single pixel
     * is added to each relative component (until pixels are used up)
     */
    public void setRoundingPolicy(int roundingPolicy) {
        this.roundingPolicy = roundingPolicy;
    }

    /**
     * Gets the constraints for the specified component.
     *
     * @param component the component to be queried
     * @return the constraint for the specified component, or null if component is null or is not present in this layout
     */
    public Float getConstraints(Component component) {
        return constraints.get(component);
    }

    /**
     * Not supported
     */
    @Override
    public void addLayoutComponent(String name, Component component) {
    }

    /*
     * Keep track of any specified constraint for the component.
     */
    @Override
    public void addLayoutComponent(Component component, Object constraint) {
        if (constraint != null) {
            if (constraint instanceof Float) {
                constraints.put(component, (Float) constraint);
            } else {
                throw new IllegalArgumentException("Constraint parameter must be of type Float");
            }
        }
    }

    /**
     * Removes the specified component from the layout.
     *
     * @param comp the component to be removed
     */
    @Override
    public void removeLayoutComponent(Component comp) {
    }

    /**
     * Determines the preferred size of the container argument using this column layout. <p> The preferred width of a
     * column layout is the largest preferred width of each column in the container, plus the horizontal padding times
     * the number of columns minus one, plus the left and right insets of the target container. <p> The preferred height
     * of a column layout is the largest preferred height of each row in the container, plus the vertical padding times
     * the number of rows minus one, plus the top and bottom insets of the target container.
     *
     * @param target the container in which to do the layout
     * @return the preferred dimensions to lay out the subcomponents of the specified container
     * @see java.awt.RelativeLayout#minimumLayoutSize
     * @see java.awt.Container#getPreferredSize()
     */
    @Override
    public Dimension preferredLayoutSize(Container parent) {
        synchronized (parent.getTreeLock()) {
            return getLayoutSize(parent, PREFERRED);
        }
    }

    /**
     * Determines the minimum size of the container argument using this column layout. <p> The minimum width of a grid
     * layout is the largest minimum width of each column in the container, plus the horizontal padding times the number
     * of columns minus one, plus the left and right insets of the target container. <p> The minimum height of a column
     * layout is the largest minimum height of each row in the container, plus the vertical padding times the number of
     * rows minus one, plus the top and bottom insets of the target container.
     *
     * @param target the container in which to do the layout
     * @return the minimum dimensions needed to lay out the subcomponents of the specified container
     * @see java.awt.RelativeLayout#preferredLayoutSize
     * @see java.awt.Container#doLayout
     */
    @Override
    public Dimension minimumLayoutSize(Container parent) {
        synchronized (parent.getTreeLock()) {
            return getLayoutSize(parent, MINIMUM);
        }
    }

    /**
     * Lays out the specified container using this layout. <p> This method reshapes the components in the specified
     * target container in order to satisfy the constraints of the
     * <code>RelativeLayout</code> object. <p> The grid layout manager determines the size of individual components by
     * dividing the free space in the container into equal-sized portions according to the number of rows and columns in
     * the layout. The container's free space equals the container's size minus any insets and any specified horizontal
     * or vertical gap. All components in a grid layout are given the same size.
     *
     * @param target the container in which to do the layout
     * @see java.awt.Container
     * @see java.awt.Container#doLayout
     */
    @Override
    public void layoutContainer(Container parent) {
        synchronized (parent.getTreeLock()) {
            if (axis == X_AXIS) {
                layoutContainerHorizontally(parent);
            } else {
                layoutContainerVertically(parent);
            }
        }
    }

    /*
     *  Lay out all the components in the Container along the X-Axis
     */
    private void layoutContainerHorizontally(Container parent) {
        int components = parent.getComponentCount();
        int visibleComponents = getVisibleComponents(parent);

        if (components == 0) {
            return;
        }

        //  Determine space available for components using relative sizing

        float relativeTotal = 0.0f;
        Insets insets = parent.getInsets();
        int spaceAvailable = parent.getSize().width
                - insets.left
                - insets.right
                - ((visibleComponents - 1) * gap)
                - (2 * borderGap);

        for (int i = 0; i < components; i++) {
            Component component = parent.getComponent(i);

            if (!component.isVisible()) {
                continue;
            }

            Float constraint = constraints.get(component);

            if (constraint == null) {
                Dimension d = component.getPreferredSize();
                spaceAvailable -= d.width;
            } else {
                relativeTotal += constraint.doubleValue();
            }
        }

        //  Allocate space to each component using relative sizing

        int[] relativeSpace = allocateRelativeSpace(parent, spaceAvailable, relativeTotal);

        //  Position each component in the container

        int x = insets.left + borderGap;
        int y = insets.top;
        int insetGap = insets.top + insets.bottom;
        int parentHeight = parent.getSize().height - insetGap;

        for (int i = 0; i < components; i++) {
            Component component = parent.getComponent(i);

            if (!component.isVisible()) {
                continue;
            }

            if (i > 0) {
                x += gap;
            }

            Dimension d = component.getPreferredSize();

            if (fill) {
                d.height = parentHeight - fillGap;
            }

            Float constraint = constraints.get(component);

            if (constraint == null) {
                component.setSize(d);
                int locationY = getLocationY(component, parentHeight) + y;
                component.setLocation(x, locationY);
                x += d.width;
            } else {
                int width = relativeSpace[i];
                component.setSize(width, d.height);
                int locationY = getLocationY(component, parentHeight) + y;
                component.setLocation(x, locationY);
                x += width;
            }
        }
    }

    /*
     *  Align the component on the Y-Axis
     */
    private int getLocationY(Component component, int height) {
        //  Use the Container alignment policy

        float alignmentY = alignment;

        //  Override with the Component alignment

        if (alignmentY == COMPONENT) {
            alignmentY = component.getAlignmentY();
        }

        return (int) ((height - component.getSize().height) * alignmentY);
    }

    /*
     *  Lay out all the components in the Container along the Y-Axis
     */
    private void layoutContainerVertically(Container parent) {
        int components = parent.getComponentCount();
        int visibleComponents = getVisibleComponents(parent);

        if (components == 0) {
            return;
        }

        //  Determine space available for components using relative sizing

        float relativeTotal = 0.0f;
        Insets insets = parent.getInsets();
        int spaceAvailable = parent.getSize().height
                - insets.top
                - insets.bottom
                - ((visibleComponents - 1) * gap)
                - (2 * borderGap);

        for (int i = 0; i < components; i++) {
            Component component = parent.getComponent(i);

            if (!component.isVisible()) {
                continue;
            }

            Float constraint = constraints.get(component);

            if (constraint == null) {
                Dimension d = component.getPreferredSize();
                spaceAvailable -= d.height;
            } else {
                relativeTotal += constraint.doubleValue();
            }
        }

        //  Allocate space to each component using relative sizing

        int[] relativeSpace = allocateRelativeSpace(parent, spaceAvailable, relativeTotal);

        //  Position each component in the container

        int x = insets.left;
        int y = insets.top + borderGap;
        int insetGap = insets.left + insets.right;
        int parentWidth = parent.getSize().width - insetGap;

        for (int i = 0; i < components; i++) {
            Component component = parent.getComponent(i);

            if (!component.isVisible()) {
                continue;
            }

            if (i > 0) {
                y += gap;
            }

            Dimension d = component.getPreferredSize();

            if (fill) {
                d.width = parentWidth - fillGap;
            }

            Float constraint = constraints.get(component);

            if (constraint == null) {
                component.setSize(d);
                int locationX = getLocationX(component, parentWidth) + x;
                component.setLocation(locationX, y);
                y += d.height;
            } else {
                int height = relativeSpace[i];
                component.setSize(d.width, height);
                int locationX = getLocationX(component, parentWidth) + x;
                component.setLocation(locationX, y);
                y += height;
            }

        }
    }

    /*
     *  Align the component on the X-Axis
     */
    private int getLocationX(Component component, int width) {
        //  Use the Container alignment policy

        float alignmentX = alignment;

        //  Override with the Component alignment

        if (alignmentX == COMPONENT) {
            alignmentX = component.getAlignmentX();
        }

        return (int) ((width - component.getSize().width) * alignmentX);
    }

    /*
     *  Allocate the space available to each component using relative sizing
     */
    private int[] allocateRelativeSpace(Container parent, int spaceAvailable, float relativeTotal) {
        int spaceUsed = 0;
        int components = parent.getComponentCount();
        int[] relativeSpace = new int[components];

        for (int i = 0; i < components; i++) {
            relativeSpace[i] = 0;

            if (relativeTotal > 0 && spaceAvailable > 0) {
                Component component = parent.getComponent(i);
                Float constraint = constraints.get(component);

                if (constraint != null) {
                    int space = (int) (spaceAvailable * constraint.floatValue() / relativeTotal);
                    relativeSpace[i] = space;
                    spaceUsed += space;
                }
            }
        }

        int spaceRemaining = spaceAvailable - spaceUsed;

        if (relativeTotal > 0 && spaceRemaining > 0) {
            adjustForRounding(relativeSpace, spaceRemaining);
        }

        return relativeSpace;
    }

    /*
     *  Because of rounding, all the space has not been allocated
     *  Override this method to create a custom rounding policy
     */
    protected void adjustForRounding(int[] relativeSpace, int spaceRemaining) {
        switch (roundingPolicy) {
            case DO_NOTHING:
                break;
            case FIRST:
                adjustFirst(relativeSpace, spaceRemaining);
                break;
            case LAST:
                adjustLast(relativeSpace, spaceRemaining);
                break;
            case LARGEST:
                adjustLargest(relativeSpace, spaceRemaining);
                break;
            case EQUAL:
                adjustEqual(relativeSpace, spaceRemaining);
                break;
            default:
                adjustLargest(relativeSpace, spaceRemaining);
        }
    }

    /*
     * First component using relative sizing gets all the space
     */
    private void adjustFirst(int[] relativeSpace, int spaceRemaining) {
        for (int i = 0; i < relativeSpace.length; i++) {
            if (relativeSpace[i] > 0) {
                relativeSpace[i] += spaceRemaining;
                break;
            }
        }
    }

    /*
     *  Last component using relative sizing gets all the space
     */
    private void adjustLast(int[] relativeSpace, int spaceRemaining) {
        for (int i = relativeSpace.length - 1; i > 0; i--) {
            if (relativeSpace[i] > 0) {
                relativeSpace[i] += spaceRemaining;
                break;
            }
        }
    }

    /*
     *  Largest component using relative sizing gets all the space.
     *  When multiple components are the same size, the last one found is used.
     */
    private void adjustLargest(int[] relativeSpace, int spaceRemaining) {
        int largest = 0;
        int largestSpace = 0;

        for (int i = 0; i < relativeSpace.length; i++) {
            int space = relativeSpace[i];

            if (space > 0 && largestSpace < space) {
                largestSpace = space;
                largest = i;
            }
        }

        relativeSpace[largest] += spaceRemaining;
    }

    /*
     *  Each component using relative sizing gets 1 more pixel
     *  until all the space is used, starting with the first.
     */
    private void adjustEqual(int[] relativeSpace, int spaceRemaining) {
        int pixelsLeft = spaceRemaining;
        for (int i = 0; i < relativeSpace.length; i++) {
            if (relativeSpace[i] > 0) {
                relativeSpace[i]++;
                pixelsLeft--;

                if (pixelsLeft == 0) {
                    break;
                }
            }
        }
    }

    /*
     *  Determine the Preferred or Minimum layout size
     */
    private Dimension getLayoutSize(Container parent, int type) {
        int width = 0;
        int height = 0;
        int components = parent.getComponentCount();
        int visibleComponents = getVisibleComponents(parent);

        for (int i = 0; i < components; i++) {
            Component component = parent.getComponent(i);

            if (!component.isVisible()) {
                continue;
            }

            Dimension d = getDimension(component, type);

            if (axis == X_AXIS) {
                width += d.width;
                height = Math.max(height, d.height);
            } else {
                width = Math.max(width, d.width);
                height += d.height;
            }
        }

        Insets insets = parent.getInsets();
        int totalGap = ((visibleComponents - 1) * gap) + (2 * borderGap);

        if (axis == X_AXIS) {
            width += insets.left + insets.right + totalGap;
            height += insets.top + insets.bottom;
        } else {
            width += insets.left + insets.right;
            height += insets.top + insets.bottom + totalGap;
        }

        return new Dimension(width, height);
    }

    private int getVisibleComponents(Container container) {
        int visibleComponents = 0;

        for (Component component : container.getComponents()) {
            if (component.isVisible()) {
                visibleComponents++;
            }
        }

        return visibleComponents;
    }

    private Dimension getDimension(Component component, int type) {
        switch (type) {
            case PREFERRED:
                return component.getPreferredSize();
            case MINIMUM:
                return component.getMinimumSize();
            default:
                return new Dimension(0, 0);
        }
    }

    /**
     * There is no maximum.
     */
    @Override
    public Dimension maximumLayoutSize(Container target) {
        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
    }

    /**
     * Returns the alignment along the x axis. Use center alignment.
     */
    @Override
    public float getLayoutAlignmentX(Container parent) {
        return 0.5f;
    }

    /**
     * Returns the alignment along the y axis. Use center alignment.
     */
    @Override
    public float getLayoutAlignmentY(Container parent) {
        return 0.5f;
    }

    /**
     * Invalidates the layout, indicating that if the layout manager has cached information it should be discarded.
     */
    @Override
    public void invalidateLayout(Container target) {
        // remove constraints here?
    }

    /**
     * Returns the string representation of this column layout's values.
     *
     * @return a string representation of this grid layout
     */
    @Override
    public String toString() {
        return getClass().getName()
                + "[axis=" + axis
                + ",gap=" + gap
                + "]";
    }
}
