/*
 * Copyright 2008 Google Inc.
 *
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * 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.google.gwt.gen2.table.client;

import com.google.gwt.dom.client.*;
import com.google.gwt.gen2.event.shared.*;
import com.google.gwt.gen2.table.event.client.*;
import com.google.gwt.gen2.table.event.client.TableEvent.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.Element;

import java.util.*;

/**
 * A variation of the {@link Grid} that supports row or cell highlight and row
 * selection.
 * <p/>
 * <h3>CSS Style Rules</h3>
 * <p/>
 * <ul class="css">
 * <p/>
 * <li>tr.selected { applied to selected rows }</li>
 * <p/>
 * <li>tr.highlighted { applied to row currently being highlighted }</li>
 * <p/>
 * <li>td.highlighted { applied to cell currently being highlighted }</li>
 * <p/>
 * </ul>
 */
public class SelectionGrid extends Grid implements HasRowHighlightHandlers,
                                                   HasRowUnhighlightHandlers,
                                                   HasCellHighlightHandlers,
                                                   HasCellUnhighlightHandlers,
                                                   HasRowSelectionHandlers {
    /**
     * This class contains methods used to format a table's cells.
     */
    public class SelectionGridCellFormatter extends CellFormatter {
        @Override
        protected Element getRawElement( int row, int column ) {
            if ( selectionPolicy.hasInputColumn() ) {
                column += 1;
            }
            return super.getRawElement( row, column );
        }
    }

    /**
     * This class contains methods used to format a table's rows.
     */
    public class SelectionGridRowFormatter extends RowFormatter {
        @Override
        protected Element getRawElement( int row ) {
            return super.getRawElement( row );
        }
    }

    /**
     * Selection policies.
     * <p/>
     * <ul>
     * <li>ONE_ROW - one row can be selected at a time</li>
     * <li>MULTI_ROW - multiple rows can be selected at a time</li>
     * <li>CHECKBOX - multiple rows can be selected using checkboxes</li>
     * <li>RADIO - one row can be selected using radio buttons</li>
     * </ul>
     */
    public static enum SelectionPolicy {
        ONE_ROW( null ), MULTI_ROW( null ), CHECKBOX( "<input type='checkbox'/>" ), RADIO( "<input name='%NAME%' type='radio'/>" );

        private String inputHtml;

        private SelectionPolicy( String inputHtml ) {
            this.inputHtml = inputHtml;
        }

        /**
         * @return true if the policy requires a selection column
         */
        public boolean hasInputColumn() {
            return inputHtml != null;
        }

        /**
         * @return the HTML string used for this policy
         */
        private String getInputHtml() {
            return inputHtml;
        }
    }

    /**
     * Unique IDs assigned to the grids.
     */
    private static int uniqueID = 0;

    /**
     * The cell element currently being highlight.
     */
    private Element highlightedCellElem = null;

    /**
     * The index of the cell currently being highlight.
     */
    private int highlightedCellIndex = -1;

    /**
     * The row element currently being highlight.
     */
    private Element highlightedRowElem = null;

    /**
     * The index of the row currently being highlight.
     */
    private int highlightedRowIndex = -1;

    /**
     * Unique ID of this grid.
     */
    private int id;

    /**
     * The index of the row that the user selected last.
     */
    private int lastSelectedRowIndex = -1;

    /**
     * The rows that are currently selected.
     */
    private Map<Integer, Element> selectedRows = new HashMap<Integer, Element>();

    /**
     * A boolean indicating if selection is enabled disabled.
     */
    private boolean selectionEnabled = true;

    /**
     * The selection policy determines if the user can select zero, one, or many
     * rows.
     */
    private SelectionPolicy selectionPolicy = SelectionPolicy.MULTI_ROW;

    /**
     * Construct a new {@link SelectionGrid}.
     */
    public SelectionGrid() {
        super();
        id = uniqueID++;
        setCellFormatter( new SelectionGridCellFormatter() );
        setRowFormatter( new SelectionGridRowFormatter() );

        // Sink highlight and selection events
        sinkEvents( Event.ONMOUSEOVER | Event.ONMOUSEOUT | Event.ONMOUSEDOWN | Event.ONCLICK );
    }

    /**
     * Constructs a {@link SelectionGrid} with the requested size.
     *
     * @param rows    the number of rows
     * @param columns the number of columns
     *
     * @throws IndexOutOfBoundsException
     */
    public SelectionGrid( int rows, int columns ) {
        this();
        resize( rows, columns );
    }

    @Override
    public HandlerRegistration addCellHighlightHandler( CellHighlightHandler handler ) {
        return addHandler( CellHighlightEvent.TYPE, handler );
    }

    @Override
    public HandlerRegistration addCellUnhighlightHandler( CellUnhighlightHandler handler ) {
        return addHandler( CellUnhighlightEvent.TYPE, handler );
    }

    @Override
    public HandlerRegistration addRowHighlightHandler( RowHighlightHandler handler ) {
        return addHandler( RowHighlightEvent.TYPE, handler );
    }

    @Override
    public HandlerRegistration addRowSelectionHandler( RowSelectionHandler handler ) {
        return addHandler( RowSelectionEvent.TYPE, handler );
    }

    @Override
    public HandlerRegistration addRowUnhighlightHandler( RowUnhighlightHandler handler ) {
        return addHandler( RowUnhighlightEvent.TYPE, handler );
    }

    /**
     * Deselect all selected rows in the data table.
     */
    public void deselectAllRows() {
        deselectAllRows( true );
    }

    /**
     * Deselect a row in the grid. This method is safe to call even if the row is
     * not selected, or doesn't exist (out of bounds).
     *
     * @param row the row index
     */
    public void deselectRow( int row ) {
        deselectRow( row, true );
    }

    /**
     * @return the set of selected row indexes
     */
    public Set<Integer> getSelectedRows() {
        return selectedRows.keySet();
    }

    /**
     * Explicitly gets the {@link SelectionGridCellFormatter}. The results of
     * {@link HTMLTable#getCellFormatter()}
     * may also be downcast to a {@link SelectionGridCellFormatter}.
     *
     * @return the FlexTable's cell formatter
     */
    public SelectionGridCellFormatter getSelectionGridCellFormatter() {
        return (SelectionGridCellFormatter) getCellFormatter();
    }

    /**
     * Explicitly gets the {@link SelectionGridRowFormatter}. The results of
     * {@link HTMLTable#getRowFormatter()}
     * may also be downcast to a {@link SelectionGridRowFormatter}.
     *
     * @return the FlexTable's cell formatter
     */
    public SelectionGridRowFormatter getSelectionGridRowFormatter() {
        return (SelectionGridRowFormatter) getRowFormatter();
    }

    /**
     * @return the selection policy
     */
    public SelectionPolicy getSelectionPolicy() {
        return selectionPolicy;
    }

    @Override
    public int insertRow( int beforeRow ) {
        deselectAllRows();
        return super.insertRow( beforeRow );
    }

    /**
     * @param row the row index
     *
     * @return true if the row is selected, false if not
     */
    public boolean isRowSelected( int row ) {
        return selectedRows.containsKey( new Integer( row ) );
    }

    /**
     * @return true if selection is enabled
     */
    public boolean isSelectionEnabled() {
        return selectionEnabled;
    }

    @Override
    public void onBrowserEvent( Event event ) {
        super.onBrowserEvent( event );
        Element targetRow = null;
        Element targetCell = null;

        switch ( DOM.eventGetType( event ) ) {
            // Highlight the cell on mouse over
            case Event.ONMOUSEOVER:
                Element cellElem = getEventTargetCell( event );
                if ( cellElem != null ) {
                    highlightCell( cellElem );
                }
                break;

            // Unhighlight on mouse out
            case Event.ONMOUSEOUT:
                Element toElem = DOM.eventGetToElement( event );
                if ( highlightedRowElem != null && (toElem == null || !highlightedRowElem.isOrHasChild( toElem )) ) {
                    // Check that the coordinates are not directly over the cell
                    int clientX = event.getClientX() + Window.getScrollLeft();
                    int clientY = event.getClientY() + Window.getScrollTop();
                    int rowLeft = highlightedRowElem.getAbsoluteLeft();
                    int rowTop = highlightedRowElem.getAbsoluteTop();
                    int rowWidth = highlightedRowElem.getOffsetWidth();
                    int rowHeight = highlightedRowElem.getOffsetHeight();
                    int rowBottom = rowTop + rowHeight;
                    int rowRight = rowLeft + rowWidth;
                    if ( clientX > rowLeft && clientX < rowRight && clientY > rowTop && clientY < rowBottom ) {
                        return;
                    }

                    // Unhighlight the current cell
                    highlightCell( null );
                }
                break;

            // Select a row on click
            case Event.ONMOUSEDOWN: {
                // Ignore if selection is disabled
                if ( !selectionEnabled ) {
                    return;
                }

                // Get the target row
                targetCell = getEventTargetCell( event );
                if ( targetCell == null ) {
                    return;
                }
                targetRow = DOM.getParent( targetCell );
                int targetRowIndex = getRowIndex( targetRow );

                // Select the row
                if ( selectionPolicy == SelectionPolicy.MULTI_ROW ) {
                    boolean shiftKey = DOM.eventGetShiftKey( event );
                    boolean ctrlKey = DOM.eventGetCtrlKey( event ) || DOM.eventGetMetaKey( event );

                    // Prevent default text selection
                    if ( ctrlKey || shiftKey ) {
                        event.preventDefault();
                    }

                    // Select the rows
                    selectRow( targetRowIndex, ctrlKey, shiftKey );
                } else if ( selectionPolicy == SelectionPolicy.ONE_ROW ||
                            (selectionPolicy == SelectionPolicy.RADIO && targetCell == targetRow.getFirstChild()) ) {
                    selectRow( -1, targetRow, true, true );
                    lastSelectedRowIndex = targetRowIndex;
                }
            }
            break;

            // Prevent native inputs from being checked
            case Event.ONCLICK: {
                // Ignore if selection is disabled
                if ( !selectionEnabled ) {
                    return;
                }

                // Get the target row
                targetCell = getEventTargetCell( event );
                if ( targetCell == null ) {
                    return;
                }
                targetRow = DOM.getParent( targetCell );
                int targetRowIndex = getRowIndex( targetRow );

                // Select the row
                if ( selectionPolicy == SelectionPolicy.CHECKBOX && targetCell == targetRow.getFirstChild() ) {
                    selectRow( targetRowIndex, true, DOM.eventGetShiftKey( event ) );
                }
            }
            break;
        }
    }

    @Override
    public void removeRow( int row ) {
        deselectAllRows();
        super.removeRow( row );
    }

    /**
     * Select all rows in the table.
     */
    public void selectAllRows() {
        // Get the currently selected rows
        Set<Row> oldRowSet = getSelectedRowsSet();

        // Select all rows
        RowFormatter rowFormatter = getRowFormatter();
        int rowCount = getRowCount();
        for ( int i = 0; i < rowCount; i++ ) {
            if ( !selectedRows.containsKey( i ) ) {
                selectRow( i, rowFormatter.getElement( i ), false, false );
            }
        }

        // Trigger the event
        fireRowSelectionEvent( oldRowSet );
    }

    /**
     * Select a row in the data table.
     *
     * @param row         the row index
     * @param unselectAll unselect all other rows first
     *
     * @throws IndexOutOfBoundsException
     */
    public void selectRow( int row, boolean unselectAll ) {
        selectRow( row, getRowFormatter().getElement( row ), unselectAll, true );
    }

    /**
     * Select a row in the data table. Simulate the effect of a shift click and/or
     * control click. This method ignores the selection policy, which only applies
     * to user selection via mouse events.
     *
     * @param row      the row index
     * @param ctrlKey  true to simulate a control click
     * @param shiftKey true to simulate a shift selection
     *
     * @throws IndexOutOfBoundsException
     */
    public void selectRow( int row, boolean ctrlKey, boolean shiftKey ) {
        // Check the row bounds
        checkRowBounds( row );

        // Get the old list of selected rows
        Set<Row> oldRowList = getSelectedRowsSet();

        // Deselect all rows
        if ( !ctrlKey ) {
            deselectAllRows( false );
        }

        boolean isSelected = selectedRows.containsKey( new Integer( row ) );
        if ( shiftKey && (lastSelectedRowIndex > -1) ) {
            // Shift+select rows
            SelectionGridRowFormatter formatter = getSelectionGridRowFormatter();
            int firstRow = Math.min( row, lastSelectedRowIndex );
            int lastRow = Math.max( row, lastSelectedRowIndex );
            lastRow = Math.min( lastRow, getRowCount() - 1 );
            for ( int curRow = firstRow; curRow <= lastRow; curRow++ ) {
                if ( isSelected ) {
                    deselectRow( curRow, false );
                } else {
                    selectRow( curRow, formatter.getRawElement( curRow ), false, false );
                }
            }

            // Fire Event
            lastSelectedRowIndex = row;
            fireRowSelectionEvent( oldRowList );
        } else if ( isSelected ) {
            // Ctrl+unselect a selected row
            deselectRow( row, false );
            lastSelectedRowIndex = row;
            fireRowSelectionEvent( oldRowList );
        } else {
            // Select the row
            SelectionGridRowFormatter formatter = getSelectionGridRowFormatter();
            selectRow( row, formatter.getRawElement( row ), false, false );
            lastSelectedRowIndex = row;
            fireRowSelectionEvent( oldRowList );
        }
    }

    /**
     * Enable or disable row selection.
     *
     * @param enabled true to enable, false to disable
     */
    public void setSelectionEnabled( boolean enabled ) {
        selectionEnabled = enabled;

        // Update the input elements
        if ( selectionPolicy.hasInputColumn() ) {
            SelectionGridCellFormatter formatter = getSelectionGridCellFormatter();
            int rowCount = getRowCount();
            for ( int i = 0; i < rowCount; i++ ) {
                Element td = formatter.getRawElement( i, -1 );
                setInputEnabled( selectionPolicy, td, enabled );
            }
        }
    }

    /**
     * Set the selection policy, which determines if the user can select zero,
     * one, or multiple rows.
     *
     * @param selectionPolicy the selection policy
     */
    public void setSelectionPolicy( SelectionPolicy selectionPolicy ) {
        if ( this.selectionPolicy == selectionPolicy ) {
            return;
        }
        deselectAllRows();

        // Update the input column
        if ( selectionPolicy.hasInputColumn() ) {
            if ( this.selectionPolicy.hasInputColumn() ) {
                // Update the existing input column
                String inputHtml = getInputHtml( selectionPolicy );
                for ( int i = 0; i < numRows; i++ ) {
                    Element tr = getRowFormatter().getElement( i );
                    tr.getFirstChildElement().setInnerHTML( inputHtml );
                }
            } else {
                // Add an input column to every row
                String inputHtml = getInputHtml( selectionPolicy );
                Element td = createCell();
                td.setInnerHTML( inputHtml );
                for ( int i = 0; i < numRows; i++ ) {
                    Element tr = getRowFormatter().getElement( i );
                    tr.insertBefore( td.cloneNode( true ), tr.getFirstChildElement() );
                }
            }
        } else if ( this.selectionPolicy.hasInputColumn() ) {
            // Remove the input column from every row
            for ( int i = 0; i < numRows; i++ ) {
                Element tr = getRowFormatter().getElement( i );
                tr.removeChild( tr.getFirstChildElement() );
            }
        }
        this.selectionPolicy = selectionPolicy;

        // Update the enabled state
        setSelectionEnabled( selectionEnabled );
    }

    @Override
    protected Element createRow() {
        Element tr = super.createRow();
        if ( selectionPolicy.hasInputColumn() ) {
            Element td = createCell();
            td.setPropertyString( "align", "center" );
            td.setInnerHTML( getInputHtml( selectionPolicy ) );
            DOM.insertChild( tr, td, 0 );
            if ( !selectionEnabled ) {
                setInputEnabled( selectionPolicy, td, false );
            }
        }
        return tr;
    }

    /**
     * Deselect all selected rows in the data table.
     *
     * @param fireEvent true to fire events
     */
    protected void deselectAllRows( boolean fireEvent ) {
        // Get the old list of selected rows
        Set<Row> oldRows = null;
        if ( fireEvent ) {
            oldRows = getSelectedRowsSet();
        }

        // Deselect all rows
        boolean hasInputColumn = selectionPolicy.hasInputColumn();
        for ( Element rowElem : selectedRows.values() ) {
            setStyleName( rowElem, "selected", false );
            if ( hasInputColumn ) {
                setInputSelected( getSelectionPolicy(), (Element) rowElem.getFirstChildElement(), false );
            }
        }

        // Clear out the rows
        selectedRows.clear();

        // Fire event
        if ( fireEvent ) {
            fireRowSelectionEvent( oldRows );
        }
    }

    /**
     * Deselect a row in the grid. This method is safe to call even if the row is
     * not selected, or doesn't exist (out of bounds).
     *
     * @param row       the row index
     * @param fireEvent true to fire events
     */
    protected void deselectRow( int row, boolean fireEvent ) {
        Element rowElem = selectedRows.remove( new Integer( row ) );
        if ( rowElem != null ) {
            // Get the old list of selected rows
            Set<Row> oldRows = null;
            if ( fireEvent ) {
                oldRows = getSelectedRowsSet();
            }

            // Deselect the row
            setStyleName( rowElem, "selected", false );
            if ( selectionPolicy.hasInputColumn() ) {
                setInputSelected( getSelectionPolicy(), (Element) rowElem.getFirstChildElement(), false );
            }

            // Fire Event
            if ( fireEvent ) {
                fireRowSelectionEvent( oldRows );
            }
        }
    }

    /**
     * Fire a {@link RowSelectionEvent}. This method will automatically add the
     * currently selected rows.
     *
     * @param oldRowSet the set of previously selected rows
     */
    protected void fireRowSelectionEvent( Set<Row> oldRowSet ) {
        Set<Row> newRowList = getSelectedRowsSet();
        if ( newRowList.equals( oldRowSet ) ) {
            return;
        }
        fireEvent( new RowSelectionEvent( oldRowSet, newRowList ) );
    }

    @Override
    protected int getCellIndex( Element rowElem, Element cellElem ) {
        int index = super.getCellIndex( rowElem, cellElem );
        if ( selectionPolicy.hasInputColumn() ) {
            index--;
        }
        return index;
    }

    @Override
    protected int getDOMCellCount( int row ) {
        int count = super.getDOMCellCount( row );
        if ( getSelectionPolicy().hasInputColumn() ) {
            count--;
        }
        return count;
    }

    /**
     * Get the html used to create the native input selection element.
     *
     * @param selectionPolicy the associated {@link SelectionPolicy}
     *
     * @return the html representation of the input element
     */
    protected String getInputHtml( SelectionPolicy selectionPolicy ) {
        String inputHtml = selectionPolicy.getInputHtml();
        if ( inputHtml != null ) {
            inputHtml = inputHtml.replace( "%NAME%", "__gwtSelectionGrid" + id );
        }
        return inputHtml;
    }

    /**
     * @return a map or selected row indexes to their elements
     */
    protected Map<Integer, Element> getSelectedRowsMap() {
        return selectedRows;
    }

    /**
     * @return a list of selected rows to pass into a {@link RowSelectionEvent}
     */
    protected Set<Row> getSelectedRowsSet() {
        Set<Row> rowSet = new TreeSet<Row>();
        for ( Integer rowIndex : selectedRows.keySet() ) {
            rowSet.add( new Row( rowIndex.intValue() ) );
        }
        return rowSet;
    }

    /**
     * Set the current highlighted cell.
     *
     * @param cellElem the cell element
     */
    protected void highlightCell( Element cellElem ) {
        // Ignore if the cell is already being highlighted
        if ( cellElem == highlightedCellElem ) {
            return;
        }

        // Get the row element
        Element rowElem = null;
        if ( cellElem != null ) {
            rowElem = DOM.getParent( cellElem );
        }

        // Unhighlight the current cell
        if ( highlightedCellElem != null ) {
            setStyleName( highlightedCellElem, "highlighted", false );
            fireEvent( new CellUnhighlightEvent( highlightedRowIndex, highlightedCellIndex ) );
            highlightedCellElem = null;
            highlightedCellIndex = -1;

            // Unhighlight the current row if it changed
            if ( rowElem != highlightedRowElem ) {
                setStyleName( highlightedRowElem, "highlighted", false );
                fireEvent( new RowUnhighlightEvent( highlightedRowIndex ) );
                highlightedRowElem = null;
                highlightedRowIndex = -1;
            }
        }

        // Highlight the cell
        if ( cellElem != null ) {
            setStyleName( cellElem, "highlighted", true );
            highlightedCellElem = cellElem;
            highlightedCellIndex = OverrideDOM.getCellIndex( cellElem );

            // Highlight the row if it changed
            if ( highlightedRowElem == null ) {
                setStyleName( rowElem, "highlighted", true );
                highlightedRowElem = rowElem;
                highlightedRowIndex = getRowIndex( highlightedRowElem );
                fireEvent( new RowHighlightEvent( highlightedRowIndex ) );
            }

            // Fire listeners
            fireEvent( new CellHighlightEvent( highlightedRowIndex, highlightedCellIndex ) );
        }
    }

    /**
     * Select a row in the data table.
     *
     * @param row         the row index, or -1 if unknown
     * @param rowElem     the row element
     * @param unselectAll true to unselect all currently selected rows
     * @param fireEvent   true to fire the select event to listeners
     */
    protected void selectRow( int row, Element rowElem, boolean unselectAll, boolean fireEvent ) {
        // Get the row index if needed
        if ( row < 0 ) {
            row = getRowIndex( rowElem );
        }

        // Ignore request if row already selected
        Integer rowI = new Integer( row );
        if ( selectedRows.containsKey( rowI ) ) {
            return;
        }

        // Get the old list of selected rows
        Set<Row> oldRowSet = null;
        if ( fireEvent ) {
            oldRowSet = getSelectedRowsSet();
        }

        // Deselect current rows
        if ( unselectAll ) {
            deselectAllRows( false );
        }

        // Select the new row
        selectedRows.put( rowI, rowElem );
        setStyleName( rowElem, "selected", true );
        if ( selectionPolicy.hasInputColumn() ) {
            setInputSelected( getSelectionPolicy(), (Element) rowElem.getFirstChildElement(), true );
        }

        // Fire grid listeners
        if ( fireEvent ) {
            fireRowSelectionEvent( oldRowSet );
        }
    }

    @Override
    protected void setBodyElement( Element element ) {
        super.setBodyElement( element );
        if ( !selectionEnabled ) {
            setSelectionEnabled( selectionEnabled );
        }
    }

    /**
     * Enabled or disabled the native input element in the given cell. This method
     * should correspond with the HTML returned from {@link #getInputHtml}.
     *
     * @param selectionPolicy the associated {@link SelectionPolicy}
     * @param td              the cell containing the element
     * @param enabled         true to enable, false to disable
     */
    protected void setInputEnabled( SelectionPolicy selectionPolicy, Element td, boolean enabled ) {
        ((InputElement) td.getFirstChild()).setDisabled( !enabled );
    }

    /**
     * Select the native input element in the given cell. This method should
     * correspond with the HTML returned from {@link #getInputHtml}.
     *
     * @param selectionPolicy the associated {@link SelectionPolicy}
     * @param td              the cell containing the element
     * @param selected        true to select, false to deselect
     */
    protected void setInputSelected( SelectionPolicy selectionPolicy, Element td, boolean selected ) {
        ((InputElement) td.getFirstChild()).setChecked( selected );
    }
}