package org.litesoft.GWT.client.widgets.datatables;

import java.util.*;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.event.*;
import org.litesoft.GWT.client.widgets.datatables.RowSelectionPolicy.*;
import org.litesoft.core.*;
import org.litesoft.core.util.*;

import com.google.gwt.dom.client.*;
import com.google.gwt.dom.client.Element;
import com.google.gwt.event.dom.client.*;
import com.google.gwt.event.logical.shared.*;
import com.google.gwt.event.shared.*;
import com.google.gwt.gen2.table.client.AbstractScrollTable.*;
import com.google.gwt.gen2.table.client.*;
import com.google.gwt.gen2.table.client.SelectionGrid.*;
import com.google.gwt.gen2.table.client.property.*;
import com.google.gwt.gen2.table.event.client.*;
import com.google.gwt.gen2.table.override.client.FlexTable.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.user.client.ui.HasHorizontalAlignment.*;
import com.google.gwt.widgetideas.client.*;

public class Table<RowType> extends Composite implements HasSelectionHandlers<RowType>
{
    private final FixedWidthFlexTable mHeaderTable = new FixedWidthFlexTable();
    private final DataTable mDataTable = new DataTable();
    private final TableImpl<RowType> mTable;
    private final TableClickCommand<RowType> mRowClickCommand;

    protected SelectAllCheckBox mSelectAllCheckBox = null;

    private RowSelectionPolicy mSelectionPolicy = RowSelectionPolicy.MULTI; // important: initialized to match PagingScrollingTable's default value

    public Table( ListTableModel<RowType> pTableModel, TableDefinitionPlus<RowType> pTableDefinition, TableClickCommand<RowType> pRowClickCommand )
    {
        mRowClickCommand = pRowClickCommand;
        FlexCellFormatter headerCellFormatter = mHeaderTable.getFlexCellFormatter();
        final List<ColumnDefinition<RowType, ?>> colDefs = pTableDefinition.getVisibleColumnDefinitions();
        int colCount = colDefs.size();
        mDataTable.resizeColumns( colCount );
        for ( int col = 0; col < colCount; col++ )
        {
            ColumnDefinition<RowType, ?> colDef = colDefs.get( col );
            mHeaderTable.setHTML( 0, col, (String) colDef.getColumnProperty( HeaderProperty.TYPE ).getHeader( 0 ) );
            Style style = headerCellFormatter.getElement( 0, col ).getStyle();
            HorizontalAlignmentConstant alignment = colDef.getColumnProperty( HorizontalAlignmentProperty.TYPE ).getValue();
            headerCellFormatter.setHorizontalAlignment( 0, col, alignment );
            style.setPropertyPx( "paddingLeft", colDef.getColumnProperty( PaddingProperty.LEFT ).getValue() );
            style.setPropertyPx( "paddingRight", colDef.getColumnProperty( PaddingProperty.RIGHT ).getValue() );
            style.setPropertyPx( "paddingTop", colDef.getColumnProperty( PaddingProperty.TOP ).getValue() );
            style.setPropertyPx( "paddingBottom", colDef.getColumnProperty( PaddingProperty.BOTTOM ).getValue() );
            String colStyleName = colDef.getColumnProperty( ColStyleNameProperty.TYPE ).getValue();
            if ( colStyleName != null )
            {
                mHeaderTable.getColumnFormatter().addStyleName( col, colStyleName );
                mDataTable.getColumnFormatter().addStyleName( col, colStyleName );
            }
        }
        mTable = new TableImpl<RowType>( pTableModel, mDataTable, mHeaderTable, pTableDefinition );
        mTable.setPageSize( 5 );
        mTable.setResizePolicy( ResizePolicy.FILL_WIDTH );
        mTable.setSortPolicy( SortPolicy.DISABLED );
        setSelectionPolicy( RowSelectionPolicy.SINGLE );
        if ( mRowClickCommand != null )
        {
            setClickCommand( pRowClickCommand );
        }
        final TableHelper.GridHelper gridHelper = new TableHelper.GridHelper( mDataTable )
        {
            @Override
            protected int getRowIndex( com.google.gwt.user.client.Element pRowElement )
            {
                return mDataTable.getRowIndex( pRowElement );
            }
            
            @Override
            protected int getCellIndex(com.google.gwt.user.client.Element pRowElement, com.google.gwt.user.client.Element pCellElement)
            {
                return mDataTable.getCellIndex(pRowElement, pCellElement);
            }
        };
        mDataTable.addClickHandler( new TableHelper.GridClickHandler<RowType>( 0, gridHelper, colDefs )
        {
            @Override
            public void onClick(ClickEvent pEvent)
            {
                super.onClick(pEvent);
                boolean checkBox = mSelectionPolicy == RowSelectionPolicy.CHECKBOX;
                boolean radio = mSelectionPolicy == RowSelectionPolicy.RADIO;
                if (checkBox || radio)
                {
                    TableHelper.Cell cell = gridHelper.getCellForEvent(Event.as(pEvent.getNativeEvent()));
                    if (cell != null)
                    {
                        /*
                         * ctrlKey = false for RADIO to workaround table bug
                         * where deselection of old row does not update UI
                         */
                        boolean ctrlKey = !radio;
                        mDataTable.selectRow(cell.getRow(), ctrlKey, false);
                    }
                }
            }
            
            @Override
            protected RowType getRowValue( int pRow )
            {
                return mTable.getRowValue( pRow );
            }
        } );
        initWidget( mTable );
    }

