// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.client.widgets.nonpublic;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

import java.util.*;

public abstract class AbstractSizeableTwoDimensionalPanel extends AbstractSizeableHasAlignmentPanel implements IndexedPanel {
    /**
     * Table element.
     */
    private Element tableElem;

    /**
     * Table's body.
     */
    private Element bodyElem;

    private WidgetCollection mChildren = new WidgetCollection( this );

    protected AbstractSizeableTwoDimensionalPanel() {
        tableElem = DOM.createTable();
        bodyElem = DOM.createTBody();
        DOM.appendChild( tableElem, bodyElem );
        setElement( tableElem ); // todo: ...
    }

    @Override
    public boolean anyChildren() {
        return (mChildren.size() != 0);
    }

    // vvvvvvvvvvv HasWidgets

    /**
     * Removes all child widgets.
     */
    @Override
    public void clear() {
        if ( anyChildren() ) {
            // todo: ...
        }
    }

    /**
     * Gets an iterator for the contained widgets. This iterator is required to
     * implement {@link Iterator#remove()}.
     */
    @SuppressWarnings({"unchecked"})
    @Override
    public Iterator iterator() {
        return mChildren.iterator();
    }

    /**
     * Adds a child widget.
     *
     * @param pWidget the widget to be added
     *
     * @throws UnsupportedOperationException if this method is not supported (most
     *                                       often this means that a specific overload must be called)
     */
    @Override
    public void add( Widget pWidget ) {
        // todo: ...
    }

    /**
     * Removes a child widget.
     *
     * @param pWidget the widget to be removed
     *
     * @return <code>true</code> if the widget was present
     */
    @Override
    public boolean remove( Widget pWidget ) {
        // Make sure this panel actually contains the child widget.
        if ( !mChildren.contains( pWidget ) ) {
            return false;
        }

        // Disown it.
        disown( pWidget );
        return true;
    }

    // ^^^^^^^^^^^ HasWidgets

    // vvvvvvvvvvv IndexedPanel

    @Override
    public Widget getWidget( int pIndex ) {
        return null; // todo: getChildren().get( pIndex );
    }

    @Override
    public int getWidgetCount() {
        return 0; // todo: getChildren().size();
    }

    @Override
    public int getWidgetIndex( Widget pChild ) {
        return 0; // todo: getChildren().indexOf( pChild );
    }

    @Override
    public boolean remove( int pIndex ) {
        return remove( getWidget( pIndex ) );
    }

    // ^^^^^^^^^^^ IndexedPanel

    /**
     * Sets the horizontal alignment of the last cell.
     *
     * @param hAlign a constant representing left, center or right alignment
     *
     * @see HasAlignment
     */
    public void setCellHorizontalAlignment( HorizontalAlignmentConstant hAlign ) {
//        if ( m_cellMap.size() == 0 )
//        {
//            throw new IllegalStateException();
//        }
//
//        setCellHorizontalAlignment( getCellCount() - 1, hAlign );
    }

    /**
     * Sets the vertical alignment of the last cell.
     *
     * @param vAlign a constant representing top, middle or bottom alignment
     *
     * @see HasAlignment
     */
    public void setCellVerticalAlignment( VerticalAlignmentConstant vAlign ) {
//        if ( m_cellMap.size() == 0 )
//        {
//            throw new IllegalStateException();
//        }
//
//        setCellVerticalAlignment( getCellCount() - 1, vAlign );
    }

    public static void setTdHorizontalAlignment( Element td, HorizontalAlignmentConstant hAlign ) {
        CommonElementHelper.setTDalign( td, hAlign );
    }

    public static void setTdVerticalAlignment( Element td, VerticalAlignmentConstant vAlign ) {
        CommonElementHelper.setTDvAlign( td, vAlign );
    }

    /**
     * Gets the column span for the given cell. This is the number of logical
     * columns covered by the cell.
     *
     * @param row    the cell's row
     * @param column the cell's column
     *
     * @return the cell's column span
     *
     * @throws IndexOutOfBoundsException
     */
    public int getColSpan( int row, int column ) {
        return DOM.getElementPropertyInt( getElement( row, column ), "colSpan" );
    }

    /**
     * Gets the row span for the given cell. This is the number of logical rows
     * covered by the cell.
     *
     * @param row    the cell's row
     * @param column the cell's column
     *
     * @return the cell's row span
     *
     * @throws IndexOutOfBoundsException
     */
    public int getRowSpan( int row, int column ) {
        return DOM.getElementPropertyInt( getElement( row, column ), "rowSpan" );
    }

    /**
     * Gets the TD element representing the specified cell.
     *
     * @param row    the row of the cell to be retrieved
     * @param column the column of the cell to be retrieved
     *
     * @return the column's TD element
     *
     * @throws IndexOutOfBoundsException
     */
    public Element getElement( int row, int column ) {
        checkCellBounds( row, column );
        return getCellElement( bodyElem, row, column );
    }

