/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.eclipse.org/org/documents/epl-v10.php
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.ide.common.layout.grid;

import static com.android.SdkConstants.ATTR_COLUMN_COUNT;
import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN;
import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN_SPAN;
import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY;
import static com.android.SdkConstants.ATTR_LAYOUT_ROW;
import static com.android.SdkConstants.ATTR_LAYOUT_ROW_SPAN;
import static com.android.ide.common.layout.GravityHelper.getGravity;
import static com.android.ide.common.layout.GridLayoutRule.GRID_SIZE;
import static com.android.ide.common.layout.GridLayoutRule.MARGIN_SIZE;
import static com.android.ide.common.layout.GridLayoutRule.MAX_CELL_DIFFERENCE;
import static com.android.ide.common.layout.GridLayoutRule.SHORT_GAP_DP;
import static com.android.ide.common.layout.grid.GridModel.UNDEFINED;
import static java.lang.Math.abs;

import com.android.ide.common.api.DropFeedback;
import com.android.ide.common.api.IDragElement;
import com.android.ide.common.api.INode;
import com.android.ide.common.api.IViewMetadata;
import com.android.ide.common.api.Margins;
import com.android.ide.common.api.Point;
import com.android.ide.common.api.Rect;
import com.android.ide.common.api.SegmentType;
import com.android.ide.common.layout.BaseLayoutRule;
import com.android.ide.common.layout.GravityHelper;
import com.android.ide.common.layout.GridLayoutRule;
import com.android.ide.eclipse.adt.internal.editors.layout.gre.ViewMetadataRepository;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Locale;

/**
 * The {@link GridDropHandler} handles drag and drop operations into and within a
 * GridLayout, computing guidelines, handling drops to edit the grid model, and so on.
 */
public class GridDropHandler {
    private final GridModel mGrid;
    private final GridLayoutRule mRule;
    private GridMatch mColumnMatch;
    private GridMatch mRowMatch;

    /**
     * Creates a new {@link GridDropHandler} for
     * @param gridLayoutRule the corresponding {@link GridLayoutRule}
     * @param layout the GridLayout node
     * @param view the view instance of the grid layout receiving the drop
     */
    public GridDropHandler(GridLayoutRule gridLayoutRule, INode layout, Object view) {
        mRule = gridLayoutRule;
        mGrid = GridModel.get(mRule.getRulesEngine(), layout, view);
    }

