// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.uispecification;

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.hierarchicaldata.*;

public class UiFont
{
    /**
     * Family takes a String of comma seperated Font Family 'names', if the 'name' has spaces in it, it
     * must be quoted by single quotes (').<p>
     * <p/>
     * Parsing rules:
     * Leading & trailing spaces will be removed,
     * Single Quotes (') must be paired, &
     * The following characters are NOT allowed:
     * ';', ':', '"'
     */
    public static final String FAMILY = "Family";

    public static final String COLOR = "Color";

    public static final String SIZE = "Size";
    public static final String STYLE = "Style";
    public static final String WEIGHT = "Weight";
    public static final String DECORATION = "Decoration";

    public static final String SIZE_XX_SMALL = "xx-small";
    public static final String SIZE_X_SMALL = "x-small";
    public static final String SIZE_SMALL = "small";
    public static final String SIZE_MEDIUM = "medium";
    public static final String SIZE_LARGE = "large";
    public static final String SIZE_X_LARGE = "x-large";
    public static final String SIZE_XX_LARGE = "xx-large";
    public static final String SIZE_SMALLER = "smaller";
    public static final String SIZE_LARGER = "larger";

    public static final String STYLE_NORMAL = "normal";
    public static final String STYLE_ITALIC = "italic";

    public static final String WEIGHT_NORMAL = "normal";
    public static final String WEIGHT_BOLD = "bold";

    public static final String DECORATION_NONE = "none";
    public static final String DECORATION_UNDERLINE = "underline";
    public static final String DECORATION_LINE_THROUGH = "line-through";

    private static final String[] SIZE_OPTIONS = new String[] //
            { //
              SIZE_XX_SMALL, //
              SIZE_X_SMALL, //
              SIZE_SMALL, //
              SIZE_MEDIUM, //
              SIZE_LARGE, //
              SIZE_X_LARGE, //
              SIZE_XX_LARGE, //
              SIZE_SMALLER, //
              SIZE_LARGER, //
            };

    private static final String[] STYLE_OPTIONS = new String[] //
            { //
              STYLE_NORMAL, //
              STYLE_ITALIC, //
            };

    private static final String[] WEIGHT_OPTIONS = new String[] //
            { //
              WEIGHT_NORMAL, //
              WEIGHT_BOLD, //
            };

    private static final String[] DECORATION_OPTIONS = new String[] //
            { //
              DECORATION_NONE, //
              DECORATION_UNDERLINE, //
              DECORATION_LINE_THROUGH, //
            };

    private String mFamily = null;
    private String mColor = null;
    private String mSize = null;
    private String mStyle = null;
    private String mWeight = null;
    private String mDecoration = null;

    private UiFont( String pFamily, String pColor, String pSize, String pStyle, String pWeight, String pDecoration )
    {
        mFamily = pFamily;
        mColor = pColor;
        mSize = pSize;
        mStyle = pStyle;
        mWeight = pWeight;
        mDecoration = pDecoration;
    }

    public String getFamily()
    {
        return mFamily;
    }

    /**
     * Family takes a String of comma seperated Font Family 'names', if the 'name' has spaces in it, it
     * must be quoted by single quotes (').<p>
     * <p/>
     * Parsing rules:
     * Leading & trailing spaces will be removed,
     * Single Quotes (') must be paired, &
     * The following characters are NOT allowed:
     * ';', ':', '"'
     */
    public UiFont family( String pFamily )
    {
        pFamily = parseFamily( pFamily );
        return Objects.areNonArraysEqual( mFamily, pFamily ) ? this : new UiFont( pFamily, mColor, mSize, mStyle, mWeight, mDecoration );
    }

    private String parseFamily( String pStr )
    {
        if ( null != (pStr = Strings.noEmpty( pStr )) )
        {
            checkFamilyBadChar( pStr, ';' );
            checkFamilyBadChar( pStr, ':' );
            checkFamilyBadChar( pStr, '"' );
            checkFamilyPairedSingleQuotes( pStr );
        }
        return pStr;
    }

    private void checkFamilyBadChar( String pStr, char c )
    {
        if ( pStr.indexOf( c ) != -1 )
        {
            throw new IllegalArgumentException( "Font Family may not have a '" + c + "' character in it: " + pStr );
        }
    }

