/*

 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.swing.text;

import java.awt.*;

import java.util.BitSet;

import java.util.Vector;

import javax.swing.SizeRequirements;

import javax.swing.event.DocumentEvent;

import javax.swing.text.html.HTML;

/**

 * <p>

 * Implements View interface for a table, that is composed of an

 * element structure where the child elements of the element

 * this view is responsible for represent rows and the child

 * elements of the row elements are cells.  The cell elements can

 * have an arbitrary element structure under them, which will

 * be built with the ViewFactory returned by the getViewFactory

 * method.

 * <pre>

 *

 *    TABLE

 *      ROW

 *        CELL

 *        CELL

 *      ROW

 *        CELL

 *        CELL

 *

 * </pre>

 * <p>

 * This is implemented as a hierarchy of boxes, the table itself

 * is a vertical box, the rows are horizontal boxes, and the cells

 * are vertical boxes.  The cells are allowed to span multiple

 * columns and rows.  By default, the table can be thought of as

 * being formed over a grid (i.e. somewhat like one would find in

 * gridbag layout), where table cells can request to span more

 * than one grid cell.  The default horizontal span of table cells

 * will be based upon this grid, but can be changed by reimplementing

 * spans if desired).

 *

 * @author  Timothy Prinzing

 * @see     View

 */

public abstract class TableView extends BoxView {

    /**

     * Constructs a TableView for the given element.

     *

     * @param elem the element that this view is responsible for

     */

    public TableView(Element elem) {

        super(elem, View.Y_AXIS);

        rows = new Vector<TableRow>();

        gridValid = false;

        totalColumnRequirements = new SizeRequirements();

    }

    /**

     * Creates a new table row.

     *

     * @param elem an element

     * @return the row

     */

    protected TableRow createTableRow(Element elem) {

        return new TableRow(elem);

    }

    /**

     * @deprecated Table cells can now be any arbitrary

     * View implementation and should be produced by the

     * ViewFactory rather than the table.

     *

     * @param elem an element

     * @return the cell

     */

    @Deprecated

    protected TableCell createTableCell(Element elem) {

        return new TableCell(elem);

    }

    /**

     * The number of columns in the table.

     */

    int getColumnCount() {

        return columnSpans.length;

    }

    /**

     * Fetches the span (width) of the given column.

     * This is used by the nested cells to query the

     * sizes of grid locations outside of themselves.

     */

    int getColumnSpan(int col) {

        return columnSpans[col];

    }

    /**

     * The number of rows in the table.

     */

    int getRowCount() {

        return rows.size();

    }

    /**

     * Fetches the span (height) of the given row.

     */

    int getRowSpan(int row) {

        View rv = getRow(row);

        if (rv != null) {

            return (int) rv.getPreferredSpan(Y_AXIS);

        }

        return 0;

    }

    TableRow getRow(int row) {

        if (row < rows.size()) {

            return rows.elementAt(row);

        }

        return null;

    }

    /**

     * Determines the number of columns occupied by

     * the table cell represented by given element.

     */

    /*protected*/ int getColumnsOccupied(View v) {

        // PENDING(prinz) this code should be in the html

        // paragraph, but we can't add api to enable it.

        AttributeSet a = v.getElement().getAttributes();

        String s = (String) a.getAttribute(HTML.Attribute.COLSPAN);

        if (s != null) {

            try {

                return Integer.parseInt(s);

            } catch (NumberFormatException nfe) {

                // fall through to one column

            }

        }

        return 1;

    }

    /**

     * Determines the number of rows occupied by

     * the table cell represented by given element.

     */

    /*protected*/ int getRowsOccupied(View v) {

        // PENDING(prinz) this code should be in the html

        // paragraph, but we can't add api to enable it.

        AttributeSet a = v.getElement().getAttributes();

        String s = (String) a.getAttribute(HTML.Attribute.ROWSPAN);

        if (s != null) {

            try {

                return Integer.parseInt(s);

            } catch (NumberFormatException nfe) {

                // fall through to one row

            }

        }

        return 1;

    }

    /*protected*/ void invalidateGrid() {

        gridValid = false;

    }

    protected void forwardUpdate(DocumentEvent.ElementChange ec,

                                     DocumentEvent e, Shape a, ViewFactory f) {

        super.forwardUpdate(ec, e, a, f);

        // A change in any of the table cells usually effects the whole table,

        // so redraw it all!

        if (a != null) {

            Component c = getContainer();

            if (c != null) {

                Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a :

                                   a.getBounds();

                c.repaint(alloc.x, alloc.y, alloc.width, alloc.height);

            }

        }

    }

    /**

     * Change the child views.  This is implemented to

     * provide the superclass behavior and invalidate the

     * grid so that rows and columns will be recalculated.

     */

    public void replace(int offset, int length, View[] views) {

        super.replace(offset, length, views);

        invalidateGrid();

    }

    /**

     * Fill in the grid locations that are placeholders

     * for multi-column, multi-row, and missing grid

     * locations.

     */