    /**
     * Computes the best horizontal and vertical matches for a drag to the given position.
     *
     * @param feedback a {@link DropFeedback} object containing drag state like the drag
     *            bounds and the drag baseline
     * @param p the mouse position
     */
    public void computeMatches(DropFeedback feedback, Point p) {
        mRowMatch = mColumnMatch = null;
        feedback.tooltip = null;

        Rect bounds = mGrid.layout.getBounds();
        int x1 = p.x;
        int y1 = p.y;

        Rect dragBounds = feedback.dragBounds;
        int w = dragBounds != null ? dragBounds.w : 0;
        int h = dragBounds != null ? dragBounds.h : 0;
        if (!GridLayoutRule.sGridMode) {
            if (dragBounds != null) {
                // Sometimes the items are centered under the mouse so
                // offset by the top left corner distance
                x1 += dragBounds.x;
                y1 += dragBounds.y;
            }

            int x2 = x1 + w;
            int y2 = y1 + h;

            if (x2 < bounds.x || y2 < bounds.y || x1 > bounds.x2() || y1 > bounds.y2()) {
                return;
            }

            List<GridMatch> columnMatches = new ArrayList<GridMatch>();
            List<GridMatch> rowMatches = new ArrayList<GridMatch>();
            int max = BaseLayoutRule.getMaxMatchDistance();

            // Column matches:
            addLeftSideMatch(x1, columnMatches, max);
            addRightSideMatch(x2, columnMatches, max);
            addCenterColumnMatch(bounds, x1, y1, x2, y2, columnMatches, max);

            // Row matches:
            int row = (mGrid.getViewCount() == 0) ? 0 : mGrid.getClosestRow(y1);
            int rowY = mGrid.getRowY(row);
            addTopMatch(y1, rowMatches, max, row, rowY);
            addBaselineMatch(feedback.dragBaseline, y1, rowMatches, max, row, rowY);
            addBottomMatch(y2, rowMatches, max);

            // Look for gap-matches: Predefined spacing between widgets.
            // TODO: Make this use metadata for predefined spacing between
            // pairs of types of components. For example, buttons have certain
            // inserts in their 9-patch files (depending on the theme) that should
            // be considered and subtracted from the overall proposed distance!
            addColumnGapMatch(bounds, x1, x2, columnMatches, max);
            addRowGapMatch(bounds, y1, y2, rowMatches, max);

            // Fallback: Split existing cell. Also do snap-to-grid.
            if (GridLayoutRule.sSnapToGrid) {
                x1 = ((x1 - MARGIN_SIZE - bounds.x) / GRID_SIZE) * GRID_SIZE
                        + MARGIN_SIZE + bounds.x;
                y1 = ((y1 - MARGIN_SIZE - bounds.y) / GRID_SIZE) * GRID_SIZE
                        + MARGIN_SIZE + bounds.y;
                x2 = x1 + w;
                y2 = y1 + h;
            }


            if (columnMatches.size() == 0 && x1 >= bounds.x) {
                // Split the current cell since we have no matches
                // TODO: Decide whether it should be gravity left or right...
                columnMatches.add(new GridMatch(SegmentType.LEFT, 0, x1, mGrid.getColumn(x1),
                        true /* createCell */, UNDEFINED));
            }
            if (rowMatches.size() == 0 && y1 >= bounds.y) {
                rowMatches.add(new GridMatch(SegmentType.TOP, 0, y1, mGrid.getRow(y1),
                        true /* createCell */, UNDEFINED));
            }

            // Pick best matches
            Collections.sort(rowMatches);
            Collections.sort(columnMatches);

            mColumnMatch = null;
            mRowMatch = null;
            String columnDescription = null;
            String rowDescription = null;
            if (columnMatches.size() > 0) {
                mColumnMatch = columnMatches.get(0);
                columnDescription = mColumnMatch.getDisplayName(mGrid.layout);
            }
            if (rowMatches.size() > 0) {
                mRowMatch = rowMatches.get(0);
                rowDescription = mRowMatch.getDisplayName(mGrid.layout);
            }

            if (columnDescription != null && rowDescription != null) {
                feedback.tooltip = columnDescription + '\n' + rowDescription;
            }

            feedback.invalidTarget = mColumnMatch == null || mRowMatch == null;
        } else {
            // Find which cell we're inside.

            // TODO: Find out where within the cell we are, and offer to tweak the gravity
            // based on the position.
            int column = mGrid.getColumn(x1);
            int row = mGrid.getRow(y1);

            int leftDistance = mGrid.getColumnDistance(column, x1);
            int rightDistance = mGrid.getColumnDistance(column + 1, x1);
            int topDistance = mGrid.getRowDistance(row, y1);
            int bottomDistance = mGrid.getRowDistance(row + 1, y1);

            int SLOP = 2;
            int radius = mRule.getNewCellSize();
            if (rightDistance < radius + SLOP) {
                column = Math.min(column + 1, mGrid.actualColumnCount);
                leftDistance = rightDistance;
            }
            if (bottomDistance < radius + SLOP) {
                row = Math.min(row + 1, mGrid.actualRowCount);
                topDistance = bottomDistance;
            }

            boolean createColumn = leftDistance < radius + SLOP;
            boolean createRow = topDistance < radius + SLOP;
            if (x1 >= bounds.x2()) {
                createColumn = true;
            }
            if (y1 >= bounds.y2()) {
                createRow = true;
            }

            int cellWidth = leftDistance + rightDistance;
            int cellHeight = topDistance + bottomDistance;
            SegmentType horizontalType = SegmentType.LEFT;
            SegmentType verticalType = SegmentType.TOP;
            int minDistance = 10; // Don't center or right/bottom align in tiny cells
            if (!createColumn && leftDistance > minDistance
                    && dragBounds != null && dragBounds.w < cellWidth - 10) {
                if (rightDistance < leftDistance) {
                    horizontalType = SegmentType.RIGHT;
                }

                int centerDistance = Math.abs(cellWidth / 2 - leftDistance);
                if (centerDistance < leftDistance / 2 && centerDistance < rightDistance / 2) {
                    horizontalType = SegmentType.CENTER_HORIZONTAL;
                }
            }
            if (!createRow && topDistance > minDistance
                    && dragBounds != null && dragBounds.h < cellHeight - 10) {
                if (bottomDistance < topDistance) {
                    verticalType = SegmentType.BOTTOM;
                }
                int centerDistance = Math.abs(cellHeight / 2 - topDistance);
                if (centerDistance < topDistance / 2 && centerDistance < bottomDistance / 2) {
                    verticalType = SegmentType.CENTER_VERTICAL;
                }
            }

            mColumnMatch = new GridMatch(horizontalType, 0, x1, column, createColumn, 0);
            mRowMatch = new GridMatch(verticalType, 0, y1, row, createRow, 0);

            StringBuilder description = new StringBuilder(50);
            String rowString = Integer.toString(mColumnMatch.cellIndex + 1);
            String columnString = Integer.toString(mRowMatch.cellIndex + 1);
            if (mRowMatch.createCell && mRowMatch.cellIndex < mGrid.actualRowCount) {
                description.append(String.format("Shift row %1$d down", mRowMatch.cellIndex + 1));
                description.append('\n');
            }
            if (mColumnMatch.createCell && mColumnMatch.cellIndex < mGrid.actualColumnCount) {
                description.append(String.format("Shift column %1$d right",
                        mColumnMatch.cellIndex + 1));
                description.append('\n');
            }
            description.append(String.format("Insert into cell (%1$s,%2$s)",
                    rowString, columnString));
            description.append('\n');
            description.append(String.format("Align %1$s, %2$s",
                    horizontalType.name().toLowerCase(Locale.US),
                    verticalType.name().toLowerCase(Locale.US)));
            feedback.tooltip = description.toString();
        }
    }