    /**
     * Bounds checks that the cell exists at the specified location.
     *
     * @param row    cell's row
     * @param column cell's column
     *
     * @throws IndexOutOfBoundsException
     */
    protected void checkCellBounds( int row, int column ) {
        checkRowBounds( row );
        if ( column < 0 ) {
            throw new IndexOutOfBoundsException( "Column " + column + " must be non-negative: " + column );
        }
        int cellSize = getCellCount( row );
        if ( cellSize <= column ) {
            throw new IndexOutOfBoundsException( "Column index: " + column + ", Column size: " + getCellCount( row ) );
        }
    }

    /**
     * Checks that the row is within the correct bounds.
     *
     * @param row row index to check
     *
     * @throws IndexOutOfBoundsException
     */
    protected void checkRowBounds( int row ) {
        int rowSize = getRowCount();
        if ( (row >= rowSize) || (row < 0) ) {
            throw new IndexOutOfBoundsException( "Row index: " + row + ", Row size: " + rowSize );
        }
    }

    /**
     * Gets the number of rows present in this table.
     *
     * @return the table's row count
     */
    public abstract int getRowCount();

    /**
     * Gets the number of cells in a given row.
     *
     * @param row the row whose cells are to be counted
     *
     * @return the number of cells present in the row
     */
    public abstract int getCellCount( int row );

    /**
     * Native method to get a cell's element.
     *
     * @param table the table element
     * @param row   the row of the cell
     * @param col   the column of the cell
     *
     * @return the element
     */
    private native Element getCellElement( Element table, int row, int col ) /*-{
        var out = table.rows[row].cells[col];
        return (out == null ? null : out);
    }-*/;

    @Override
    protected final Element adopt( Widget w, Element container ) {
        throw new IllegalStateException( "Inappropriate use of raw adopt( Widget w, Element container )" );
    }

    /**
     * Do everything to insert pWidget at the appropriate place
     *
     * @param pWidget !null
     */
    protected void adopt( Widget pWidget, int pBeforeIndex ) {
        if ( aboutToAdopt( pWidget, pBeforeIndex ) ) {
            LLadopt( pWidget, pBeforeIndex );
            justAdopted( pWidget, pBeforeIndex );
        }
    }

    /**
     * Do everything to remove pWidget
     *
     * @param pWidget !null
     */
    @Override
    protected Element disown( Widget pWidget ) {
        int index = mChildren.indexOf( pWidget );
        if ( index == -1 ) {
            throw new IllegalStateException( "Attempt to 'disown' widget (" + pWidget + ") not owned by: " + this );
        }
        if ( aboutToDisown( pWidget, index ) ) {
            LLdisown( pWidget, index );
            justDisowned( pWidget, index );
        }
        return null; // We Don't Care
    }

    protected void LLdisown( Widget pWidget, int pIndex ) {
        Element td = abstractSizeablePanel_disown( pWidget ); // remove Widget from td
        DOM.removeChild( getContainerElement(), unwrap( td ) );
        mChildren.remove( pIndex );
    }

    protected void LLadopt( Widget pWidget, int pBeforeIndex ) {
        pWidget.removeFromParent();
        Element td = DOM.createTD();
        abstractSizeablePanel_adopt( pWidget, td ); // put Widget in TD
        DOM.insertChild( getContainerElement(), wrap( td ), pBeforeIndex );
        mChildren.insert( pWidget, pBeforeIndex );
    }

    protected Element abstractSizeablePanel_disown( Widget pWidget ) {
        return super.disown( pWidget );
    }

    protected void abstractSizeablePanel_adopt( Widget pWidget, Element pContainer ) {
        super.adopt( pWidget, pContainer );
    }

    /**
     * Override point for special behavior of index based addition, before adding.
     * Could throw an exception!
     *
     * @return true if OK to add
     */
    @SuppressWarnings({"UnusedParameters"})
    protected boolean aboutToAdopt( Widget pWidget, int pBeforeIndex ) {
        return true;
    }

    /**
     * Override point for special behavior of index based addition.
     * Should not throw an exception!
     */
    @SuppressWarnings({"UnusedParameters"})
    protected void justAdopted( Widget pWidget, int pWidgetIndex ) {
    }

    /**
     * Override point for special behavior of index based removal, before removing.
     * Could throw an exception!
     *
     * @return true if OK to add
     */
    @SuppressWarnings({"UnusedParameters"})
    protected boolean aboutToDisown( Widget pWidget, int pBeforeIndex ) {
        return true;
    }

    /**
     * Override point for special behavior of index based removal.
     * Should not throw an exception!
     */
    @SuppressWarnings({"UnusedParameters"})
    protected void justDisowned( Widget pWidget, int pWidgetIndex ) {
    }

    abstract protected Element unwrap( Element pTD );

    abstract protected Element wrap( Element pTD );
}