    public TableModel<RowType> getModel()
    {
        return mTable.getTableModel();
    }

    public ImmutableArrayList<RowType> getAllRows()
    {
        return new ImmutableArrayList<RowType>( mTable.getRowValues() );
    }

    public void selectAll()
    {
        mTable.getDataTable().selectAllRows();
    }

    public void deselectAll()
    {
        mTable.getDataTable().deselectAllRows();
    }

    /**
     * @return true if pPossibleRowValue is in the table (and is now selected)
     */
    public boolean selectRow( RowType pPossibleRowValue )
    {
        return mTable.selectRow( pPossibleRowValue );
    }

    public RowSelectionPolicy getSelectionPolicy()
    {
        return mSelectionPolicy;
    }

    public Set<RowType> getSelectedValues()
    {
        return mTable.getSelectedRowValues();
    }

    public void setSelectionPolicy( RowSelectionPolicy pSelectionPolicy )
    {
        if (mSelectionPolicy != pSelectionPolicy)
        {
            mSelectionPolicy = pSelectionPolicy;
            SelectionPolicy oldSelectionPolicy = mDataTable.getSelectionPolicy();
            SelectionPolicy newSelectionPolicy = pSelectionPolicy.getSelectionPolicy();
            boolean hasSelectionColumn = oldSelectionPolicy == SelectionPolicy.CHECKBOX || oldSelectionPolicy == SelectionPolicy.RADIO;
            boolean needsSelectionColumn = newSelectionPolicy == SelectionPolicy.CHECKBOX || newSelectionPolicy == SelectionPolicy.RADIO;
    
            if ( oldSelectionPolicy == newSelectionPolicy && !hasSelectionColumn )
            {
                return;
            }
    
            mDataTable.setSelectionEnabled( pSelectionPolicy.isSelectionEnabled() );
            mDataTable.setSelectionPolicy( (newSelectionPolicy != null) ? newSelectionPolicy : SelectionPolicy.ONE_ROW );
            if ( hasSelectionColumn && !needsSelectionColumn )
            {
                mHeaderTable.removeCell( 0, 0 );
                Element colGroup = mHeaderTable.getElement().getFirstChildElement();
                colGroup.removeChild( colGroup.getFirstChildElement() );
            }
            else if ( needsSelectionColumn && !hasSelectionColumn )
            {
                Element colGroup = mHeaderTable.getElement().getFirstChildElement();
                colGroup.insertBefore( Document.get().createColElement(), colGroup.getFirstChildElement() );
                mHeaderTable.insertCell( 0, 0 );
                mHeaderTable.getCellFormatter().getElement(0, 0).getStyle().setProperty("textAlign", HasHorizontalAlignment.ALIGN_CENTER.getTextAlignString());
                mHeaderTable.setColumnWidth( 0, mDataTable.getInputColumnWidth() );
            }
            if ( needsSelectionColumn )
            {
                // can be called if hasSelectionColumn=true but the label has changed
                Widget colLabel = ((RowSelectionPolicy.Column) pSelectionPolicy).getColLabel();

                /*
                 * If no selection col label is specified, set a "select all"
                 * checkbox in the header.
                 */
                if (colLabel == null && pSelectionPolicy.getType() == Type.CheckBox)
                {
                    colLabel = mSelectAllCheckBox = new SelectAllCheckBox();
                }
                mHeaderTable.setWidget( 0, 0, colLabel );
            }
        }
    }

