// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.core.simpletypes.temporal.nonpublic;

import java.io.*;

public class AbstractRes implements Comparable,
                                    Serializable
{
    @Override
    public String toString()
    {
        return mName;
    }

    private /* final */ String mName;
    private /* final */ String mFriendlyName;
    private /* final */ int mIndex;
    private /* final */ char mIndicator;

    @SuppressWarnings("deprecation") @Deprecated /** for Serialization */
    protected AbstractRes()
    {
    }

    protected AbstractRes( String pName, String pFriendlyName, int pIndex, char pIndicator )
    {
        mIndex = pIndex;
        mFriendlyName = pFriendlyName;
        mName = pName;
        mIndicator = pIndicator;
    }

    public String getFriendlyName()
    {
        return mFriendlyName;
    }

    public int getIndex()
    {
        return mIndex;
    }

    public char getIndicator()
    {
        return mIndicator;
    }

    @Override
    public int compareTo( Object o )
    {
        AbstractRes them = (AbstractRes) o;
        return this.mIndex - them.mIndex;
    }

    @Override
    public boolean equals( Object o )
    {
        return (this == o) || //
               ((o instanceof AbstractRes) && equals( (AbstractRes) o ));
    }

    public boolean equals( AbstractRes them )
    {
        return (this == them) || //
               ((them != null) //
                && this.mName.equals( them.mName ) //
               );
    }

    @Override
    public int hashCode()
    {
        return mName.hashCode();
    }

    public String desicate()
    {
        return mName;
    }

    protected static AbstractRes LLrehydrate( String pWhat, AbstractRes[] pOptions, String pDesiccated )
            throws IllegalArgumentException
    {
        for ( AbstractRes zRes : pOptions )
        {
            if ( zRes.mName.equalsIgnoreCase( pDesiccated ) )
            {
                return zRes;
            }
        }
        StringBuilder sb = new StringBuilder();
        sb.append( "Unable to " ).append( pWhat ).append( ".rehydrate( " );
        sb.append( '"' ).append( pDesiccated ).append( '"' ).append( " ), valid options are: " );
        sb.append( pOptions[0] );
        for ( int i = 1; i < pOptions.length; i++ )
        {
            sb.append( ", " ).append( pOptions[i] );
        }
        throw new IllegalArgumentException( sb.toString() );
    }

    protected static AbstractRes LLfromIndex( AbstractRes[] pOptions, int pIndex )
    {
        int i = 0;
        AbstractRes zRes;
        do
        {
            zRes = pOptions[i];
            if ( pIndex == zRes.getIndex() )
            {
                break;
            }
        }
        while ( ++i < pOptions.length );
        return zRes;
    }
}