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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;

/**
 * @noinspection EqualsAndHashcode, deprecation
 */
public abstract class AbstractXY<T extends AbstractXY> extends CompareSupport<T> implements SimpleType
{
    private /* final */ int mX, mY;

    @SuppressWarnings({"deprecation", "UnusedDeclaration"}) @Deprecated /** for Serialization */
    protected AbstractXY()
    {
    }

    protected AbstractXY( int pX, int pY )
    {
        mX = validate( "X", pX );
        mY = validate( "Y", pY );
    }

    public int getX()
    {
        return mX;
    }

    public int getY()
    {
        return mY;
    }

    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mX ), //
                           calcHashCode( mY ) );
    }

    protected boolean LLequals( AbstractXY them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mX, them.mX ) //
                && equal( this.mY, them.mY ) //
               );
    }

    /**
     * Row (Y) then Column (X)
     */
    protected int LLcompareTo( AbstractXY them )
    {
        return compareEm( compare( this.mY, them.mY ), //
                          compare( this.mX, them.mX ) );
    }

    abstract protected int validate( String pWhat, int pValue );

    private static IllegalArgumentException populateProblem( String pWhat, String pWhy )
    {
        return new IllegalArgumentException( pWhat + "XY from string value" + pWhy );
    }

    private static int parseValue( String pWhat, String pXorY, String pValue )
    {
        if ( (pValue = pValue.trim()).length() == 0 )
        {
            throw populateProblem( pWhat, ": did not have a '" + pXorY + "' value" );
        }
        try
        {
            return Integer.parseInt( pValue );
        }
        catch ( NumberFormatException e )
        {
            throw populateProblem( pWhat, ", '" + pXorY + "' value: " + e.getMessage() );
        }
    }

    protected T copyParse( String pWhat, String pToString )
    {
        if ( pToString == null )
        {
            throw populateProblem( pWhat, Objects.NOT_ALLOWED_TO_BE_NULL );
        }
        pToString = pToString.trim();
        if ( !pToString.startsWith( "(" ) )
        {
            throw populateProblem( pWhat, ": did not start with '('" );
        }
        if ( !pToString.startsWith( "(" ) )
        {
            throw populateProblem( pWhat, ": did not end with ')'" );
        }
        int zCommaAt = pToString.indexOf( ',' );
        if ( zCommaAt == -1 )
        {
            throw populateProblem( pWhat, ": No X-Y sep ','" );
        }
        return copy( parseValue( pWhat, "X", pToString.substring( 1, zCommaAt ) ),
                     parseValue( pWhat, "Y", pToString.substring( zCommaAt + 1, pToString.length() - 1 ) ) );
    }

    private T copy( int pX, int pY )
    {
        return Cast.it( ((pX == mX) && (pY == mY)) ? this : clone( pX, pY ) );
    }

    protected abstract AbstractXY clone( int pX, int pY );

    public String toString()
    {
        return "(" + mX + "," + mY + ")";
    }
}