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

import org.litesoft.GWT.forms.server.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.configuration.*;
import org.litesoft.core.util.*;
import org.litesoft.orsup.base.*;
import org.litesoft.ui_1_5.def.*;
import org.litesoft.util.*;

public class CreateAMDParamsPlus extends CreateAMDParams {
    public static final Configuration.CachedConfigInt DEFAULT_SHORT_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultShortDisplayCharsWidth", 3 );

    public static final Configuration.CachedConfigInt DEFAULT_INTEGER_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultIntegerDisplayCharsWidth", 8 );

    public static final Configuration.CachedConfigInt DEFAULT_LONG_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultLongDisplayCharsWidth", 15 );

    public static final Configuration.CachedConfigInt DEFAULT_FIXED_PLONG_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultFixedPLongDisplayCharsWidth", 15 );

    public static final Configuration.CachedConfigInt DEFAULT_FLOATING_PLONG_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultFloatingPLongDisplayCharsWidth", 15 );

    public static final Configuration.CachedConfigInt DEFAULT_FLOAT_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultFloatDisplayCharsWidth", 15 );

    public static final Configuration.CachedConfigInt DEFAULT_DOUBLE_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultDoubleDisplayCharsWidth", 20 );

    public static final Configuration.CachedConfigInt DEFAULT_MONEY_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultMoneyDisplayCharsWidth", 15 );

    private static final Configuration.CachedConfigInt DEFAULT_TEXT_FIELD_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultTextFieldDisplayCharsWidth", 20 );

    private static final Configuration.CachedConfigInt DEFAULT_PASSWORD_FIELD_DISPLAY_CHARS_WIDTH = //
            new Configuration.CachedConfigInt( "DefaultPasswordFieldDisplayCharsWidth", 10 );

    private static final Configuration.CachedConfigInt MAX_CHARS_FOR_TEXT_FIELD = //
            new Configuration.CachedConfigInt( "MaxCharsForTextField", 255 );

    private static final Configuration.CachedConfigInt MAX_DEFAULT_DISPLAY_CHARS_WIDTH_FOR_TEXT_FIELD_BEFORE_FLOODX = //
            new Configuration.CachedConfigInt( "MaxDefaultDisplayCharsWidthForTextFieldBeforeFloodX", 80 );

    protected HintManager mHintManager;

    protected boolean mRequired;
    protected boolean mDisabled;
    protected boolean mHide;

    protected Integer mMaxChars;

    protected Integer mDisplayLines, mDisplayCharsWidth;

    protected void apply( HintManager pAttributeHintManager, //
                          boolean pRequired, boolean pDisabled, boolean pHide, //
                          Integer pMaxChars, Integer pDisplayLines, Integer pDisplayCharsWidth ) {
        mHintManager = HintController.getGlobalHintManager().addAll( pAttributeHintManager ).addAll(
                getUsage().getHints() );

        mRequired = mergeRequired( pRequired, getUsage().getRequired() );
        mDisabled = pDisabled || getUsage().shouldComponentBeDisabled();
        mHide = pHide || getUsage().shouldDataBeHiden();
        switch ( getField() ) {
            default:
            case ViewHide:
                mHide = true;
                // Fall Thru
            case ViewOnly:
                mDisabled = true;
                break;
            case EditHide:
                mHide = true;
                break;
            case Editable:
                break;
        }

        mMaxChars = pMaxChars;
        if ( (mMaxChars != null) && (mMaxChars < 1) ) {
            mMaxChars = null;
        }

        mDisplayLines = pDisplayLines;

        if ( (mDisplayCharsWidth != null) && (mDisplayCharsWidth < 1) ) {
            mDisplayCharsWidth = null;
        }
        mDisplayCharsWidth = pDisplayCharsWidth;
    }

    protected boolean mergeRequired( boolean pServiceSaysRequired, Boolean pUsageSaysRequired ) {
        return (pUsageSaysRequired == null) ? pServiceSaysRequired : pUsageSaysRequired;
    }

    public CreateAMDParamsPlus( CreateAMDParams pParams, HintManager pAttributeHintManager, //
                                boolean pRequired, boolean pDisabled, boolean pHide, //
                                Integer pMaxChars, Integer pDisplayLines, Integer pDisplayCharsWidth ) {
        super( pParams );
        apply( pAttributeHintManager, //
               pRequired, pDisabled, pHide, //
               pMaxChars, pDisplayLines, pDisplayCharsWidth );
    }