    /**
     * Adds a match to align the left edge with some other edge.
     */
    private void addLeftSideMatch(int x1, List<GridMatch> columnMatches, int max) {
        int column = (mGrid.getViewCount() == 0) ? 0 : mGrid.getClosestColumn(x1);
        int columnX = mGrid.getColumnX(column);
        int distance = abs(columnX - x1);
        if (distance <= max) {
            columnMatches.add(new GridMatch(SegmentType.LEFT, distance, columnX, column,
                    false, UNDEFINED));
        }
    }

    /**
     * Adds a match to align the right edge with some other edge.
     */
    private void addRightSideMatch(int x2, List<GridMatch> columnMatches, int max) {
        // TODO: Only match the right hand side if the drag bounds fit fully within the
        // cell! Ditto for match below.
        int columnRight = (mGrid.getViewCount() == 0) ? 0 : mGrid.getClosestColumn(x2);
        int rightDistance = mGrid.getColumnDistance(columnRight, x2);
        if (rightDistance < max) {
            int columnX = mGrid.getColumnX(columnRight);
            if (columnX > mGrid.layout.getBounds().x) {
                columnMatches.add(new GridMatch(SegmentType.RIGHT, rightDistance, columnX,
                        columnRight, false, UNDEFINED));
            }
        }
    }

    /**
     * Adds a horizontal match with the center axis of the GridLayout
     */
    private void addCenterColumnMatch(Rect bounds, int x1, int y1, int x2, int y2,
            List<GridMatch> columnMatches, int max) {
        Collection<INode> intersectsRow = mGrid.getIntersectsRow(y1, y2);
        if (intersectsRow.size() == 0) {
            // Offer centering on this row since there isn't anything there
            int matchedLine = bounds.centerX();
            int distance = abs((x1 + x2) / 2 - matchedLine);
            if (distance <= 2 * max) {
                boolean createCell = false; // always just put in column 0
                columnMatches.add(new GridMatch(SegmentType.CENTER_HORIZONTAL, distance,
                        matchedLine, 0 /* column */, createCell, UNDEFINED));
            }
        }
    }

    /**
     * Adds a match to align the top edge with some other edge.
     */
    private void addTopMatch(int y1, List<GridMatch> rowMatches, int max, int row, int rowY) {
        int distance = mGrid.getRowDistance(row, y1);
        if (distance <= max) {
            rowMatches.add(new GridMatch(SegmentType.TOP, distance, rowY, row, false,
                    UNDEFINED));
        }
    }

    /**
     * Adds a match to align the bottom edge with some other edge.
     */
    private void addBottomMatch(int y2, List<GridMatch> rowMatches, int max) {
        int rowBottom = (mGrid.getViewCount() == 0) ? 0 : mGrid.getClosestRow(y2);
        int distance = mGrid.getRowDistance(rowBottom, y2);
        if (distance < max) {
            int rowY = mGrid.getRowY(rowBottom);
            if (rowY > mGrid.layout.getBounds().y) {
                rowMatches.add(new GridMatch(SegmentType.BOTTOM, distance, rowY,
                        rowBottom, false, UNDEFINED));
            }
        }
    }

