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

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.util.*;
import org.litesoft.ui.def.*;
import org.litesoft.ui.def.nonpublic.support.*;
import org.litesoft.ui.support.*;
import org.litesoft.uispecification.*;

public class UiInputDef extends AbstractUiInputDef implements Hintable
{
    public static final String HINT_CATEGORY = "InputDef";

    public static final UiD_Type TYPE = new UiD_Type( CI_INPUT, "Input" );
    public static final UiDefTypeFactory FACTORY = new UiDefTypeFactory()
    {
        public UiD_Type getType()
        {
            return TYPE;
        }

        public UiDef create()
        {
            return new UiInputDef();
        }
    };

    public UiD_Type getType()
    {
        return TYPE;
    }

    public UiInputDef()
    {
    }

    public UiInputDef( String pAttributeName )
    {
        super( pAttributeName );
    }

    public UiInputDef forView()
    {
        setIntendedUse( IntendedUse.ForView );
        return this;
    }

    public UiInputDef forEdit()
    {
        setIntendedUse( IntendedUse.ForEdit );
        return this;
    }

    public UiInputDef forSearch()
    {
        setIntendedUse( IntendedUse.ForSearch );
        return this;
    }

    public UiInputDef forSearchRequired()
    {
        setIntendedUse( IntendedUse.ForSearch_Required );
        return this;
    }

    public UiInputDef forSearchDirect()
    {
        setIntendedUse( IntendedUse.ForSearch_Direct );
        return this;
    }

    public UiInputDef required()
    {
        setRequired( Boolean.TRUE );
        return this;
    }

    public UiInputDef notRequired()
    {
        setRequired( Boolean.FALSE );
        return this;
    }

    public UiInputDef labelID( String pLabelID )
    {
        setLabelID( pLabelID );
        return this;
    }

    public UiInputDef labelLess()
    {
        setLabelLess( true );
        return this;
    }

    public UiInputDef labelFont( UiFont pFont )
    {
        setLabelFont( pFont );
        return this;
    }

    public UiInputDef disabled()
    {
        setDisabled( true );
        return this;
    }

    /**
     * Add the Hint (if pValue is not null or empty)
     *
     * @param pName !null or empty
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public UiInputDef hint( String pName, String pValue )
            throws IllegalArgumentException
    {
        addHint( pName, pValue );
        return this;
    }

    public UiInputDef hint( Hint pHint )
    {
        addHint( pHint );
        return this;
    }

    protected void collectDefAttributes( UiD_AttributeCollector pCollector )
    {
        super.collectDefAttributes( pCollector );
        pCollector.add( mLabelID );
        pCollector.add( mLabelLess );
        pCollector.add( mRequired );
    }

    private UiD_AttributeStringOptional mLabelID = new UiD_AttributeStringOptional( "LabelID" );
    private UiD_Attribute_boolean mLabelLess = new UiD_Attribute_boolean( "LabelLess" );
    private UiD_AttributeBoolean mRequired = new UiD_AttributeBoolean( "Required" );

    public AttributeUsage getAttributeUsage( IntendedUse pIntendedUseNonNull )
    {
        return new AttributeUsage( getAttributeUniqueID(), getAttributeName(), pIntendedUseNonNull,
                                   getLabelID(), isDisabled(), isLabelLess(), getRequired(),
                                   (mHintManager != null) ? getHints() : null );
    }

    public String getLabelID()
    {
        return mLabelID.getValue();
    }

    public void setLabelID( String pLabelID )
    {
        mLabelID.setValue( pLabelID );
    }

    public Boolean getRequired()
    {
        return mRequired.getValue();
    }

    public void setRequired( Boolean pRequired )
    {
        mRequired.setValue( pRequired );
    }

    public boolean isLabelLess()
    {
        return mLabelLess.isValue();
    }

    public void setLabelLess( boolean pLabelLess )
    {
        mLabelLess.setValue( pLabelLess );
    }

    public boolean anyHints()
    {
        return getHintManager().anyHints();
    }

    /**
     * @return !null and No Nulls
     */
    public Hint[] getHints()
    {
        return getHintManager().getHints();
    }

    /**
     * Return the value associated with pName if any.
     *
     * @param pName !null or empty
     *
     * @return null or value associated with pName
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public String getHintValue( String pName )
            throws IllegalArgumentException
    {
        return getHintManager().getHintValue( pName );
    }

    /**
     * Add the Hint (if pValue is not null or empty) and return any previous Hint's Value with the same pName
     *
     * @param pName !null or empty
     *
     * @return null or previous Hint's Value with the same pName
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public String addHint( String pName, String pValue )
            throws IllegalArgumentException
    {
        return getAddHintManager( Strings.isNotNullOrEmpty( pValue ) ).addHint( pName, pValue );
    }

    /**
     * Add the Hint (if it was not null) and return any previous Hint's Value with the same Hint Name
     *
     * @return null or previous Hint's Value with the same Hint Name
     */
    public String addHint( Hint pHint )
    {
        return getAddHintManager( pHint != null ).addHint( pHint );
    }

    /**
     * Remove the Hint indicated by pName and return its Value
     *
     * @param pName !null or empty
     *
     * @return null if not found or removed Hint's Value
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public String removeHint( String pName )
            throws IllegalArgumentException
    {
        return getHintManager().removeHint( pName );
    }

    public HintManager getHintManager()
    {
        return (mHintManager != null) ? mHintManager : HintManager.NULL;
    }

    private HintManager mHintManager = null;

    private HintManager getAddHintManager( boolean pProbablyAdding )
    {
        HintManager manager = getHintManager();
        if ( pProbablyAdding )
        {
            mHintManager = manager = manager.aboutToAdd();
        }
        return manager;
    }

    private static final String FONT_ATTRIBUTE_NAME = "LabelFont";

    private UiFont mLabelFont = null;

    public UiFont getLabelFont()
    {
        return mLabelFont;
    }

    public void setLabelFont( UiFont pFont )
    {
        mLabelFont = pFont;
    }

    private static final String[] FONT_ATTRIBUTE_NAMES = new String[]{FONT_ATTRIBUTE_NAME};

    /**
     * @return entry '0' will be for the 'Label'
     */
    public String[] getFontAttributeNames()
    {
        return FONT_ATTRIBUTE_NAMES;
    }

    public UiFont getFont( String pAttributeName )
    {
        return FONT_ATTRIBUTE_NAME.equals( pAttributeName ) ? getLabelFont() : null;
    }

    public void setFont( String pAttributeName, UiFont pUiFont )
    {
        if ( FONT_ATTRIBUTE_NAME.equals( pAttributeName ) )
        {
            setLabelFont( pUiFont );
            return;
        }
        throw new IllegalArgumentException( "Invalid Font AttributeName '" + pAttributeName + "', " +
                                            Objects.optionsToString( FONT_ATTRIBUTE_NAMES ) );
    }
}