    public CreateAMDParamsPlus( CreateAMDParams pParams, AttributeAccessorSCD pSCD ) {
        super( pParams );
        // todo: translate:
//        apply( pSCD.getHintManager(), //
//               pSCD.isRequired(), //
//               Boolean.FALSE.equals( pSCD.getBooleanProperty( AttributeAccessorSCD.EDITABLE_PROPERTY ) ), //
//               Boolean.TRUE.equals( pSCD.getBooleanProperty( AttributeAccessorSCD.HIDE_PROPERTY ) ), //
//               pSCD.getIntegerProperty( AttributeAccessorSCD.LENGTH_PROPERTY ), // MaxChars;
//               pSCD.getIntegerProperty( AttributeAccessorSCD.DISPLAY_LINES_PROPERTY ),
//               pSCD.getIntegerProperty( AttributeAccessorSCD.DISPLAY_COLUMNS_PROPERTY ) );
    }

    public boolean isRequired() {
        return mRequired;
    }

    public boolean isDisabled() {
        return mDisabled;
    }

    public boolean isHide() {
        return mHide;
    }

    public Hintable.Hint[] getHints() {
        return mHintManager.getHints();
    }

    public String getHintValue( String pName ) {
        return mHintManager.getHintValue( pName );
    }

    public String getHintValue( String pName, String pDefaultIfNullOrEmpty ) {
        return mHintManager.getHintValue( pName, pDefaultIfNullOrEmpty );
    }

    public boolean isEditRequired() {
        return isRequired() && getUsage().getIntendedUse().isEdit();
    }

    public String resolveAction( String pActionID ) {
        return mExternalization.resolveAction( pActionID );
    }

    public String getErrorTextForRequired() {
        return isRequired() ? error( FormServicePeer.IS_REQUIRED_ERROR_KEY, getFieldLabel() ) : null;
    }

    public String error( String pErrorKey, String... pToInject ) {
        return SimpleMessage.format( mExternalization.resolveError( pErrorKey ), (Object[]) pToInject );
    }

    public Integer getMaxChars() {
        return mMaxChars;
    }

    public Integer getDisplayLines() {
        return mDisplayLines;
    }

    public Integer getDisplayCharsWidth() {
        return mDisplayCharsWidth;
    }

    public boolean shouldBeTextArea() {
        return ((mMaxChars == null) || (mMaxChars > MAX_CHARS_FOR_TEXT_FIELD.getInteger()) ||
                UI.Hints.CF_TEXT_AREA.equals( getHintValue( UI.Hints.COMPONENT_FORM ) ));
    }

    public Integer getPasswordDisplayCharsWidth() {
        return oneLineHintOveride( DEFAULT_PASSWORD_FIELD_DISPLAY_CHARS_WIDTH );
    }

    public Integer getTextFieldDisplayCharsWidth() {
        return oneLineHintOveride( DEFAULT_TEXT_FIELD_DISPLAY_CHARS_WIDTH );
    }

    public Integer oneLineHintOveride( Configuration.CachedConfigInt pCachedConfigInt ) {
        Integer width = hintOveride( UI.Hints.TEXT_FIELD_WIDTH, mDisplayCharsWidth );
        if ( width == null ) {
            width = (mMaxChars == null) ? pCachedConfigInt.getInteger() : (mMaxChars + 1);
        }
        return (width <= MAX_DEFAULT_DISPLAY_CHARS_WIDTH_FOR_TEXT_FIELD_BEFORE_FLOODX.getInteger()) ? //
               width : null;
    }

    public Integer getTextAreaInitialDisplayCharsWidth() {
        return hintOveride( UI.Hints.TEXT_AREA_WIDTH, mDisplayLines );
    }

    public Integer getTextAreaInitialDisplayLines() {
        return hintOveride( UI.Hints.TEXT_AREA_LINES, mDisplayLines );
    }

    private Integer hintOveride( String pHintName, Integer pCurValue ) {
        Integer override = getIntegerHint( pHintName );
        return (override != null) ? override : pCurValue;
    }

    public Integer getIntegerHint( String pHintName ) {
        String value = ConstrainTo.significantOrNull( getHintValue( pHintName ) );
        if ( value != null ) {
            try {
                return Integer.valueOf( value );
            }
            catch ( NumberFormatException e ) {
                System.err.println( "Hint '" + pHintName + "' Not an Integer: " + value );
            }
        }
        return null;
    }
}