    /**
     * Adds a baseline match, if applicable.
     */
    private void addBaselineMatch(int dragBaseline, int y1, List<GridMatch> rowMatches, int max,
            int row, int rowY) {
        int dragBaselineY = y1 + dragBaseline;
        int rowBaseline = mGrid.getBaseline(row);
        if (rowBaseline != -1) {
            int rowBaselineY = rowY + rowBaseline;
            int distance = abs(dragBaselineY - rowBaselineY);
            if (distance < max) {
                rowMatches.add(new GridMatch(SegmentType.BASELINE, distance, rowBaselineY, row,
                        false, UNDEFINED));
            }
        }
    }

    /**
     * Computes a horizontal "gap" match - a preferred distance from the nearest edge,
     * including margin edges
     */
    private void addColumnGapMatch(Rect bounds, int x1, int x2, List<GridMatch> columnMatches,
            int max) {
        if (x1 < bounds.x + MARGIN_SIZE + max) {
            int matchedLine = bounds.x + MARGIN_SIZE;
            int distance = abs(matchedLine - x1);
            if (distance <= max) {
                boolean createCell = mGrid.getColumnX(mGrid.getColumn(matchedLine)) != matchedLine;
                columnMatches.add(new GridMatch(SegmentType.LEFT, distance, matchedLine,
                        0, createCell, MARGIN_SIZE));
            }
        } else if (x2 > bounds.x2() - MARGIN_SIZE - max) {
            int matchedLine = bounds.x2() - MARGIN_SIZE;
            int distance = abs(matchedLine - x2);
            if (distance <= max) {
                // This does not yet work properly; we need to use columnWeights to achieve this
                //boolean createCell = mGrid.getColumnX(mGrid.getColumn(matchedLine)) != matchedLine;
                //columnMatches.add(new GridMatch(SegmentType.RIGHT, distance, matchedLine,
                //        mGrid.actualColumnCount - 1, createCell, MARGIN_SIZE));
            }
        } else {
            int columnRight = mGrid.getColumn(x1 - SHORT_GAP_DP);
            int columnX = mGrid.getColumnMaxX(columnRight);
            int matchedLine = columnX + SHORT_GAP_DP;
            int distance = abs(matchedLine - x1);
            if (distance <= max) {
                boolean createCell = mGrid.getColumnX(mGrid.getColumn(matchedLine)) != matchedLine;
                columnMatches.add(new GridMatch(SegmentType.LEFT, distance, matchedLine,
                        columnRight, createCell, SHORT_GAP_DP));
            }

            // Add a column directly adjacent (no gap)
            columnRight = mGrid.getColumn(x1);
            columnX = mGrid.getColumnMaxX(columnRight);
            matchedLine = columnX;
            distance = abs(matchedLine - x1);

            // Let's say you have this arrangement:
            //     [button1][button2]
            // This is two columns, where the right hand side edge of column 1 is
            // flush with the left side edge of column 2, because in fact the width of
            // button1 is what defines the width of column 1, and that in turn is what
            // defines the left side position of column 2.
            //
            // In this case we don't want to consider inserting a new column at the
            // right hand side of button1 a better match than matching left on column 2.
            // Therefore, to ensure that this doesn't happen, we "penalize" right column
            // matches such that they don't get preferential treatment when the matching
            // line is on the left side of the column.
            distance += 2;

            if (distance <= max) {
                boolean createCell = mGrid.getColumnX(mGrid.getColumn(matchedLine)) != matchedLine;
                columnMatches.add(new GridMatch(SegmentType.LEFT, distance, matchedLine,
                        columnRight, createCell, 0));
            }
        }
    }

