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

abstract class NoEqualsBase<E, C extends Comparable<C>>
{
    protected final NoEqualsHelper<E, C> mHelper;

    protected NoEqualsBase( NoEqualsHelper<E, C> pHelper )
    {
        mHelper = pHelper;
    }

    @SuppressWarnings({"unchecked"})
    protected class Wrapper implements Comparable<Wrapper>
    {
        private final E mObjectWithProxyValue;

        public Wrapper( E pObjectWithProxyValue )
        {
            mObjectWithProxyValue = pObjectWithProxyValue;
        }

        public E getObject()
        {
            return mObjectWithProxyValue;
        }

        public C getProxyValue()
        {
            return mHelper.getProxyValue( mObjectWithProxyValue );
        }

        @Override
        public boolean equals( Object obj )
        {
            return (obj instanceof Wrapper) && equals( (Wrapper) obj );
        }

        public boolean equals( Wrapper them )
        {
            return (them != null) && areEqual( mHelper.getProxyValue( this.mObjectWithProxyValue ), mHelper.getProxyValue( them.mObjectWithProxyValue ) );
        }

        @Override
        public int hashCode()
        {
            Comparable<?> zProxyValue = mHelper.getProxyValue( mObjectWithProxyValue );
            return (zProxyValue == null) ? 0 : zProxyValue.hashCode();
        }

        @Override
        public int compareTo( Wrapper them )
        {
            return compare( mHelper.getProxyValue( this.mObjectWithProxyValue ), mHelper.getProxyValue( them.mObjectWithProxyValue ) );
        }

        @Override
        public String toString()
        {
            return mObjectWithProxyValue.toString();
        }

        /**
         * @return >0, 0, <0 as pThis > pThem, pThis == pThem, pThis < pThem
         */
        private int compare( C pThis, C pThem )
        {
            if ( pThis == pThem )
            {
                return 0; // the same (or both null)
            }
            if ( pThis == null ) // null - !null
            {
                return -1;
            }
            if ( pThem == null ) // !null - null
            {
                return 1;
            }
            return pThis.compareTo( pThem );
        }
    }

    protected Wrapper wrap( E pObject )
    {
        return new Wrapper( pObject );
    }

    protected E unwrap( Wrapper pWrapper )
    {
        return (pWrapper != null) ? pWrapper.mObjectWithProxyValue : null;
    }

    protected Wrapper wrapNotNull( E pObject )
    {
        validateNotNull( pObject );
        return wrap( pObject );
    }

    protected void validateNotNull( Object o )
    {
        if ( o == null )
        {
            throw new NullPointerException();
        }
    }

    protected E castNotNull( Object o )
    {
        validateNotNull( o );
        if ( mHelper.isInstance( o ) )
        {
            return castNullOK( o );
        }
        throw new ClassCastException( "Unexpected object type '" + o.getClass() + "', expected '" + mHelper.getObjectType() + "' from object: " + o );
    }

    protected E castNullOK( Object o )
    {
        return cast( o );
    }

    @SuppressWarnings({"unchecked"})
    protected <T> T cast( Object o )
    {
        return (T) o;
    }

    protected static boolean areEqual( Object p1, Object p2 )
    {
        return (p1 == p2) || ((p1 != null) && p1.equals( p2 ));
    }

    protected static final Wrapper[] EMPTY_ARRAY = new Wrapper[0];
}