    /**
     * Note: currently only notifies w/ selected item w/ the lowest index. If we
     * need multiple items we can roll a custom event or create a method to get
     * selected items on this class.
     */
    public HandlerRegistration addSelectionHandler( SelectionHandler<RowType> pHandler )
    {
        return new IncubatorHandlerRegistrationAdaptor2( addHandler( pHandler, SelectionEvent.getType() ), mDataTable.addRowSelectionHandler( new RowSelectionHandler()
        {
            public void onRowSelection( RowSelectionEvent pEvent )
            {
                Set<Integer> selectionSet = mDataTable.getSelectedRows();
                RowType selection;
                if ( selectionSet.size() > 0 )
                {
                    int selectedIndex = selectionSet.iterator().next();
                    selection = mTable.getRowValue( selectedIndex );
                }
                else
                {
                    selection = null;
                }
                SelectionEvent.fire( Table.this, selection );
            }
        } ) );
    }
    
    public boolean isScrollVertically()
    {
        return mTable.isScrollVertically();
    }

    /**
     * Must be set before loading data to ensure that fetched rows do not
     * increase viewport size. Default is true.
     * 
     * @throws IllegalStateException if called after {@link #loadData()}
     */
    public void setScrollVertically(boolean pScrollVertically)
    {
        mTable.setScrollVertically(pScrollVertically);
    }
    
    public TableRowCountCallback getRowCountCallback()
    {
        return mTable.getRowCountCallback();
    }
    
    public void setRowCountCallback(TableRowCountCallback pRowCountCallback)
    {
        mTable.setRowCountCallback(pRowCountCallback);
    }

    public boolean isHeaderVisible()
    {
        return mHeaderTable.isVisible();
    }

    public void setHeaderVisible( boolean pVisible )
    {
        mHeaderTable.setVisible( pVisible );
    }

    public Widget getEmptyTableWidget()
    {
        return mTable.getEmptyTableWidget();
    }

    public void setEmptyTableWidget( Widget pEmptyTableWidget )
    {
        mTable.setEmptyTableWidget( pEmptyTableWidget );
    }

    public void loadData()
    {
        mTable.loadPage();
    }

    @SuppressWarnings({"deprecation"})
    private void setClickCommand( TableClickCommand<RowType> pClickCommand )
    {
        mDataTable.addTableListener( new com.google.gwt.user.client.ui.TableListener()
        {
            public void onCellClicked( com.google.gwt.user.client.ui.SourcesTableEvents pSender, int pRow, int pCol )
            {
                mRowClickCommand.execute( ((ListTableModel<RowType>) mTable.getTableModel()).get( pRow ) );
            }
        } );
    }
    
    public void simulateUserClickHeader(int pCol, KeyboardKeyModifier pModifiers)
    {
        pModifiers = KeyboardKeyModifier.deNull(pModifiers);
        NativeEvent event = Document.get().createClickEvent(0, 0, 0, 0, 0, pModifiers.isCtrl(), pModifiers.isAlt(), pModifiers.isShift(), pModifiers.isMeta());
        com.google.gwt.user.client.Element zElement = mHeaderTable.getCellFormatter().getElement( 0, pCol );
        zElement.dispatchEvent(event);
    }
    
    public void simulateUserClickDataGrid(int pRow, int pCol, KeyboardKeyModifier pModifiers)
    {
        pModifiers = KeyboardKeyModifier.deNull(pModifiers);
        NativeEvent event = Document.get().createClickEvent(0, 0, 0, 0, 0, pModifiers.isCtrl(), pModifiers.isAlt(), pModifiers.isShift(), pModifiers.isMeta());
        com.google.gwt.user.client.Element zElement = mDataTable.getCellFormatter().getElement( pRow, pCol );
        zElement.dispatchEvent(event);
    }

    private static class TableImpl<RowType> extends PagingScrollTable<RowType>
    {
        private boolean mScrollVertically = true; // important: initialized to match PagingScrollingTable's default value
        private TableRowCountCallback mRowCountCallback = null;
        private TableRowElement mGridRow;
        private int mRowCount = 0;
        private int mMaxVisibleRows = 0;
        private boolean mFetchDataWaitingForSize = false;
        private int mViewportHeight = 0;
        private int mPrototypeRowHeight = 0;
        private boolean mLoadPageCalled = false;
        