    /**
     * Computes a vertical "gap" match - a preferred distance from the nearest edge,
     * including margin edges
     */
    private void addRowGapMatch(Rect bounds, int y1, int y2, List<GridMatch> rowMatches, int max) {
        if (y1 < bounds.y + MARGIN_SIZE + max) {
            int matchedLine = bounds.y + MARGIN_SIZE;
            int distance = abs(matchedLine - y1);
            if (distance <= max) {
                boolean createCell = mGrid.getRowY(mGrid.getRow(matchedLine)) != matchedLine;
                rowMatches.add(new GridMatch(SegmentType.TOP, distance, matchedLine,
                        0, createCell, MARGIN_SIZE));
            }
        } else if (y2 > bounds.y2() - MARGIN_SIZE - max) {
            int matchedLine = bounds.y2() - MARGIN_SIZE;
            int distance = abs(matchedLine - y2);
            if (distance <= max) {
                // This does not yet work properly; we need to use columnWeights to achieve this
                //boolean createCell = mGrid.getRowY(mGrid.getRow(matchedLine)) != matchedLine;
                //rowMatches.add(new GridMatch(SegmentType.BOTTOM, distance, matchedLine,
                //        mGrid.actualRowCount - 1, createCell, MARGIN_SIZE));
            }
        } else {
            int rowBottom = mGrid.getRow(y1 - SHORT_GAP_DP);
            int rowY = mGrid.getRowMaxY(rowBottom);
            int matchedLine = rowY + SHORT_GAP_DP;
            int distance = abs(matchedLine - y1);
            if (distance <= max) {
                boolean createCell = mGrid.getRowY(mGrid.getRow(matchedLine)) != matchedLine;
                rowMatches.add(new GridMatch(SegmentType.TOP, distance, matchedLine,
                        rowBottom, createCell, SHORT_GAP_DP));
            }

            // Add a row directly adjacent (no gap)
            rowBottom = mGrid.getRow(y1);
            rowY = mGrid.getRowMaxY(rowBottom);
            matchedLine = rowY;
            distance = abs(matchedLine - y1);
            distance += 2; // See explanation in addColumnGapMatch
            if (distance <= max) {
                boolean createCell = mGrid.getRowY(mGrid.getRow(matchedLine)) != matchedLine;
                rowMatches.add(new GridMatch(SegmentType.TOP, distance, matchedLine,
                        rowBottom, createCell, 0));
            }

        }
    }