    private void checkFamilyPairedSingleQuotes( String pStr )
    {
        int zQuotes = 0;
        for ( int at, from = 0; -1 != (at = pStr.indexOf( '\'', from )); from = at + 1 )
        {
            zQuotes++;
        }
        if ( (zQuotes & 1) != 0 ) // Odd
        {
            throw new IllegalArgumentException( "Font Family has single quotes (') that are NOT paired: " + pStr );
        }
    }

    public String getColor()
    {
        return mColor;
    }

    public UiFont color( String pColor )
    {
        pColor = parseColor( pColor );
        return Objects.areNonArraysEqual( mColor, pColor ) ? this : new UiFont( mFamily, pColor, mSize, mStyle, mWeight, mDecoration );
    }

    private String parseColor( String pStr )
    {
        if ( null != (pStr = Strings.noEmpty( pStr )) )
        {
            if ( pStr.startsWith( "#" ) )
            {
                return "#" + parseColorCode( pStr.substring( 1 ).trim().toUpperCase() );
            }
            if ( !isAllAlpha( pStr ) )
            {
                throw new IllegalArgumentException( "A Color must either be a 'code' (eg #FF0000) or a color name, but provided: " + pStr );
            }
        }
        return pStr;
    }

    private boolean isAllAlpha( String pStr )
    {
        for ( int i = pStr.length(); --i >= 0; )
        {
            if ( !Character.isLetter( pStr.charAt( i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    private String parseColorCode( String pStr )
    {
        if ( (pStr.length() == 6) //
             && isHex( pStr.charAt( 0 ) ) //
             && isHex( pStr.charAt( 1 ) ) //
             && isHex( pStr.charAt( 2 ) ) //
             && isHex( pStr.charAt( 3 ) ) //
             && isHex( pStr.charAt( 4 ) ) //
             && isHex( pStr.charAt( 5 ) ) //
                )
        {
            return pStr;
        }
        throw new IllegalArgumentException( "A Color 'code' must have 6 hex digits eg #FF0000, but provided: #" + pStr );
    }

    private boolean isHex( char pChar )
    {
        return (('0' <= pChar) && (pChar <= '9')) || (('A' <= pChar) && (pChar <= 'F'));
    }

    public String getSize()
    {
        return mSize;
    }

    public UiFont size( String pSize )
    {
        pSize = parseSize( pSize );
        return Objects.areNonArraysEqual( mSize, pSize ) ? this : new UiFont( mFamily, mColor, pSize, mStyle, mWeight, mDecoration );
    }

    private String parseSize( String pStr )
    {
        if ( null != (pStr = Strings.noEmpty( pStr )) )
        {
            if ( (pStr.length() > 1) && pStr.endsWith( "%" ) )
            {
                String num = pStr.substring( 0, pStr.length() - 1 ).trim();
                int i = Integer.parseInt( num );
                if ( 1 < i )
                {
                    return i + "%";
                }
            }
        }
        return nullOrOptions( SIZE, "##%", pStr, SIZE_OPTIONS );
    }

    public String getStyle()
    {
        return mStyle;
    }

    public UiFont style( String pStyle )
    {
        pStyle = parseStyle( pStyle );
        return Objects.areNonArraysEqual( mStyle, pStyle ) ? this : new UiFont( mFamily, mColor, mSize, pStyle, mWeight, mDecoration );
    }

    private String parseStyle( String pStr )
    {
        return nullOrOptions( STYLE, "", Strings.noEmpty( pStr ), STYLE_OPTIONS );
    }

    public UiFont sizeXXsmall()
    {
        return size( SIZE_XX_SMALL );
    }

    public UiFont sizeXsmall()
    {
        return size( SIZE_X_SMALL );
    }

    public UiFont sizeSmall()
    {
        return size( SIZE_SMALL );
    }

    public UiFont sizeMedium()
    {
        return size( SIZE_MEDIUM );
    }

    public UiFont sizeLarge()
    {
        return size( SIZE_LARGE );
    }

    public UiFont sizeXlarge()
    {
        return size( SIZE_X_LARGE );
    }

    public UiFont sizeXXlarge()
    {
        return size( SIZE_XX_LARGE );
    }

    public UiFont sizeSmaller()
    {
        return size( SIZE_SMALLER );
    }

    public UiFont sizeLarger()
    {
        return size( SIZE_LARGER );
    }

    public UiFont styleNormal()
    {
        return style( STYLE_NORMAL );
    }

    public UiFont styleItalic()
    {
        return style( STYLE_ITALIC );
    }

    public String getWeight()
    {
        return mWeight;
    }

    public UiFont weight( String pWeight )
    {
        pWeight = parseWeight( pWeight );
        return Objects.areNonArraysEqual( mWeight, pWeight ) ? this : new UiFont( mFamily, mColor, mSize, mStyle, pWeight, mDecoration );
    }

    private String parseWeight( String pStr )
    {
        return nullOrOptions( WEIGHT, "", Strings.noEmpty( pStr ), WEIGHT_OPTIONS );
    }

    public UiFont weightNormal()
    {
        return weight( WEIGHT_NORMAL );
    }

    public UiFont weightBold()
    {
        return weight( WEIGHT_BOLD );
    }

    public String getDecoration()
    {
        return mDecoration;
    }

    public UiFont decoration( String pDecoration )
    {
        pDecoration = parseDecoration( pDecoration );
        return Objects.areNonArraysEqual( mDecoration, pDecoration ) ? this : new UiFont( mFamily, mColor, mSize, mStyle, mWeight, pDecoration );
    }

    private String parseDecoration( String pStr )
    {
        return nullOrOptions( DECORATION, "", Strings.noEmpty( pStr ), DECORATION_OPTIONS );
    }

    public UiFont decorationNone()
    {
        return decoration( DECORATION_NONE );
    }

    public UiFont decorationUnderline()
    {
        return decoration( DECORATION_UNDERLINE );
    }

    public UiFont decorationLineThrough()
    {
        return decoration( DECORATION_LINE_THROUGH );
    }

    /*
       font-family:
           arial, sans-serif;
           tahoma, sans-serif;
           courier, serif;
           times, serif;

       color:
           red;
           green;
           #FFFFFF;

       font-size:
           xx-small;
           x-small;
           small;
           medium;
           large;
           x-large;
           xx-large;
           smaller;
           larger;
           80%;

       font-style:
           normal;
           italic;

       font-weight:
           normal;
           bold;

       text-decoration:
           none;
           underline;
           line-through;
    */

    public void desiccate( AttributesNameValueMutator pMutator )
    {
        desiccate( pMutator, FAMILY, mFamily );
        desiccate( pMutator, COLOR, mColor );
        desiccate( pMutator, SIZE, mSize );
        desiccate( pMutator, STYLE, mStyle );
        desiccate( pMutator, WEIGHT, mWeight );
        desiccate( pMutator, DECORATION, mDecoration );
    }

    public static UiFont rehydrate( AttributesNameValueAccessor pAccessor )
    {
        UiFont rv = NULL;
        rv = rv.family( rehydrate( pAccessor, FAMILY ) );
        rv = rv.color( rehydrate( pAccessor, COLOR ) );
        rv = rv.size( rehydrate( pAccessor, SIZE ) );
        rv = rv.style( rehydrate( pAccessor, STYLE ) );
        rv = rv.weight( rehydrate( pAccessor, WEIGHT ) );
        rv = rv.decoration( rehydrate( pAccessor, DECORATION ) );
        return rv;
    }

    public static final UiFont NULL = new UiFont( null, null, null, null, null, null );

    private static void desiccate( AttributesNameValueMutator pMutator, String pWhat, String pValue )
    {
        if ( pValue != null )
        {
            pMutator.setAttribute( pWhat, pValue );
        }
    }

    private static String rehydrate( AttributesNameValueAccessor pAccessor, String pAttibuteName )
    {
        return pAccessor.getAttributeValue( pAttibuteName );
    }

    private String nullOrOptions( String pWhat, String pXtraOption, String pValue, String[] pOptions )
    {
        if ( pValue == null )
        {
            return null;
        }
        for ( String option : pOptions )
        {
            if ( option.equalsIgnoreCase( pValue ) )
            {
                return option;
            }
        }
        throw new IllegalArgumentException( "Invalid " + pWhat + " '', only accepting: " + pXtraOption + Objects.optionsToString( pOptions ) );
    }
}