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

import org.litesoft.core.typeutils.*;
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 );
        Objects.assertNotNull( "UniqueID", mUniqueID = pUniqueID );
        mAttributeReference = UtilsCommon.assertNotNullNotEmpty( "AttributeReference", pAttributeReference );
        mIntendedUse = pIntendedUse;
        mLabelLess = pLabelLess;
        mRequired = pRequired;
        mHints = Objects.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 Objects.areNonArraysEqual( this.mUniqueID, pThem.mUniqueID ) && //
               Objects.areNonArraysEqual( this.mAttributeReference, pThem.mAttributeReference ) && //
               Objects.areNonArraysEqual( this.mIntendedUse, pThem.mIntendedUse ) && //
               UtilsCommon.areNonArraysEqual( this.isDisabled(), pThem.isDisabled() ) && //
               UtilsCommon.areNonArraysEqual( this.mLabelLess, pThem.mLabelLess ) && //
               Objects.areNonArraysEqual( this.mRequired, pThem.mRequired ) && //
               Objects.areArraysEqual( 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();
    }
}