        public TableImpl( TableModel<RowType> pTableModel, FixedWidthGrid pDataTable, FixedWidthFlexTable pHeaderTable, TableDefinitionPlus<RowType> pTableDefinition )
        {
            super( pTableModel, pDataTable, pHeaderTable, pTableDefinition );
            if ( BrowserFamily.IE.equals( UserAgent.getInstance().getFamily() ) )
            {
                /*
                 * Hack the header spacer so it does not prevent interaction w/ the column resize handles in IE (Issue 66).
                 * 
                 * DOM structure of table for reference: 
                 * mainElem:div > absoluteElem:div > headerWrapper:div [> headerSpacer:div, IE only]
                 *                                                     > headerTable:table
                 * 
                 * http://code.google.com/p/google-web-toolkit-incubator/issues/detail?id=313
                 */
                Element headerWrapper = pHeaderTable.getElement().getParentElement();
                Element headerSpacer = headerWrapper.getFirstChildElement();
                headerSpacer.getStyle().setProperty( "visibility", "hidden" );
                // Almost fixes, but 1px div still gets in the way. IE will not honor 0px.  
                // headerSpacer.getStyle().setProperty("overflow", "hidden");
            }
            setCellPadding( 0 );
            setCellSpacing( 0 );
            setHeight( "200px" );
            MockTable.CreateResult mockTableResult = MockTable.createFrom( this, pTableDefinition );
            mGridRow = mockTableResult.mPrototypeRow;
            getElement().insertBefore( mockTableResult.mTable, getElement().getFirstChild() );
            
            ResizableWidgetCollection.get().add(new ResizableWidgetAdaptor(this, getDataWrapper())
            {
                @Override
                public void onResize(int pViewportWidth, int pViewportHeight)
                {
                    mViewportHeight = pViewportHeight;
                    updateMaxVisibleRows();
                }
            });
            
            ResizableWidgetCollection.get().add(new TemporaryResizableWidgetAdaptor(this, mGridRow.<com.google.gwt.user.client.Element>cast())
            {
                @Override
                protected void onSizeInitialized(int pRowWidth, int pRowHeight)
                {
                    mPrototypeRowHeight = pRowHeight;
                    updateMaxVisibleRows();
                }
            });
        }
        
        public boolean isScrollVertically()
        {
            return mScrollVertically;
        }

        /**
         * Must be set before loading data to ensure that fetched rows do not
         * increase viewport size. Default is true.
         * 
         * @throws IllegalStateException if called after {@link #loadData()}
         */
        public void setScrollVertically(boolean pScrollVertically)
        {
            if (mLoadPageCalled)
                throw new IllegalStateException("Table: must call set setScrollVertically() before loadData()");
            
            mScrollVertically = pScrollVertically;
        }
        
        @Override
        public void setScrollPolicy(ScrollPolicy pScrollPolicy)
        {
            throw new UnsupportedOperationException();
        }
        
        public void loadPage()
        {
            mLoadPageCalled = true;
            if (isSizeInitialized())
            {
                gotoPage(0, true);
            }
            else
            {
                mFetchDataWaitingForSize = true;
            }
        }
        
        public TableRowCountCallback getRowCountCallback()
        {
            return mRowCountCallback;
        }
        
        public void setRowCountCallback(TableRowCountCallback pRowCountCallback)
        {
            mRowCountCallback = pRowCountCallback;
        }

        /**
         * @return true if pPossibleRowValue is in the table (and is now selected)
         */
        public boolean selectRow( RowType pPossibleRowValue )
        {
            if ( pPossibleRowValue != null )
            {
                List<RowType> zRows = getRowValues();
                for ( int i = 0; i < zRows.size(); i++ )
                {
                    if ( pPossibleRowValue.equals( zRows.get( i ) ) )
                    {
                        getDataTable().selectRow( i, false ); // todo: Do we need to do some kind of page adjustment?
                    }
                }
            }
            return false;
        }

        /**
         * Override to gain access
         */
        @Override
        protected List<RowType> getRowValues()
        {
            return super.getRowValues();
        }

