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

import java.io.*;

import org.litesoft.core.typeutils.*;

public class ObjectUniqueKey implements Serializable
{
    public static final String PREFIX = "+";

    static final long serialVersionUID = -1L;

    private Type mType;
    private String mID;

    @Deprecated
    protected ObjectUniqueKey()
    {
    }

    private ObjectUniqueKey( Type pType, Object pID )
    {
        mType = pType;
        mID = pType.validate( pID ).toString();
    }

    public static ObjectUniqueKey createExisting( Long pLong )
    {
        return new ObjectUniqueKey( Type.Long, pLong );
    }

    public static ObjectUniqueKey createNew( Long pLong )
    {
        return new ObjectUniqueKey( Type.NewLong, pLong );
    }

    public static ObjectUniqueKey createExisting( String pString )
    {
        return new ObjectUniqueKey( Type.String, pString );
    }

    public static ObjectUniqueKey createNew( String pString )
    {
        return new ObjectUniqueKey( Type.NewString, pString );
    }

    public Type getType()
    {
        return mType;
    }

    public String getID()
    {
        return mID;
    }

    public Object getParsedID()
    {
        return mType.parse( mID );
    }

    public boolean isForNewObject()
    {
        return mType.isForNew();
    }

    public final boolean equals( Object pThem )
    {
        return (this == pThem) || ((pThem instanceof ObjectUniqueKey) && equalsNotNullNotUs( (ObjectUniqueKey) pThem ));
    }

    public final boolean equals( ObjectUniqueKey pThem )
    {
        return (this == pThem) || ((pThem != null) && equalsNotNullNotUs( pThem ));
    }

    private boolean equalsNotNullNotUs( ObjectUniqueKey pThem )
    {
        return this.mType.equals( pThem.mType ) && this.mID.equals( pThem.mID );
    }

    public final int hashCode()
    {
        return 31 * mType.hashCode() + mID.hashCode();
    }

    public final String toString()
    {
        return PREFIX + mType.getTypeID() + mID;
    }

    public static ObjectUniqueKey fromString( String pToString )
            throws IllegalArgumentException
    {
        String zTypeStr = "";
        if ( pToString != null )
        {
            if ( (pToString = pToString.trim()).startsWith( PREFIX ) )
            {
                String zRest = pToString.substring( PREFIX.length() ).trim();
                for ( Type zType : Type.values() )
                {
                    String zTypeID = zType.getTypeID();
                    if ( zRest.startsWith( zTypeID ) )
                    {
                        zTypeStr = zType.toString() + " ";
                        Object zID = zType.parse( zRest.substring( zTypeID.length() ) );
                        if ( zID != null )
                        {
                            return new ObjectUniqueKey( zType, zID );
                        }
                    }
                }
            }
        }
        throw new IllegalArgumentException( "Unacceptable encoding of " + zTypeStr + "ObjectUniqueKey: '" + pToString + "'" );
    }

    public enum Type
    {
        Long( Long.class, "L", false )
                {
                    public Object validate( Object pID )
                    {
                        return validateLong( pID );
                    }

                    public Object parse( String pID )
                    {
                        return parseLong( pID );
                    }
                },
        NewLong( Long.class, "L", true )
                {
                    public Object validate( Object pID )
                    {
                        return validateLong( pID );
                    }

                    public Object parse( String pID )
                    {
                        return parseLong( pID );
                    }
                },
        String( String.class, "S", false )
                {
                    public Object validate( Object pID )
                    {
                        return validateString( pID );
                    }

                    public Object parse( String pID )
                    {
                        return parseString( pID );
                    }
                },
        NewString( String.class, "S", true )
                {
                    public Object validate( Object pID )
                    {
                        return validateString( pID );
                    }

                    public Object parse( String pID )
                    {
                        return parseString( pID );
                    }
                };

        private Class<?> mType;
        private String mTypeID;
        private boolean mForNew;

        private Type( Class<?> pType, String pTypeID, boolean pForNew )
        {
            mType = pType;
            mTypeID = (pForNew ? "!" + pTypeID + ":" : pTypeID + ":");
            mForNew = pForNew;
        }

        /**
         * @return the {@link Class#getName()} of the type
         */
        public Class<?> getType()
        {
            return mType;
        }

        public String getTypeID()
        {
            return mTypeID;
        }

        public boolean isForNew()
        {
            return mForNew;
        }

        abstract public Object validate( Object pID );

        abstract public Object parse( String pID );

        public String validateString( Object pID )
        {
            if ( pID instanceof String )
            {
                String zID = (String) pID;
                if ( (zID = zID.trim()).length() != 0 )
                {
                    return zID;
                }
            }
            throw new IllegalArgumentException( "Unacceptable ObjectUniqueKey ID, expected a String. but was: " + Objects.justClassNameOf( pID ) );
        }

        public String parseString( String pID )
        {
            if ( pID != null )
            {
                if ( (pID = pID.trim()).length() != 0 )
                {
                    return pID;
                }
            }
            return null;
        }

        public Long validateLong( Object pID )
        {
            if ( pID instanceof Long )
            {
                return (Long) pID;
            }
            throw new IllegalArgumentException( "Unacceptable ObjectUniqueKey ID, expected a Long. but was: " + Objects.justClassNameOf( pID ) );
        }

        public Long parseLong( String pID )
        {
            if ( pID != null )
            {
                if ( (pID = pID.trim()).length() != 0 )
                {
                    try
                    {
                        return new Long( pID );
                    }
                    catch ( NumberFormatException e )
                    {
                        // fall thru...
                    }
                }
            }
            return null;
        }
    }
}