    void updateGrid() {

        if (! gridValid) {

            // determine which views are table rows and clear out

            // grid points marked filled.

            rows.removeAllElements();

            int n = getViewCount();

            for (int i = 0; i < n; i++) {

                View v = getView(i);

                if (v instanceof TableRow) {

                    rows.addElement((TableRow) v);

                    TableRow rv = (TableRow) v;

                    rv.clearFilledColumns();

                    rv.setRow(i);

                }

            }

            int maxColumns = 0;

            int nrows = rows.size();

            for (int row = 0; row < nrows; row++) {

                TableRow rv = getRow(row);

                int col = 0;

                for (int cell = 0; cell < rv.getViewCount(); cell++, col++) {

                    View cv = rv.getView(cell);

                    // advance to a free column

                    for (; rv.isFilled(col); col++);

                    int rowSpan = getRowsOccupied(cv);

                    int colSpan = getColumnsOccupied(cv);

                    if ((colSpan > 1) || (rowSpan > 1)) {

                        // fill in the overflow entries for this cell

                        int rowLimit = row + rowSpan;

                        int colLimit = col + colSpan;

                        for (int i = row; i < rowLimit; i++) {

                            for (int j = col; j < colLimit; j++) {

                                if (i != row || j != col) {

                                    addFill(i, j);

                                }

                            }

                        }

                        if (colSpan > 1) {

                            col += colSpan - 1;

                        }

                    }

                }

                maxColumns = Math.max(maxColumns, col);

            }

            // setup the column layout/requirements

            columnSpans = new int[maxColumns];

            columnOffsets = new int[maxColumns];

            columnRequirements = new SizeRequirements[maxColumns];

            for (int i = 0; i < maxColumns; i++) {

                columnRequirements[i] = new SizeRequirements();

            }

            gridValid = true;

        }

    }

    /**

     * Mark a grid location as filled in for a cells overflow.

     */

    void addFill(int row, int col) {

        TableRow rv = getRow(row);

        if (rv != null) {

            rv.fillColumn(col);

        }

    }

    /**

     * Lays out the columns to fit within the given target span.

     * Returns the results through {@code offsets} and {@code spans}.

     *

     * @param targetSpan the given span for total of all the table

     *  columns

     * @param reqs the requirements desired for each column.  This

     *  is the column maximum of the cells minimum, preferred, and

     *  maximum requested span

     * @param spans the return value of how much to allocated to

     *  each column

     * @param offsets the return value of the offset from the

     *  origin for each column

     */

    protected void layoutColumns(int targetSpan, int[] offsets, int[] spans,

                                 SizeRequirements[] reqs) {

        // allocate using the convenience method on SizeRequirements

        SizeRequirements.calculateTiledPositions(targetSpan, null, reqs,

                                                 offsets, spans);

    }

    /**

     * Perform layout for the minor axis of the box (i.e. the

     * axis orthogonal to the axis that it represents).  The results

     * of the layout should be placed in the given arrays which represent

     * the allocations to the children along the minor axis.  This

     * is called by the superclass whenever the layout needs to be

     * updated along the minor axis.

     * <p>

     * This is implemented to call the

     * {@link #layoutColumns layoutColumns} method, and then

     * forward to the superclass to actually carry out the layout

     * of the tables rows.

     *

     * @param targetSpan the total span given to the view, which

     *  would be used to layout the children.

     * @param axis the axis being layed out.

     * @param offsets the offsets from the origin of the view for

     *  each of the child views.  This is a return value and is

     *  filled in by the implementation of this method.

     * @param spans the span of each child view.  This is a return

     *  value and is filled in by the implementation of this method.

     */

    protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {

        // make grid is properly represented

        updateGrid();

        // all of the row layouts are invalid, so mark them that way

        int n = getRowCount();

        for (int i = 0; i < n; i++) {

            TableRow row = getRow(i);

            row.layoutChanged(axis);

        }

        // calculate column spans

        layoutColumns(targetSpan, columnOffsets, columnSpans, columnRequirements);

        // continue normal layout

        super.layoutMinorAxis(targetSpan, axis, offsets, spans);

    }

    /**

     * Calculate the requirements for the minor axis.  This is called by

     * the superclass whenever the requirements need to be updated (i.e.

     * a preferenceChanged was messaged through this view).

     * <p>

     * This is implemented to calculate the requirements as the sum of the

     * requirements of the columns.

     */

    protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) {

        updateGrid();

        // calculate column requirements for each column

        calculateColumnRequirements(axis);

        // the requirements are the sum of the columns.

        if (r == null) {

            r = new SizeRequirements();

        }

        long min = 0;

        long pref = 0;

        long max = 0;

        for (SizeRequirements req : columnRequirements) {

            min += req.minimum;

            pref += req.preferred;

            max += req.maximum;

        }

        r.minimum = (int) min;

        r.preferred = (int) pref;

        r.maximum = (int) max;

        r.alignment = 0;

        totalColumnRequirements.minimum = r.minimum;

        totalColumnRequirements.preferred = r.preferred;

        totalColumnRequirements.maximum = r.maximum;

        return r;

    }

    /*

    boolean shouldTrace() {

        AttributeSet a = getElement().getAttributes();

        Object o = a.getAttribute(HTML.Attribute.ID);

        if ((o != null) && o.equals("debug")) {

            return true;

        }

        return false;

    }

    */

    /**

     * Calculate the requirements for each column.  The calculation

     * is done as two passes over the table.  The table cells that

     * occupy a single column are scanned first to determine the

     * maximum of minimum, preferred, and maximum spans along the

     * give axis.  Table cells that span multiple columns are excluded

     * from the first pass.  A second pass is made to determine if

     * the cells that span multiple columns are satisfied.  If the

     * column requirements are not satisified, the needs of the

     * multi-column cell is mixed into the existing column requirements.

     * The calculation of the multi-column distribution is based upon

     * the proportions of the existing column requirements and taking

     * into consideration any constraining maximums.

     */

    void calculateColumnRequirements(int axis) {

        for (SizeRequirements req : columnRequirements) {

            req.minimum = 0;

            req.preferred = 0;

            req.maximum = Integer.MAX_VALUE;

        }

        // pass 1 - single column cells

        boolean hasMultiColumn = false;

        int nrows = getRowCount();

        for (int i = 0; i < nrows; i++) {

            TableRow row = getRow(i);

            int col = 0;

            int ncells = row.getViewCount();

            for (int cell = 0; cell < ncells; cell++, col++) {

                View cv = row.getView(cell);

                for (; row.isFilled(col); col++); // advance to a free column

                int rowSpan = getRowsOccupied(cv);

                int colSpan = getColumnsOccupied(cv);

                if (colSpan == 1) {

                    checkSingleColumnCell(axis, col, cv);

                } else {

                    hasMultiColumn = true;

                    col += colSpan - 1;

                }

            }

        }

        // pass 2 - multi-column cells

        if (hasMultiColumn) {

            for (int i = 0; i < nrows; i++) {

                TableRow row = getRow(i);

                int col = 0;

                int ncells = row.getViewCount();

                for (int cell = 0; cell < ncells; cell++, col++) {

                    View cv = row.getView(cell);

                    for (; row.isFilled(col); col++); // advance to a free column

                    int colSpan = getColumnsOccupied(cv);

                    if (colSpan > 1) {

                        checkMultiColumnCell(axis, col, colSpan, cv);

                        col += colSpan - 1;

                    }

                }

            }

        }

        /*

        if (shouldTrace()) {

            System.err.println("calc:");

            for (int i = 0; i < columnRequirements.length; i++) {

                System.err.println(" " + i + ": " + columnRequirements[i]);

            }

        }

        */

    }

    /**

     * check the requirements of a table cell that spans a single column.

     */

    void checkSingleColumnCell(int axis, int col, View v) {

        SizeRequirements req = columnRequirements[col];

        req.minimum = Math.max((int) v.getMinimumSpan(axis), req.minimum);

        req.preferred = Math.max((int) v.getPreferredSpan(axis), req.preferred);

        req.maximum = Math.max((int) v.getMaximumSpan(axis), req.maximum);

    }

    /**

     * check the requirements of a table cell that spans multiple

     * columns.

     */

    void checkMultiColumnCell(int axis, int col, int ncols, View v) {

        // calculate the totals

        long min = 0;

        long pref = 0;

        long max = 0;

        for (int i = 0; i < ncols; i++) {

            SizeRequirements req = columnRequirements[col + i];

            min += req.minimum;

            pref += req.preferred;

            max += req.maximum;

        }

        // check if the minimum size needs adjustment.

        int cmin = (int) v.getMinimumSpan(axis);

        if (cmin > min) {

            /*

             * the columns that this cell spans need adjustment to fit

             * this table cell.... calculate the adjustments.  The

             * maximum for each cell is the maximum of the existing

             * maximum or the amount needed by the cell.

             */

            SizeRequirements[] reqs = new SizeRequirements[ncols];

            for (int i = 0; i < ncols; i++) {

                SizeRequirements r = reqs[i] = columnRequirements[col + i];

                r.maximum = Math.max(r.maximum, (int) v.getMaximumSpan(axis));

            }

            int[] spans = new int[ncols];

            int[] offsets = new int[ncols];

            SizeRequirements.calculateTiledPositions(cmin, null, reqs,

                                                     offsets, spans);

            // apply the adjustments

            for (int i = 0; i < ncols; i++) {

                SizeRequirements req = reqs[i];

                req.minimum = Math.max(spans[i], req.minimum);

                req.preferred = Math.max(req.minimum, req.preferred);

                req.maximum = Math.max(req.preferred, req.maximum);

            }

        }

        // check if the preferred size needs adjustment.

        int cpref = (int) v.getPreferredSpan(axis);