        /**
         * Override to gain access
         */
        @Override
        protected void setEmptyTableWidgetVisible( boolean pVisible )
        {
            super.setEmptyTableWidgetVisible( pVisible );
        }

        /**
         * Called by superclass after {@link TableModel} calls callback w/ data.
         */
        @Override
        protected void setData(int pFirstRow, Iterator<RowType> pRows)
        {
            super.setData(pFirstRow, (mScrollVertically) ? pRows : new LimitingIteratorWrapper<RowType>(pRows, mMaxVisibleRows));
            int rowCount = getTableModel().getRowCount();
            if (mRowCount != rowCount)
            {
                mRowCount = rowCount;
                fireRowCountChanged();
            }
        }
        
        @Override
        public void onResize(int pTableWidth, int pTableHeight)
        {
            super.onResize(pTableWidth, pTableHeight);
            updateMaxVisibleRows();
        }
        
        private boolean isSizeInitialized()
        {
            return mViewportHeight > 0 && mPrototypeRowHeight > 0;
        }
        
        private void updateMaxVisibleRows()
        {
            if (isSizeInitialized())
            {
                /*
                 * Require a minimum of 1 row. Otherwise outer element
                 * (AbstractScrollTable.absoluteElem) can get stuck at header
                 * size and will not expand to show rows when more space becomes
                 * available.
                 */
                int maxVisibleRows = Math.max(1, mViewportHeight / mPrototypeRowHeight);
                if (mMaxVisibleRows != maxVisibleRows)
                {
                    mMaxVisibleRows = maxVisibleRows;
                    setPageSize(mMaxVisibleRows);
                    if (mFetchDataWaitingForSize)
                    {
                        mFetchDataWaitingForSize = false;
                        super.gotoFirstPage();
                    }
                    else
                    {
                        fireRowCountChanged();
                    }
                }
            }
        }

        private void fireRowCountChanged()
        {
            if (mRowCountCallback != null)
            {
                int visibleRows = Math.min(mRowCount, mMaxVisibleRows);
                mRowCountCallback.rowCountChanged(visibleRows, mRowCount, mMaxVisibleRows);
            }
        }
    }

    private static class DataTable extends FixedWidthGrid
    {
        public HandlerRegistration addClickHandler( ClickHandler pHandler )
        {
            return addDomHandler( pHandler, ClickEvent.getType() );
        }

        /**
         * Override to gain access
         */
        @Override
        protected int getInputColumnWidth()
        {
            return super.getInputColumnWidth();
        }

        /**
         * Override to gain access
         */
        @Override
        protected int getRowIndex( com.google.gwt.user.client.Element pRowElem )
        {
            return super.getRowIndex( pRowElem );
        }
        
        /**
         * Override to gain access
         */
        @Override
        protected int getCellIndex(com.google.gwt.user.client.Element pRowElem, com.google.gwt.user.client.Element pCellElem)
        {
            return super.getCellIndex(pRowElem, pCellElem);
        }
        
        @Override
        public void onBrowserEvent( Event pEvent )
        {
            if ( pEvent.getTypeInt() == Event.ONCLICK )
            {
                // the current incubator HTMLTable does not call super()
                DomEvent.fireNativeEvent( pEvent, this, getElement() );
            }
            super.onBrowserEvent( pEvent );
        }
    }
    
    public class SelectAllCheckBox extends CheckBox
    {
        private HandlerRegistration mSelectionHandlerRegistration;
        
        public SelectAllCheckBox()
        {
            addValueChangeHandler(new ValueChangeHandler<Boolean>()
            {
                public void onValueChange(ValueChangeEvent<Boolean> pEvent)
                {
                    if (pEvent.getValue())
                    {
                        selectAll();
                    }
                    else
                    {
                        deselectAll();
                    }
                }
            });
            update();
        }
        
        public void update()
        {
            int selectionCount = getSelectedValues().size();
            setValue(selectionCount > 0 && getSelectedValues().size() == getModel().getRowCount());
        }
        
        @Override
        protected void onLoad()
        {
            super.onLoad();
            mSelectionHandlerRegistration = addSelectionHandler(new SelectionHandler<RowType>()
            {
                public void onSelection(SelectionEvent<RowType> pEvent)
                {
                    update();
                }
            });
        }
        
        @Override
        protected void onUnload()
        {
            mSelectionHandlerRegistration.removeHandler();
        }
    }
}