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

import org.litesoft.commonfoundation.html.*;

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

/**
 * A basic cell renderer. By default, the model element for the cell is
 * converted to a String via {@link String#valueOf(Object)} and written to the
 * cell. The default conversion can be overriden by setting a custom formatter.
 * <p/>
 * see #setFormatter(StringFormatter)
 */
public class TableCellRenderer<T> implements CellRenderer<T, Object>
{
    public enum EscapeCtrl
    {
        NoWrap( HTMLize.INSTANCE_NO_WRAP ), //
        NoEscape( HTMLize.INSTANCE_NO_ESCAPE ), //
        Regular( HTMLize.INSTANCE );

        private HTMLize mHTMLizer;

        EscapeCtrl( HTMLize pHTMLizer )
        {
            mHTMLizer = pHTMLizer;
        }

        public String process( String pText )
        {
            return mHTMLizer.process( pText );
        }
    }

    public static class Builder
    {
        private String mElementStyleName;
        private StringFormatter mFormatter;
        private EscapeCtrl mEscapeCtrl = EscapeCtrl.NoWrap;

        public String getElementBaseStyleName()
        {
            return (mElementStyleName != null) ? mElementStyleName : "";
        }

        public Builder setElementBaseStyleName( String pStyleName )
        {
            mElementStyleName = pStyleName;
            return this;
        }

        public StringFormatter getFormatter()
        {
            return (mFormatter != null) ? mFormatter : StringFormatterDefault.INSTANCE;
        }

        public Builder setFormatter( StringFormatter pFormatter )
        {
            if ( pFormatter == null )
            {
                throw new NullPointerException();
            }

            mFormatter = pFormatter;
            return this;
        }

        public EscapeCtrl getEscapeCtrl()
        {
            return (mEscapeCtrl != null) ? mEscapeCtrl : EscapeCtrl.NoWrap;
        }

        /**
         * Instructs the renderer to escape HTML markup in values to be rendered.
         * Default is <code>NoWrap</code>. Specifying <code>NoEscape</code> will enable
         * HTML script injection if the data being rendererd is not from a trusted
         * source.
         *
         * @param pEscapeCtrl <code>NoEscape</code> to allow HTML markup to be rendered in
         *                    cells
         *                    <p/>
         *                    see #escapeMarkup(String)
         */
        public Builder setEscapeCtrl( EscapeCtrl pEscapeCtrl )
        {
            mEscapeCtrl = pEscapeCtrl;
            return this;
        }
    }

    public static Builder NO_WRAP = new Builder().setEscapeCtrl( EscapeCtrl.NoWrap );
    public static Builder NO_ESCAPE = new Builder().setEscapeCtrl( EscapeCtrl.NoEscape );

    private String mElementStyleName;
    private StringFormatter mFormatter;
    private EscapeCtrl mEscapeCtrl;

    public TableCellRenderer( Builder pBuilder )
    {
        if ( pBuilder == null )
        {
            pBuilder = NO_WRAP;
        }
        mElementStyleName = pBuilder.getElementBaseStyleName();
        mFormatter = pBuilder.getFormatter();
        mEscapeCtrl = pBuilder.getEscapeCtrl();
    }

    public TableCellRenderer()
    {
        this( null );
    }

    @Override
    public void renderRowValue( T pRowValue, ColumnDefinition<T, Object> pColumnDef, AbstractCellView<T> pView )
    {
        Object cellValue = pColumnDef.getCellValue( pRowValue );
        prepareElement( pRowValue, pColumnDef, pView, cellValue );
        renderContent( pRowValue, pColumnDef, pView, cellValue );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public void prepareElement( T rowValue, ColumnDefinition<T, Object> pColumnDef, AbstractCellView<T> pView, Object pCellValue )
    {
        // set cell class name(s)
        StringBuilder styleName = new StringBuilder();
        buildStyleName( styleName, pCellValue );
        pView.setStyleName( styleName.toString() );

        // align has a special setter b/c css "text-align" does not work for block context
        pView.setHorizontalAlignment( pColumnDef.getColumnProperty( HorizontalAlignmentProperty.TYPE ).getValue() );

        pView.setVerticalAlignment( pColumnDef.getColumnProperty( VerticalAlignmentProperty.TYPE ).getValue() );

        // set cell CSS properties
        pView.setStyleAttribute( "paddingLeft", pColumnDef.getColumnProperty( PaddingProperty.LEFT ).getValue() + "px" );
        pView.setStyleAttribute( "paddingRight", pColumnDef.getColumnProperty( PaddingProperty.RIGHT ).getValue() + "px" );
        pView.setStyleAttribute( "paddingTop", pColumnDef.getColumnProperty( PaddingProperty.TOP ).getValue() + "px" );
        pView.setStyleAttribute( "paddingBottom", pColumnDef.getColumnProperty( PaddingProperty.BOTTOM ).getValue() + "px" );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    protected StringBuilder buildStyleName( StringBuilder result, Object pCellValue )
    {
        result.append( mElementStyleName );
        return result;
    }

    protected StringBuilder appendDependantStyle( StringBuilder styleIn, String dependentStyleName )
    {
        return appendDependantStyle( styleIn, dependentStyleName, true );
    }

    protected StringBuilder appendDependantStyle( StringBuilder styleIn, String dependentStyleName, boolean add )
    {
        if ( add )
        {
            styleIn.append( ' ' );
            styleIn.append( mElementStyleName );
            styleIn.append( '-' );
            styleIn.append( dependentStyleName );
        }
        return styleIn;
    }

    public void renderContent( T pRowValue, ColumnDefinition<T, Object> pColumnDef, AbstractCellView<T> pView, Object pCellValue )
    {
        if ( pCellValue instanceof Widget )
        {
            Widget widget = (Widget) pCellValue;
            Element element = widget.getElement();
            HorizontalAlignmentConstant align = pColumnDef.getColumnProperty( HorizontalAlignmentProperty.TYPE ).getValue();
            pView.setHorizontalAlignment( align );
            if ( element.getTagName().equalsIgnoreCase( "table" ) )
            {
                DOM.setElementAttribute( element, "cellpadding", "0" );
                DOM.setElementAttribute( element, "cellspacing", "0" );
            }
            pView.setWidget( widget );
        }
        else
        {
            String valueString = getValueString( pCellValue );
            String safeValueString = mEscapeCtrl.process( valueString );
            String nonEmptyValueString = ("".equals( safeValueString )) ? HTMLConstants.NBSP : safeValueString;
            String cellString = getCellString( pRowValue, nonEmptyValueString, pCellValue );
            pView.setHTML( cellString );
        }
    }

    /**
     * Calls the formatter.
     *
     * @return an HTML snippet representing <code>modelElement</code>
     */
    protected String getValueString( Object modelElement )
    {
        return mFormatter.getString( modelElement );
    }

    /**
     * Template method for decorating text returned by the formatter.
     * Implementors can use this method to create complex cells.
     * <p/>
     * This implementation simply returns the input string.
     *
     * @param pRowValue
     * @param pValueString the string provided by the formatter
     *
     * @return an HTML snippet describing the entire content of the cell
     */
    protected String getCellString( T pRowValue, String pValueString, Object pCellValue )
    {
        return pValueString;
    }
}