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

import org.litesoft.GWT.client.widgets.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.ui.*;

import com.google.gwt.dom.client.Element;
import com.google.gwt.event.shared.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

import java.util.*;

public abstract class AbstractCellButton extends AbstractCssBackedButton {
    private static final String IMAGES_PATH = "common/images/";

    private static final String CACHED_GIF = ".gif";

    private static final String IMAGE_BUTTONS_FOLDER = "ImageButton/";
    private static final String IMAGE_BUTTON_ENABLED_GIF = "/Enabled" + CACHED_GIF;
    private static final String IMAGE_BUTTON_DISABLED_GIF = "/Disabled" + CACHED_GIF;

    private static final Set<String> sImageButtons = new HashSet<String>();
    private static final Set<String> sBackImages = new HashSet<String>();
    private static final Set<String> sForwardImages = new HashSet<String>();
    private static final Set<String> sBGCellImages = new HashSet<String>();

    protected static void prefetchImageButtonImages( String pButtonImageRef ) {
        if ( needsFetching( sImageButtons, pButtonImageRef ) ) {
            prefetchImage( buildImageButtonImageURL( pButtonImageRef, true ) );
            prefetchImage( buildImageButtonImageURL( pButtonImageRef, false ) );
        }
    }

    private static void prefetchBackImages( String pType ) {
        if ( needsFetching( sBackImages, pType ) ) {
            prefetchTypedImage( pType, "BackArrow" );
        }
    }

    private static void prefetchForwardImages( String pType ) {
        if ( needsFetching( sForwardImages, pType ) ) {
            prefetchTypedImage( pType, "ForwardArrowRegular" );
            prefetchTypedImage( pType, "ForwardArrowOver" );
        }
    }

    private static void prefetchBackgroupCellImages( String pType ) {
        if ( needsFetching( sBGCellImages, pType ) ) {
            for ( CompassPoint zPoint : CompassPoint.values() ) {
                if ( CompassPoint.center != zPoint ) {
                    for ( State zState : ALL_STATES ) {
                        prefetchTypedImage( pType, zState + "/" + zPoint.name() );
                    }
                }
            }
        }
    }

    private static void prefetchTypedImage( String pType, String pWhat ) {
        prefetchImage( IMAGES_PATH + pType + "/" + pWhat + CACHED_GIF );
    }

    private static void prefetchImage( String pImagePath ) {
        Image.prefetch( pImagePath );
    }

    private static boolean needsFetching( Set<String> pFetched, String pKey ) {
        if ( pFetched.contains( pKey ) ) {
            return false;
        }
        pFetched.add( pKey );
        return true;
    }

    protected static String buildImageButtonImageURL( String pButtonImageRef, boolean pEnabled ) {
        return IMAGES_PATH + IMAGE_BUTTONS_FOLDER + pButtonImageRef + (pEnabled ? IMAGE_BUTTON_ENABLED_GIF : IMAGE_BUTTON_DISABLED_GIF);
    }

    private int mMinimumCellSize;
    protected String mTbodyClass;
    protected Element mInnerElement, mTD;

    public AbstractCellButton( int pPreImageWidth, DefButtonNamedTypedFactory pDefButtonFactory, int pPostImageWidth, String pSizeSuffix, //
                               int pMinimumCellSize, Element pInnerElement ) {
        super( pDefButtonFactory.getName(), //
               createTableWrapper( pPreImageWidth, pInnerElement, pPostImageWidth, pMinimumCellSize, //
                                   pDefButtonFactory.getType(), // pTbodyClass
                                   pDefButtonFactory.getName(), // pTbodyClass
                                   pDefButtonFactory.getCustomStyle() ), // pTbodyClass
               pDefButtonFactory.getEnabledToolTip(), pDefButtonFactory.getDisabledToolTip() );
        mMinimumCellSize = pMinimumCellSize;
        String zType = mTbodyClass = pDefButtonFactory.getType();
        mInnerElement = pInnerElement;
        mTD = mInnerElement.getParentElement();
        mTD.setPropertyString( "align", HasHorizontalAlignment.ALIGN_CENTER.getTextAlignString() );
        mTD.setPropertyString( "verticalAlign", HasVerticalAlignment.ALIGN_MIDDLE.getVerticalAlignString() );
        addStyleName( "CellButton" );
        addStyleName( pDefButtonFactory.getSize() + pSizeSuffix + "CellButton" + pMinimumCellSize );

        if ( pPreImageWidth != 0 ) {
            prefetchBackImages( zType );
        }
        if ( pPostImageWidth != 0 ) {
            prefetchForwardImages( zType );
        }
        prefetchBackgroupCellImages( zType );
    }

    @Override
    public void fireEvent( GwtEvent<?> event ) {
        if ( isEnabled() ) {
            super.fireEvent( event );
        }
    }

    private static Element createTable() {
        return CommonElementHelper.createTable();
    }

