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

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

public class UiFormDef extends AbstractUiDef implements UiContainerMarker,
                                                        UiIntendedUsageable,
                                                        UiTitleBorderSource,
                                                        FormUniqueable
{
    /**
     * Common Action ID for forms: close the current form
     */
    public static final String ACTION_CLOSE = "Close";
    /**
     * Common Action ID for forms: commit the edited values in the backing object
     */
    public static final String ACTION_DONE = "Done";
    /**
     * Common Action ID for forms: commit the edited values in the backing object & close on success
     */
    public static final String ACTION_COMMIT = "Commit";
    /**
     * Common Action ID for forms: discard any edits and replace with original values
     */
    public static final String ACTION_RELOAD = "Reload";
    /**
     * Common Action ID for forms: replace the current backing object with a fresh one
     */
    public static final String ACTION_NEW = "New";

    public static final UiD_Type TYPE = new UiD_Type( CI_FORM, FORM_FORM );
    public static final UiDefTypeFactory FACTORY = new UiDefTypeFactory()
    {
        public UiD_Type getType()
        {
            return TYPE;
        }

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

    public UiD_Type getType()
    {
        return TYPE;
    }

    public UiFormDef()
    {
        mChildrenHelper = new UiChildrenHelperRequiredSingleContainer( this );
    }

    public UiFormDef( String pRootType )
    {
        this();
        setRootType( pRootType );
    }

    public UiFormDef( String pRootType, UiCompDef pCompDef )
    {
        this( pRootType );
        if ( pCompDef != null )
        {
            if ( !(pCompDef instanceof UiContainerDef) )
            {
                pCompDef = new UiSingleLayoutDef( pCompDef );
            }
            getChildrenHelper().addChild( pCompDef );
        }
    }

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

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

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

    public UiFormDef forEditDisabled()
    {
        setIntendedUse( IntendedUse.ForEdit_Disabled );
        return this;
    }

    public UiFormDef hot()
    {
        setHot( true );
        return this;
    }

    public UiFormDef bordered()
    {
        setBordered( true );
        return this;
    }

    public UiFormDef bordered( String pExtName )
    {
        setExtTitle( pExtName );
        return this;
    }

    public UiFormDef bordered( String pExtName, UiFont pFont )
    {
        setExtTitle( pExtName );
        setTitleFont( pFont );
        return this;
    }

    public UiChildrenHelper getChildrenHelper()
    {
        return mChildrenHelper;
    }

    protected void collectDefAttributes( UiD_AttributeCollector pCollector )
    {
        super.collectDefAttributes( pCollector );
        pCollector.add( mIntendedUse );
        pCollector.add( mHot );
        pCollector.add( mRootType );
        pCollector.add( mBordered );
        pCollector.add( mExtTitle );
    }

    protected UiD_AttributeIntendedUseOptional mIntendedUse = new UiD_AttributeIntendedUseOptional();
    private UiD_Attribute_boolean mHot = new UiD_Attribute_boolean( "Hot" );
    private UiD_Attribute_boolean mBordered = new UiD_Attribute_boolean( "Bordered" );
    private UiD_AttributeStringOptional mExtTitle = new UiD_AttributeStringOptional( "ExtTitle" );
    private UiD_AttributeStringRequired mRootType = new UiD_AttributeStringRequired( "RootType" );

    public IntendedUse getIntendedUse()
    {
        return mIntendedUse.getValue();
    }

    public void setIntendedUse( IntendedUse pIntendedUse )
    {
        mIntendedUse.setValue( pIntendedUse );
    }

    public boolean isHot()
    {
        return mHot.isValue();
    }

    public void setHot( boolean pHot )
    {
        mHot.setValue( pHot );
    }

    public boolean isBordered()
    {
        return mBordered.isValue();
    }

    public void setBordered( boolean pBordered )
    {
        mBordered.setValue( pBordered );
    }

    public void setExtTitle( String pExtTitle )
    {
        mExtTitle.setValue( pExtTitle );
    }

    public String getExtTitle()
    {
        return mExtTitle.getValue();
    }

    public String getRootType()
    {
        return mRootType.getValue();
    }

    public void setRootType( String pRootType )
    {
        mRootType.setValue( pRootType );
    }

    public String getLabelID()
    {
        return getExtTitle();
    }

    public final LabelUsage getLabelUsage()
    {
        String zTitle = getExtTitle();
        return (zTitle != null) ? new LabelUsage( zTitle ) : null;
    }

    private static final String FONT_ATTRIBUTE_NAME = "TitleFont";

    private UiFont mTitleFont = null;

    public UiFont getTitleFont()
    {
        return mTitleFont;
    }

    public void setTitleFont( UiFont pFont )
    {
        mTitleFont = pFont;
    }

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

    public String[] getFontAttributeNames()
    {
        return FONT_ATTRIBUTE_NAMES;
    }

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

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

    public FormUsage getFormUsage()
    {
        if ( getIntendedUse() == null )
        {
            throw new IllegalStateException(
                    mIntendedUse.getName() + " is required for the 'root' " + getTypeLabel() );
        }
        mRootType.validate( this );
        FormUsageCollector collector = new FormUsageCollector( getFormUniqueID(), mRootType.getValue(),
                                                               isHot(), mIntendedUse.getValue() );
        collector.addLabel( getLabelUsage() );
        UiDef child = getChild();
        if ( child != null )
        {
            UiDvCollectFormUsages.INSTANCE.process( child, collector );
        }
        return collector.getFormUsage();
    }

    public Integer getFormUniqueID()
    {
        return mFormUniqueID;
    }

    private Integer mFormUniqueID = null;

    public void setFormUniqueID( Integer pUniqueID )
    {
        mFormUniqueID = pUniqueID;
    }

    private UiDef getChild()
    {
        UiDef[] children = getChildrenHelper().getChildren();
        return (children.length == 1) ? children[0] : null;
    }
}