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

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

public class AttributeUsage extends AbstractSharedUsage {
    public static final long serialVersionUID = -7832343234032168444L;

    public static final AttributeUsage[] EMPTY_ARRAY = new AttributeUsage[0];

    private Integer mUniqueID;
    private String mAttributeReference;
    private IntendedUse mIntendedUse;
    private boolean mLabelLess;
    private Boolean mRequired;
    private Hintable.Hint[] mHints;

    /**
     * @deprecated GWT ONLY
     */
    public AttributeUsage() {
    }

    public AttributeUsage( Integer pUniqueID, String pAttributeReference, IntendedUse pIntendedUse,
                           String pLabelID, boolean pDisabled, boolean pLabelLess, Boolean pRequired,
                           Hintable.Hint[] pHints ) {
        super( pDisabled, pLabelID );
        Confirm.isNotNull( "UniqueID", mUniqueID = pUniqueID );
        mAttributeReference = Confirm.significant( "AttributeReference", pAttributeReference );
        mIntendedUse = pIntendedUse;
        mLabelLess = pLabelLess;
        mRequired = pRequired;
        mHints = Currently.isNotNullOrEmpty( pHints ) ? pHints : null;
    }

    public AttributeUsage( Integer pUniqueID, String pAttributeReference ) {
        this( pUniqueID, pAttributeReference, IntendedUse.ForView, null, true, true, null, null );
    }

    protected AttributeUsage( AttributeUsage pAttributeUsage ) {
        this( pAttributeUsage.getUniqueID(), //
              pAttributeUsage.getAttributeReference(), //
              pAttributeUsage.getIntendedUse(), //
              pAttributeUsage.getLabelID(), //
              pAttributeUsage.isDisabled(), //
              pAttributeUsage.isLabelLess(), //
              pAttributeUsage.getRequired(), //
              pAttributeUsage.getHints() );
    }

    public Integer getUniqueID() {
        return mUniqueID;
    }

    public String getAttributeReference() {
        return mAttributeReference;
    }

    public String getExtLabelID() {
        String rv = getLabelID();
        return (rv != null) ? rv : getAttributeReference();
    }

    public IntendedUse getIntendedUse() {
        return mIntendedUse;
    }

    public boolean isLabelLess() {
        return mLabelLess;
    }

    public Boolean getRequired() {
        return mRequired;
    }

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

    public boolean isSingle() {
        return true;
    }

    public boolean shouldDataBeHiden() {
        return mIntendedUse.isHideData();
    }

    public boolean shouldComponentBeDisabled() {
        return isDisabled() || !getIntendedUseComponentEnabled();
    }

    public boolean getIntendedUseComponentEnabled() {
        return !mIntendedUse.isDisabled() && (mIntendedUse.isEdit() || mIntendedUse.isSearch());
    }

    public String toString() {
        return toStringBuilder( new StringBuilder().append( "AttributeUsage-" ), 0 ).toString();
    }

    public StringBuilder toStringBuilder( StringBuilder pSB, int pDepth ) {
        pSB.append( mAttributeReference );
        addLabelID( pSB );
        if ( mIntendedUse != null ) {
            pSB.append( ',' ).append( mIntendedUse );
        }
        addDisabled( pSB );
        if ( isLabelLess() ) {
            pSB.append( ",LabelLess" );
        }
        if ( Boolean.TRUE.equals( getRequired() ) ) {
            pSB.append( ",Required" );
        } else if ( Boolean.FALSE.equals( getRequired() ) ) {
            pSB.append( ",!Required" );
        }
        if ( mHints != null ) {
            LineIndentUtil.newLine( pSB, ++pDepth ).append( "Hints" ).append( ':' );
            pDepth++;
            for ( Hintable.Hint hint : mHints ) {
                LineIndentUtil.newLine( pSB, pDepth );
                pSB.append( hint.getName() ).append( '=' ).append( hint.getValue() );
            }
        }
        return pSB;
    }

    public boolean equals( Object o ) {
        return (this == o) || ((o instanceof AttributeUsage) && equals( (AttributeUsage) o ));
    }

    public boolean equals( AttributeUsage them ) {
        return (this == them) || ((them != null) //
                                  && them.innerEquals( this ) // Flip em for Detection of sub-classes
        );
    }

    protected boolean innerEquals( AttributeUsage pThem ) {
        return Currently.areEqual( this.mUniqueID, pThem.mUniqueID ) && //
               Currently.areEqual( this.mAttributeReference, pThem.mAttributeReference ) && //
               Currently.areEqual( this.mIntendedUse, pThem.mIntendedUse ) && //
               Currently.areEqual( this.isDisabled(), pThem.isDisabled() ) && //
               Currently.areEqual( this.mLabelLess, pThem.mLabelLess ) && //
               Currently.areEqual( this.mRequired, pThem.mRequired ) && //
               Currently.areEqual( this.mHints, pThem.mHints );
    }

    public int hashCode() {
        return mUniqueID.hashCode();
    }

    public int compareTo( Object o ) {
        return compareTo( (AttributeUsage) o );
    }

    public int compareTo( AttributeUsage pThem ) {
        // Flip em for Detection of sub-classes
        return -(pThem.innerCompareTo( this ));
    }

    protected int innerCompareTo( AttributeUsage pThem ) {
        return Compare.first( this.mAttributeReference, pThem.mAttributeReference //
        ).then( this.mIntendedUse, pThem.mIntendedUse //
        ).then( this.isDisabled(), pThem.isDisabled() //
        ).then( this.mLabelLess, pThem.mLabelLess //
                //  ).then( this.mRequired, pThem.mRequired //
        ).then( this.mUniqueID, pThem.mUniqueID //
        ).result();
    }
}