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

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;

@SuppressWarnings("deprecation")
public class LL_FloatingPointLong<T extends LL_FloatingPointLong<T>> extends CompareSupport<T> implements SimpleType
{
    protected /* final */ long mValue;
    protected /* final */ int mDecimalPlaces;

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

    public LL_FloatingPointLong( long pValue, int pDecimalPlaces )
    {
        mValue = pValue;
        mDecimalPlaces = pDecimalPlaces;
    }

    public long getLongValue()
    {
        return mValue;
    }

    public int getDecimalPlaces()
    {
        return mDecimalPlaces;
    }

    @SuppressWarnings("unchecked") @Override
    public boolean equals( Object o )
    {
        return (this == o) || //
               ((o instanceof LL_FloatingPointLong<?>) && equalsNonNull( (LL_FloatingPointLong<T>) o ));
    }

    public boolean equals( LL_FloatingPointLong<T> them )
    {
        return (this == them) || //
               ((them != null) //
                && equalsNonNull( them ) //
               );
    }

    private boolean equalsNonNull( LL_FloatingPointLong<T> them )
    {
        int maxDecimals = Math.max( this.mDecimalPlaces, them.mDecimalPlaces );
        return adjustDecimalPlacesFromTo( this.mValue, this.mDecimalPlaces, maxDecimals ) == //
               adjustDecimalPlacesFromTo( them.mValue, them.mDecimalPlaces, maxDecimals );
    }

    @Override
    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mValue ), //
                           calcHashCode( mDecimalPlaces ) );
    }

    public int compareTo( T them )
    {
        int maxDecimals = Math.max( this.mDecimalPlaces, them.mDecimalPlaces );
        return compare( adjustDecimalPlacesFromTo( this.mValue, this.mDecimalPlaces, maxDecimals ), //
                        adjustDecimalPlacesFromTo( them.mValue, them.mDecimalPlaces, maxDecimals ) );
    }

    protected static long adjustDecimalPlacesFromTo( long pValue, int pCurDecimals, int pNewDecimals )
    {
        for (; pNewDecimals > pCurDecimals; pCurDecimals++ )
        {
            pValue *= 10L;
        }
        for (; pNewDecimals < pCurDecimals; pCurDecimals-- )
        {
            pValue /= 10L;
        }
        return pValue;
    }

    public void minimizeDecimalPlaces()
    {
        for (; mDecimalPlaces < 0; mDecimalPlaces++ )
        {
            mValue *= 10L;
        }
        for (; mDecimalPlaces > 0; mDecimalPlaces-- )
        {
            long pValue = mValue / 10L;
            if ( mValue != (pValue * 10L) )
            {
                return;
            }
            mValue = pValue;
        }
    }

    @Override
    public String toString()
    {
        return toRawString();
    }

    public String toRawString()
    {
        return getToStringParts().toString();
    }

    protected DecimalToStringParts getToStringParts()
    {
        return new DecimalToStringParts( mValue, mDecimalPlaces );
    }

    @SuppressWarnings("deprecation")
    public static <T extends LL_FloatingPointLong<T>> LL_FloatingPointLong<T> LLparse( NumericFormatControl pFormatControl, String pString )
    {
        int decimalplaces = 0;
        long value;
        boolean negate = false;
        if ( pFormatControl == null )
        {
            pFormatControl = NumericFormatControl.JUST_DOT;
        }
        char zDecimalSeparator = pFormatControl.getDecimalSeparator();
        char zThousandsSeparator = pFormatControl.getThousandsSeparator();
        if ( (zThousandsSeparator == 0) && (zDecimalSeparator != ',') )
        {
            zThousandsSeparator = ',';
        }
        String str = pString = Strings.noEmpty( pString );
        if ( str == null )
        {
            return null;
        }
        if ( str.startsWith( "+" ) )
        {
            str = str.substring( 1 ).trim();
        }
        else if ( pString.endsWith( "+" ) )
        {
            str = str.substring( 0, str.length() - 1 ).trim();
        }
        else if ( str.startsWith( "-" ) )
        {
            negate = true;
            str = str.substring( 1 ).trim();
        }
        else if ( pString.endsWith( "-" ) )
        {
            negate = true;
            str = str.substring( 0, str.length() - 1 ).trim();
        }
        int decimalAt = str.indexOf( zDecimalSeparator );
        if ( decimalAt == -1 )
        {
            str = clean( str, zThousandsSeparator );
        }
        else
        {
            String fractional = clean( str.substring( decimalAt + 1 ), zThousandsSeparator );
            str = clean( str.substring( 0, decimalAt ), zThousandsSeparator ) + fractional;
            decimalplaces = fractional.length();
        }
        try
        {
            value = Long.parseLong( str );
        }
        catch ( NumberFormatException e )
        {
            throw new IllegalArgumentException( "Unable to parse '" + pString + "', " + e.getMessage() );
        }
        return new LL_FloatingPointLong<T>( negate ? -value : value, decimalplaces );
    }

    private static String clean( String pStr, char pThousandsSeparator )
    {
        for ( int at; -1 != (at = pStr.indexOf( pThousandsSeparator )); )
        {
            pStr = pStr.substring( 0, at ) + pStr.substring( at + 1 );
        }
        return pStr;
    }

    // todo: Math support...
}