    private static Element createTBody( String... pTbodyClasses ) {
        Element zTBody = DOM.createTBody();
        if ( Currently.isNotNullOrEmpty( pTbodyClasses ) ) {
            String zClasses = "";
            for ( String zClass : pTbodyClasses ) {
                zClasses = (zClasses + " " + ConstrainTo.notNull( zClass )).trim();
            }
            if ( zClasses.length() != 0 ) {
                zTBody.setClassName( zClasses );
            }
        }
        return zTBody;
    }

    private static Element createTR() {
        return DOM.createTR();
    }

    private static Element createTD( CompassPoint pPoint ) {
        Element zTD = DOM.createTD();
        zTD.setClassName( "CP_" + pPoint );
        return zTD;
    }

    private static CtrlElements createTableWrapper( int pPreImageWidth, Element pInnerElement, int pPostImageWidth, int pMinimumCellSize,
                                                    String... pTbodyClasses ) {
        Element zWidthImg = null;
        Element zHeightImg = null;
        Element[][] zTDs = new Element[3][3];
        for ( CompassPoint zPoint : CompassPoint.values() ) {
            int zRow = zPoint.getRow();
            int zCol = zPoint.getCol();
            Element zInnerElement;
            if ( (zRow == 1) && (zCol == 1) ) {
                zInnerElement = pInnerElement;
            } else {
                Element zElement = createBorder( pMinimumCellSize );
                if ( (zRow == 0) && (zCol == 1) ) {
                    zWidthImg = zElement;
                } else if ( (zRow == 1) && (zCol == 0) ) {
                    zHeightImg = zElement;
                }
                zInnerElement = zElement;
            }
            zTDs[zRow][zCol] = appendChild( createTD( zPoint ), zInnerElement );
        }
        Element zTBody = createTBody( pTbodyClasses );
        appendChild( zTBody, createRow0( createTR(), zTDs ) );
        appendChild( zTBody, createRow1( createTR(), zTDs, pPreImageWidth, pPostImageWidth ) );
        appendChild( zTBody, createRow2( createTR(), zTDs ) );
        return new CtrlElements( appendChild( createTable(), zTBody ), zTBody, zWidthImg, zHeightImg );
    }

    private static Element createRow0( Element pTR, Element[][] pTDs ) {
        appendChild( pTR, pTDs[0][0] );
        appendChild( pTR, addColSpan( pTDs[0][1] ) );
        appendChild( pTR, pTDs[0][2] );
        return pTR;
    }

    private static Element createRow1( Element pTR, Element[][] pTDs, int pPreImageWidth, int pPostImageWidth ) {
        appendChild( pTR, pTDs[1][0] );
        appendChild( pTR, createTD( "CP_PreCenter", pPreImageWidth ) );
        appendChild( pTR, pTDs[1][1] );
        appendChild( pTR, createTD( "CP_PostCenter", pPostImageWidth ) );
        appendChild( pTR, pTDs[1][2] );
        return pTR;
    }

    private static Element createRow2( Element pTR, Element[][] pTDs ) {
        appendChild( pTR, pTDs[2][0] );
        appendChild( pTR, addColSpan( pTDs[2][1] ) );
        appendChild( pTR, pTDs[2][2] );
        return pTR;
    }

    private static Element addColSpan( Element pElement ) {
        pElement.setPropertyInt( "colSpan", 3 );
        return pElement;
    }

    private static Element createTD( String pClass, int pImageWidth ) {
        Element zTD = DOM.createTD();
        zTD.setClassName( pClass );
        Element zImg = createImg();
        if ( pImageWidth > 0 ) {
            zImg.setAttribute( "width", "" + pImageWidth );
        }
        return appendChild( zTD, zImg );
    }

    private static Element appendChild( Element pParent, Element pNewChild ) {
        pParent.appendChild( pNewChild );
        return pParent;
    }

    private static Element createBorder( int pMinimumCellSize ) {
        Element zElement = createImg();
        zElement.getStyle().setPropertyPx( "width", pMinimumCellSize );
        zElement.getStyle().setPropertyPx( "height", pMinimumCellSize );
        return zElement;
    }

    private static Element createImg() {
        Element zElement = DOM.createImg();
        zElement.setPropertyString( "src", TransparentImage.URL );
        return zElement;
    }

    @Override
    public void setWidth( String width ) {
        int zSize = parseSize( width );
        if ( zSize > 0 ) {
            mCtrlElements.getWidth().getStyle().setPropertyPx( "width", zSize );
        }
    }

    @Override
    public void setHeight( String height ) {
        int zSize = parseSize( height );
        if ( zSize > 0 ) {
            mCtrlElements.getHeight().getStyle().setPropertyPx( "height", zSize );
        }
    }

    private int parseSize( String pSize ) {
        if ( pSize != null ) {
            pSize = pSize.trim().toUpperCase();
            if ( pSize.endsWith( "PX" ) ) {
                pSize = pSize.substring( 0, pSize.length() - 2 ).trim();
            }
            try {
                return Integer.parseInt( pSize ) - (mMinimumCellSize + mMinimumCellSize);
            }
            catch ( NumberFormatException e ) {
                // Whatever!
            }
        }
        return 0;
    }
}