    /**
     * Called when a node is dropped in free-form mode. This will insert the dragged
     * element into the grid and returns the newly created node.
     *
     * @param targetNode the GridLayout node
     * @param element the dragged element
     * @return the newly created {@link INode}
     */
    public INode handleFreeFormDrop(INode targetNode, IDragElement element) {
        assert mRowMatch != null;
        assert mColumnMatch != null;

        String fqcn = element.getFqcn();

        INode newChild = null;

        Rect bounds = element.getBounds();
        int row = mRowMatch.cellIndex;
        int column = mColumnMatch.cellIndex;

        if (targetNode.getChildren().length == 0) {
            //
            // Set up the initial structure:
            //
            //
            //    Fixed                                 Fixed
            //     Size                                  Size
            //    Column       Expanding Column         Column
            //   +-----+-------------------------------+-----+
            //   |     |                               |     |
            //   | 0,0 |              0,1              | 0,2 | Fixed Size Row
            //   |     |                               |     |
            //   +-----+-------------------------------+-----+
            //   |     |                               |     |
            //   |     |                               |     |
            //   |     |                               |     |
            //   | 1,0 |              1,1              | 1,2 | Expanding Row
            //   |     |                               |     |
            //   |     |                               |     |
            //   |     |                               |     |
            //   +-----+-------------------------------+-----+
            //   |     |                               |     |
            //   | 2,0 |              2,1              | 2,2 | Fixed Size Row
            //   |     |                               |     |
            //   +-----+-------------------------------+-----+
            //
            // This is implemented in GridLayout by the following grid, where
            // SC1 has columnWeight=1 and SR1 has rowWeight=1.
            // (SC=Space for Column, SR=Space for Row)
            //
            //   +------+-------------------------------+------+
            //   |      |                               |      |
            //   | SCR0 |             SC1               | SC2  |
            //   |      |                               |      |
            //   +------+-------------------------------+------+
            //   |      |                               |      |
            //   |      |                               |      |
            //   |      |                               |      |
            //   | SR1  |                               |      |
            //   |      |                               |      |
            //   |      |                               |      |
            //   |      |                               |      |
            //   +------+-------------------------------+------+
            //   |      |                               |      |
            //   | SR2  |                               |      |
            //   |      |                               |      |
            //   +------+-------------------------------+------+
            //
            // Note that when we split columns and rows here, if splitting the expanding
            // row or column then the row or column weight should be moved to the right or
            // bottom half!


            //int columnX = mGrid.getColumnX(column);
            //int rowY = mGrid.getRowY(row);

            mGrid.setGridAttribute(targetNode, ATTR_COLUMN_COUNT, 2);
            //mGrid.setGridAttribute(targetNode, ATTR_COLUMN_COUNT, 3);
            //INode scr0 = addSpacer(targetNode, -1, 0, 0, 1, 1);
            //INode sc1 = addSpacer(targetNode, -1, 0, 1, 0, 0);
            //INode sc2 = addSpacer(targetNode, -1, 0, 2, 1, 0);
            //INode sr1 = addSpacer(targetNode, -1, 1, 0, 0, 0);
            //INode sr2 = addSpacer(targetNode, -1, 2, 0, 0, 1);
            //mGrid.setGridAttribute(sc1, ATTR_LAYOUT_GRAVITY, VALUE_FILL_HORIZONTAL);
            //mGrid.setGridAttribute(sr1, ATTR_LAYOUT_GRAVITY, VALUE_FILL_VERTICAL);
            //
            //mGrid.loadFromXml();
            //column = mGrid.getColumn(columnX);
            //row = mGrid.getRow(rowY);
        }

        int startX, endX;
        if (mColumnMatch.type == SegmentType.RIGHT) {
            endX = mColumnMatch.matchedLine - 1;
            startX = endX - bounds.w;
            column = mGrid.getColumn(startX);
        } else {
            startX = mColumnMatch.matchedLine; // TODO: What happens on type=RIGHT?
            endX = startX + bounds.w;
        }
        int startY, endY;
        if (mRowMatch.type == SegmentType.BOTTOM) {
            endY = mRowMatch.matchedLine - 1;
            startY = endY - bounds.h;
            row = mGrid.getRow(startY);
        } else if (mRowMatch.type == SegmentType.BASELINE) {
            // TODO: The rowSpan should always be 1 for baseline alignments, since
            // otherwise the alignment won't work!
            startY = endY = mRowMatch.matchedLine;
        } else {
            startY = mRowMatch.matchedLine;
            endY = startY + bounds.h;
        }
        int endColumn = mGrid.getColumn(endX);
        int endRow = mGrid.getRow(endY);
        int columnSpan = endColumn - column + 1;
        int rowSpan = endRow - row + 1;

        // Make sure my math was right:
        assert mRowMatch.type != SegmentType.BASELINE || rowSpan == 1 : rowSpan;

        // If the item almost fits into the row (at most N % bigger) then just enlarge
        // the row; don't add a rowspan since that will defeat baseline alignment etc
        if (!mRowMatch.createCell && bounds.h <= MAX_CELL_DIFFERENCE * mGrid.getRowHeight(
                mRowMatch.type == SegmentType.BOTTOM ? endRow : row, 1)) {
            if (mRowMatch.type == SegmentType.BOTTOM) {
                row += rowSpan - 1;
            }
            rowSpan = 1;
        }
        if (!mColumnMatch.createCell && bounds.w <= MAX_CELL_DIFFERENCE * mGrid.getColumnWidth(
                mColumnMatch.type == SegmentType.RIGHT ? endColumn : column, 1)) {
            if (mColumnMatch.type == SegmentType.RIGHT) {
                column += columnSpan - 1;
            }
            columnSpan = 1;
        }

        if (mColumnMatch.type == SegmentType.CENTER_HORIZONTAL) {
            column = 0;
            columnSpan = mGrid.actualColumnCount;
        }

        // Temporary: Ensure we don't get in trouble with implicit positions
        mGrid.applyPositionAttributes();

        // Split cells to make a new column
        if (mColumnMatch.createCell) {
            int columnWidthPx = mGrid.getColumnDistance(column, mColumnMatch.matchedLine);
            //assert columnWidthPx == columnMatch.distance; // TBD? IF so simplify
            int columnWidthDp = mRule.getRulesEngine().pxToDp(columnWidthPx);

            int maxX = mGrid.getColumnMaxX(column);
            boolean insertMarginColumn = false;
            if (mColumnMatch.margin == 0) {
                columnWidthDp = 0;
            } else if (mColumnMatch.margin != UNDEFINED) {
                int distance = abs(mColumnMatch.matchedLine - (maxX + mColumnMatch.margin));
                insertMarginColumn = column > 0 && distance < 2;
                if (insertMarginColumn) {
                    int margin = mColumnMatch.margin;
                    if (ViewMetadataRepository.INSETS_SUPPORTED) {
                        IViewMetadata metadata = mRule.getRulesEngine().getMetadata(fqcn);
                        if (metadata != null) {
                            Margins insets = metadata.getInsets();
                            if (insets != null) {
                                // TODO:
                                // Consider left or right side attachment
                                // TODO: Also consider inset of element on cell to the left
                                margin -= insets.left;
                            }
                        }
                    }

                    columnWidthDp = mRule.getRulesEngine().pxToDp(margin);
                }
            }

            column++;
            mGrid.splitColumn(column, insertMarginColumn, columnWidthDp, mColumnMatch.matchedLine);
            if (insertMarginColumn) {
                column++;
            }
        }

        // Split cells to make a new  row
        if (mRowMatch.createCell) {
            int rowHeightPx = mGrid.getRowDistance(row, mRowMatch.matchedLine);
            //assert rowHeightPx == rowMatch.distance; // TBD? If so simplify
            int rowHeightDp = mRule.getRulesEngine().pxToDp(rowHeightPx);

            int maxY = mGrid.getRowMaxY(row);
            boolean insertMarginRow = false;
            if (mRowMatch.margin == 0) {
                rowHeightDp = 0;
            } else if (mRowMatch.margin != UNDEFINED) {
                int distance = abs(mRowMatch.matchedLine - (maxY + mRowMatch.margin));
                insertMarginRow = row > 0 && distance < 2;
                if (insertMarginRow) {
                    int margin = mRowMatch.margin;
                    IViewMetadata metadata = mRule.getRulesEngine().getMetadata(element.getFqcn());
                    if (metadata != null) {
                        Margins insets = metadata.getInsets();
                        if (insets != null) {
                            // TODO:
                            // Consider left or right side attachment
                            // TODO: Also consider inset of element on cell to the left
                            margin -= insets.top;
                        }
                    }

                    rowHeightDp = mRule.getRulesEngine().pxToDp(margin);
                }
            }

            row++;
            mGrid.splitRow(row, insertMarginRow, rowHeightDp, mRowMatch.matchedLine);
            if (insertMarginRow) {
                row++;
            }
        }

        // Figure out where to insert the new child

        int index = mGrid.getInsertIndex(row, column);
        if (index == -1) {
            // Couldn't find a later place to insert
            newChild = targetNode.appendChild(fqcn);
        } else {
            GridModel.ViewData next = mGrid.getView(index);

            newChild = targetNode.insertChildAt(fqcn, index);

            // Must also apply positions to the following child to ensure
            // that the new child doesn't affect the implicit numbering!
            // TODO: We can later check whether the implied number is equal to
            // what it already is such that we don't need this
            next.applyPositionAttributes();
        }

        // Set the cell position (gravity) of the new widget
        int gravity = 0;
        if (mColumnMatch.type == SegmentType.RIGHT) {
            gravity |= GravityHelper.GRAVITY_RIGHT;
        } else if (mColumnMatch.type == SegmentType.CENTER_HORIZONTAL) {
            gravity |= GravityHelper.GRAVITY_CENTER_HORIZ;
        }
        mGrid.setGridAttribute(newChild, ATTR_LAYOUT_COLUMN, column);
        if (mRowMatch.type == SegmentType.BASELINE) {
            // There *is* no baseline gravity constant, instead, leave the
            // vertical gravity unspecified and GridLayout will treat it as
            // baseline alignment
            //gravity |= GravityHelper.GRAVITY_BASELINE;
        } else if (mRowMatch.type == SegmentType.BOTTOM) {
            gravity |= GravityHelper.GRAVITY_BOTTOM;
        } else if (mRowMatch.type == SegmentType.CENTER_VERTICAL) {
            gravity |= GravityHelper.GRAVITY_CENTER_VERT;
        }
        // Ensure that we have at least one horizontal and vertical constraint, otherwise
        // the new item will be fixed. As an example, if we have a single button in the
        // table which we inserted *without* a gravity, and we then insert a button
        // above it with a vertical gravity, then only the top column would be considered
        // stretchable, and it will fill all available vertical space and the previous
        // button will jump to the bottom.
        if (!GravityHelper.isConstrainedHorizontally(gravity)) {
            gravity |= GravityHelper.GRAVITY_LEFT;
        }
        /* This causes problems: Try placing two buttons vertically from the top of the layout.
           We need to solve the free column/free row problem first.
        if (!GravityHelper.isConstrainedVertically(gravity)
                // There is no baseline constant, so we have to leave it unconstrained instead
                && mRowMatch.type != SegmentType.BASELINE
                // You also can't baseline align one element with another that has vertical
                // alignment top or bottom, so when we first "freely" place views (e.g.
                // at a particular y location), also place it freely (no constraint).
                && !mRowMatch.createCell) {
            gravity |= GravityHelper.GRAVITY_TOP;
        }
        */
        mGrid.setGridAttribute(newChild, ATTR_LAYOUT_GRAVITY, getGravity(gravity));

        mGrid.setGridAttribute(newChild, ATTR_LAYOUT_ROW, row);

        // Apply spans to ensure that the widget can fit without pushing columns
        if (columnSpan > 1) {
            mGrid.setGridAttribute(newChild, ATTR_LAYOUT_COLUMN_SPAN, columnSpan);
        }
        if (rowSpan > 1) {
            mGrid.setGridAttribute(newChild, ATTR_LAYOUT_ROW_SPAN, rowSpan);
        }

        // Ensure that we don't store columnCount=0
        if (mGrid.actualColumnCount == 0) {
            mGrid.setGridAttribute(mGrid.layout, ATTR_COLUMN_COUNT, Math.max(1, column + 1));
        }

        return newChild;
    }

