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

import org.litesoft.commonfoundation.base.*;

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 static final class Wrapper<E, C extends Comparable<C>> implements Comparable<Wrapper<E, C>>
    {
        private final NoEqualsHelper<E, C> mHelper;
        private final E mObjectWithProxyValue;

        public Wrapper( NoEqualsHelper<E, C> pHelper, E pObjectWithProxyValue )
        {
            mHelper = pHelper;
            mObjectWithProxyValue = pObjectWithProxyValue;
        }

        public E getObject()
        {
            return mObjectWithProxyValue;
        }

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

        @Override
        public boolean equals( Object them )
        {
            return (this == them) || ((them != null) && //
                                      this.getClass().equals( them.getClass() ) && //
                                      LLNotNullEquals( (Wrapper<E, C>) them ));
        }

        public boolean equals( Wrapper<E, C> them )
        {
            return (this == them) || ((them != null) && //
                                      LLNotNullEquals( them ));
        }

        private boolean LLNotNullEquals( Wrapper<E, C> them )
        {
            return areEqual( this.getProxyValue(), them.getProxyValue() );
        }

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

        @Override
        public int compareTo( Wrapper<E, C> them )
        {
            return compare( this.getProxyValue(), them.getProxyValue() );
        }

        @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 );
        }
    }

    @SuppressWarnings("unchecked")
    protected Wrapper<E, C>[] array( int pSize )
    {
        return new Wrapper[pSize];
    }

    protected Wrapper<E, C> wrap( E pObject )
    {
        return new Wrapper<E, C>( mHelper, pObject );
    }

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

    protected Wrapper<E, C> 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.it( o );
    }

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