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

import java.util.*;

import org.litesoft.GWT.client.widgets.nonpublic.*;

import com.google.gwt.dom.client.*;
import com.google.gwt.gen2.table.client.*;
import com.google.gwt.gen2.table.client.TableDefinition.*;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.user.client.ui.HasHorizontalAlignment.*;
import com.google.gwt.user.client.ui.HasVerticalAlignment.*;

class MockTable
{
    /**
     * This element is inserted as a child of the table's outer wrapper behind
     * the actual table elements. It reserves space for the header and at least
     * 1 row.
     */
    public static <RowType> MockTable.CreateResult createFrom( PagingScrollTable<RowType> pTable, TableDefinitionPlus<RowType> pTableDefinition )
    {
        // create a mock table so that we can measure its dimensions
        DivElement outer = Document.get().createDivElement();
        DivElement headerWrapper = Document.get().createDivElement();
        DivElement dataWrapper = Document.get().createDivElement();
        Node mockHeader = pTable.getHeaderTable().getElement().cloneNode( true );
        TableElement mockGrid = TableElement.as( pTable.getDataTable().getElement().cloneNode( true ).<Element>cast() );
        TableSectionElement gridBody = mockGrid.getTBodies().getItem( 0 );
        TableRowElement gridRow = Document.get().createTRElement(); // item 0 is the "ghost row"
        
        RowType rowValue = pTableDefinition.getPrototypeRowValue();
        if (rowValue != null)
        {
            renderPrototypeRow(pTableDefinition, rowValue, gridRow);
        }
        else
        {
            // render stub row
            int maxPaddingTop = 0;
            int maxPaddingBottom = 0;
            List<ColumnDefinition<RowType, ?>> colDefs = pTableDefinition.getVisibleColumnDefinitions();
            for (ColumnDefinition<RowType, ?> colDef : colDefs)
            {
                int paddingTop = colDef.getColumnProperty( PaddingProperty.TOP ).getValue();
                int paddingBottom = colDef.getColumnProperty( PaddingProperty.BOTTOM ).getValue();
                maxPaddingTop = Math.max(paddingTop, maxPaddingTop);
                maxPaddingBottom = Math.max(paddingBottom, maxPaddingBottom);
            }
            TableCellElement td = Document.get().createTDElement();
            td.setInnerHTML( "&nbsp;" );
            td.getStyle().setPropertyPx("paddingTop", maxPaddingTop);
            td.getStyle().setPropertyPx("paddingBottom", maxPaddingBottom);
            gridRow.appendChild( td );
        }
        gridBody.appendChild( gridRow );
        headerWrapper.appendChild( mockHeader );
        dataWrapper.appendChild( mockGrid );
        outer.appendChild( headerWrapper );
        outer.appendChild( dataWrapper );
        CommonElementHelper.hide( outer );
        return new CreateResult(outer, gridRow);
    }
    
    /**
     * Render full row w/ prototype values
     */
    public static <RowType> void renderPrototypeRow(TableDefinition<RowType> pTableDefinition, RowType pValue, Element pTr)
    {
        for (Node child; (child = pTr.getFirstChild()) != null; )
        {
            pTr.removeChild(child);
        }
        
        List<ColumnDefinition<RowType, ?>> colDefs = pTableDefinition.getVisibleColumnDefinitions();
        PrototypeTableCellView<RowType> view = new PrototypeTableCellView<RowType>();
        for (ColumnDefinition<RowType, ?> colDef : colDefs)
        {
            TableCellElement td = Document.get().createTDElement();
            view.setTd(td);
            CellRenderer cellRenderer = colDef.getCellRenderer();
            cellRenderer.renderRowValue(pValue, colDef, view);
            pTr.appendChild( td );
        }
    }
    
    private static class PrototypeTableCellView<RowType> extends AbstractCellView<RowType>
    {
        private TableCellElement mTd;
        
        public PrototypeTableCellView()
        {
            super(null);
        }
        
        public void setTd(TableCellElement pTd)
        {
            mTd = pTd;
        }

        @Override
        public void setHTML(String pHtml)
        {
            mTd.setInnerHTML(pHtml);
        }

        @Override
        public void setHorizontalAlignment(HorizontalAlignmentConstant pAlign)
        {
            mTd.setAlign(pAlign.getTextAlignString());
        }

        @Override
        public void setStyleAttribute(String pAttr, String pValue)
        {
            mTd.getStyle().setProperty(pAttr, pValue);
        }

        @Override
        public void setStyleName(String pStylename)
        {
            mTd.setPropertyString("className", pStylename);
        }

        @Override
        public void setText(String pText)
        {
            mTd.setInnerText(pText);
        }

        @Override
        public void setVerticalAlignment(VerticalAlignmentConstant pAlign)
        {
            mTd.setVAlign(pAlign.getVerticalAlignString());
        }

        @Override
        public void setWidget(Widget pWidget)
        {
            mTd.appendChild(pWidget.getElement());
        }
    }
    
    public static class CreateResult
    {
        public final Element mTable;
        public final TableRowElement mPrototypeRow;
        
        public CreateResult(Element pTable, TableRowElement pPrototypeRow)
        {
            mTable = pTable;
            mPrototypeRow = pPrototypeRow;
        }
    }
}