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

import org.litesoft.commonfoundation.html.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

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

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

public class FontSizer
{
    public static final String ASCII = " ?!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";

    public static FontSizer get( String... pStyles )
    {
        if ( null != (pStyles = Strings.noEmpty( pStyles )) )
        {
            if ( pStyles.length > 1 )
            {
                return getComposite( pStyles );
            }
            String zStyle = Strings.noEmpty( pStyles[0] );
            if ( zStyle != null )
            {
                return getSingle( zStyle );
            }
        }
        throw new IllegalStateException( "FontSizer requires at least one Style" );
    }

    public Integer EMs( int pChars )
    {
        Integer zWidth = getAverageCharacterWidth();
        return (zWidth != null) ? (pChars * zWidth) : null;
    }

    public Integer EMsPlus( int pChars, int pPixels )
    {
        Integer zWidth = getAverageCharacterWidth();
        return (zWidth != null) ? ((pChars * zWidth) + pPixels) : null;
    }

    public Integer EMsLess( int pChars, int pPixels )
    {
        return EMsPlus( pChars, -pPixels );
    }

    public Integer getAverageCharacterWidth()
    {
        return mSizer.getAverageCharacterWidth();
    }

    private interface Sizer
    {
        public Integer getAverageCharacterWidth();
    }

    private static class NullSizer implements Sizer
    {
        public static final Sizer INSTANCE = new NullSizer();

        @Override
        public Integer getAverageCharacterWidth()
        {
            return 0;
        }
    }

    private static class Composite implements Sizer
    {
        private Sizer[] mSizers;

        private Integer mCachedResults = null;

        private Composite( Sizer[] pSizers )
        {
            mSizers = pSizers;
        }

        @Override
        public Integer getAverageCharacterWidth()
        {
            if ( mCachedResults == null )
            {
                int zMax = 4;
                for ( Sizer zSizer : mSizers )
                {
                    Integer zWidth = zSizer.getAverageCharacterWidth();
                    if ( zWidth == null )
                    {
                        return null;
                    }
                    zMax = Math.max( zMax, zWidth );
                }
                mCachedResults = zMax;
            }
            return mCachedResults;
        }
    }

    private static final class MyLabel extends HTML implements Sizer
    {
        private static final String HTML_ASCII = HTMLize.escapeNoWrap( ASCII );

        private Integer mCachedResults = null;

        private MyLabel( String pStyle )
        {
            super( createHTML( pStyle ) );

            CommonElementHelper.setOverflowClass( getElement(), true );
            setWidth( "4" );
            RootPanel.get().add( this );
        }

        private static String createHTML( String pStyle )
        {
            return "<table border='0' cellSpacing='0' cellPadding='0'><tbody><tr><td class='" + pStyle + "' style='white-space:nowrap;'>" + //
                   HTML_ASCII + "</td></tr></tbody></table>";
        }

        @Override
        public Integer getAverageCharacterWidth()
        {
            if ( mCachedResults == null )
            {
                if ( isAttached() )
                {
                    int zWidth = getElement().getFirstChildElement().getOffsetWidth();
                    if ( ASCII.length() <= zWidth )
                    {
                        mCachedResults = zWidth / ASCII.length();
                    }
                    else
                    {
                        System.out.println( "FontSizer$MyLabel.getAverageCharacterWidth: " + zWidth );
                    }
                }
            }
            return mCachedResults;
        }
    }

    private Sizer mSizer;

    private FontSizer( Sizer pSizer )
    {
        mSizer = pSizer;
    }

    private static class CompositeKey
    {
        private String[] mStyles;

        private CompositeKey( String[] pStyles )
        {
            mStyles = pStyles;
        }

        @Override
        public int hashCode()
        {
            return Arrays.hashCode( mStyles );
        }

        @Override
        public boolean equals( Object o )
        {
            return (this == o) || //
                   ((o != null) && (getClass() == o.getClass()) && //
                    Arrays.equals( mStyles, ((CompositeKey) o).mStyles ));
        }
    }

    private static Map<String, FontSizer> STYLE_INSTANCES = new HashMap<String, FontSizer>();

    private static FontSizer getSingle( String pStyle )
    {
        FontSizer zFontSizer = STYLE_INSTANCES.get( pStyle );
        if ( zFontSizer == null )
        {
            STYLE_INSTANCES.put( pStyle, zFontSizer = new FontSizer( getSizer( pStyle ) ) );
        }
        return zFontSizer;
    }

    private static Map<CompositeKey, FontSizer> ARRAY_INSTANCES = new HashMap<CompositeKey, FontSizer>();

    private static FontSizer getComposite( String[] pStyles )
    {
        CompositeKey zKey = new CompositeKey( pStyles );
        FontSizer zFontSizer = ARRAY_INSTANCES.get( zKey );
        if ( zFontSizer == null )
        {
            ARRAY_INSTANCES.put( zKey, zFontSizer = new FontSizer( getSizer( pStyles ) ) );
        }
        return zFontSizer;
    }

    private static Map<Object, Sizer> SIZERS = new HashMap<Object, Sizer>();

    private static Sizer getSizer( String pStyle )
    {
        if ( pStyle == null )
        {
            return NullSizer.INSTANCE;
        }
        Sizer zSizer = SIZERS.get( pStyle );
        if ( zSizer == null )
        {
            SIZERS.put( pStyle, zSizer = new MyLabel( pStyle ) );
        }
        return zSizer;
    }

    private static Sizer getSizer( String[] pStyles ) // !null & !empty
    {
        Sizer zSizer = SIZERS.get( pStyles );
        if ( zSizer == null )
        {
            Sizer[] zSizers = new Sizer[pStyles.length];
            for ( int i = 0; i < pStyles.length; i++ )
            {
                zSizers[i] = getSizer( pStyles[i] );
            }
            SIZERS.put( pStyles, zSizer = new Composite( zSizers ) );
        }
        return zSizer;
    }
}