    /**
     * Called when a drop is completed and we're in grid-editing mode. This will insert
     * the dragged element into the target cell.
     *
     * @param targetNode the GridLayout node
     * @param element the dragged element
     * @return the newly created node
     */
    public INode handleGridModeDrop(INode targetNode, IDragElement element) {
        String fqcn = element.getFqcn();
        INode newChild = targetNode.appendChild(fqcn);

        int column = mColumnMatch.cellIndex;
        if (mColumnMatch.createCell) {
            mGrid.addColumn(column,
                    newChild, UNDEFINED, false, UNDEFINED, UNDEFINED);
        }
        int row = mRowMatch.cellIndex;
        if (mRowMatch.createCell) {
            mGrid.addRow(row, newChild, UNDEFINED, false, UNDEFINED, UNDEFINED);
        }

        mGrid.setGridAttribute(newChild, ATTR_LAYOUT_COLUMN, column);
        mGrid.setGridAttribute(newChild, ATTR_LAYOUT_ROW, row);

        int gravity = 0;
        if (mColumnMatch.type == SegmentType.RIGHT) {
            gravity |= GravityHelper.GRAVITY_RIGHT;
        } else if (mColumnMatch.type == SegmentType.CENTER_HORIZONTAL) {
            gravity |= GravityHelper.GRAVITY_CENTER_HORIZ;
        }
        if (mRowMatch.type == SegmentType.BASELINE) {
            // There *is* no baseline gravity constant, instead, leave the
            // vertical gravity unspecified and GridLayout will treat it as
            // baseline alignment
            //gravity |= GravityHelper.GRAVITY_BASELINE;
        } else if (mRowMatch.type == SegmentType.BOTTOM) {
            gravity |= GravityHelper.GRAVITY_BOTTOM;
        } else if (mRowMatch.type == SegmentType.CENTER_VERTICAL) {
            gravity |= GravityHelper.GRAVITY_CENTER_VERT;
        }
        if (!GravityHelper.isConstrainedHorizontally(gravity)) {
            gravity |= GravityHelper.GRAVITY_LEFT;
        }
        if (!GravityHelper.isConstrainedVertically(gravity)) {
            gravity |= GravityHelper.GRAVITY_TOP;
        }
        mGrid.setGridAttribute(newChild, ATTR_LAYOUT_GRAVITY, getGravity(gravity));

        if (mGrid.declaredColumnCount == UNDEFINED || mGrid.declaredColumnCount < column + 1) {
            mGrid.setGridAttribute(mGrid.layout, ATTR_COLUMN_COUNT, column + 1);
        }

        return newChild;
    }

    /**
     * Returns the best horizontal match
     *
     * @return the best horizontal match, or null if there is no match
     */
    public GridMatch getColumnMatch() {
        return mColumnMatch;
    }

    /**
     * Returns the best vertical match
     *
     * @return the best vertical match, or null if there is no match
     */
    public GridMatch getRowMatch() {
        return mRowMatch;
    }

    /**
     * Returns the grid used by the drop handler
     *
     * @return the grid used by the drop handler, never null
     */
    public GridModel getGrid() {
        return mGrid;
    }
}