// 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.*;

public class DecimalToStringParts
{
    private static final String PLUS = "+";
    private static final String MINUS = "-";

    private String mNegative = "";
    private String mWholePart;
    private String mFractionPart = "";

    public DecimalToStringParts( long pValue )
    {
        this( pValue, 0 );
    }

    public DecimalToStringParts( long pValue, int pDecimalPlaces )
    {
        if ( pValue < 0 )
        {
            mNegative = MINUS;
            pValue = -pValue;
        }
        String vStr = Long.toString( pValue );
        if ( pDecimalPlaces <= 0 )
        {
            mWholePart = vStr;
        }
        else
        {
            while ( vStr.length() <= pDecimalPlaces )
            {
                vStr = "0" + vStr;
            }
            int zDPat = vStr.length() - pDecimalPlaces;
            mWholePart = vStr.substring( 0, zDPat );
            mFractionPart = vStr.substring( zDPat );
        }
    }

    public DecimalToStringParts( String pValue, char pDecimalSeparator )
            throws IllegalArgumentException
    {
        String str = Strings.deNull( pValue ).trim();
        if ( str.startsWith( PLUS ) )
        {
            str = validate( str, PLUS, str.substring( 1 ), "started" );
        }
        else if ( str.startsWith( MINUS ) )
        {
            str = validate( str, mNegative = MINUS, str.substring( 1 ), "started" );
        }
        else if ( str.endsWith( PLUS ) )
        {
            str = validate( str, PLUS, str.substring( 0, str.length() - 1 ), "ended" );
        }
        else if ( str.endsWith( MINUS ) )
        {
            str = validate( str, mNegative = MINUS, str.substring( 0, str.length() - 1 ), "ended" );
        }
        StringBuilder sb = new StringBuilder();
        int zDPcnt = 0;
        for ( int i = 0; i < str.length(); i++ )
        {
            char c = str.charAt( i );
            if ( Character.isDigit( c ) )
            {
                sb.append( c );
            }
            else if ( c == pDecimalSeparator )
            {
                sb.append( c );
                if ( ++zDPcnt > 1 )
                {
                    throw new IllegalArgumentException( "2 '" + pDecimalSeparator + "' found in: " + pValue );
                }
            }
            else if ( Character.isLetter( c ) )
            {
                throw new IllegalArgumentException( "Unable to parse '" + c + "' found in: " + pValue );
            }
            // Ignore everything else
        }
        if ( zDPcnt == 0 )
        {
            sb.append( pDecimalSeparator );
        }
        str = sb.toString();
        int zDPat = str.indexOf( pDecimalSeparator );
        mWholePart = str.substring( 0, zDPat );
        mFractionPart = str.substring( zDPat + 1 );
        if ( mWholePart.length() == 0 )
        {
            if ( mFractionPart.length() == 0 )
            {
                throw new IllegalArgumentException( "Unable to parse, No digits found in: " + pValue );
            }
            mWholePart = "0";
        }
    }

    public DecimalToStringParts forceDecimalPlaces( Integer pDecimalPlaces, boolean pSilentlyTruncate )
            throws IllegalArgumentException
    {
        if ( pDecimalPlaces != null )
        {
            int zDPdesired = Math.abs( pDecimalPlaces.intValue() );
            if ( zDPdesired > 20 )
            {
                zDPdesired = 20;
            }
            while ( mFractionPart.length() < zDPdesired )
            {
                mFractionPart += "0";
            }
            int i = mFractionPart.length();
            if ( i > zDPdesired )
            {
                if ( !pSilentlyTruncate )
                {
                    for (; i > zDPdesired; i-- )
                    {
                        if ( mFractionPart.charAt( i - 1 ) != '0' )
                        {
                            throw new IllegalArgumentException( "Unable to reduce decimal places to " + zDPdesired + " places, precision lost" );
                        }
                    }
                }
                mFractionPart = (zDPdesired == 0) ? "" : mFractionPart.substring( 0, zDPdesired );
            }
        }
        return this;
    }

    public String getNegative()
    {
        return mNegative;
    }

    public String getWholePart()
    {
        return mWholePart;
    }

    public String getFractionPart()
    {
        return mFractionPart;
    }

    public String toString()
    {
        return (mFractionPart.length() == 0) ? //
               mNegative + mWholePart : //
               mNegative + mWholePart + "." + mFractionPart;
    }

    public String toString( NumericFormatControl pFormatControl )
    {
        if ( pFormatControl == null )
        {
            return toString();
        }
        String zWholePart = mWholePart;
        String zFractionPart = mFractionPart;
        char zThousandsSeparator = pFormatControl.getThousandsSeparator();
        if ( zThousandsSeparator != 0 )
        {
            zWholePart = injectFromEnd( zWholePart, zThousandsSeparator );
            if ( pFormatControl.isSeparateFractionalThousands() )
            {
                zFractionPart = injectFromStart( zFractionPart, zThousandsSeparator );
            }
        }
        return (zFractionPart.length() == 0) ? //
               mNegative + zWholePart : //
               mNegative + zWholePart + pFormatControl.getDecimalSeparator() + zFractionPart;
    }

    private String injectFromStart( String pPart, char pThousandsSeparator )
    {
        if ( pPart.length() <= 3 )
        {
            return pPart;
        }
        StringBuilder sb = new StringBuilder( pPart );
        for ( int i = 3; i < sb.length(); i += 3 )
        {
            sb.insert( i++, pThousandsSeparator );
        }
        return sb.toString();
    }

    private String injectFromEnd( String pPart, char pThousandsSeparator )
    {
        if ( pPart.length() <= 3 )
        {
            return pPart;
        }
        StringBuilder sb = new StringBuilder( pPart );
        for ( int i = sb.length() - 3; i > 0; i -= 3 )
        {
            sb.insert( i, pThousandsSeparator );
        }
        return sb.toString();
    }

    private String validate( String pOrig, String pChar, String pData, String pWhy )
    {
        String zWhyPlus;
        if ( pData.indexOf( pChar ) != -1 )
        {
            zWhyPlus = "an additional '" + pChar + "'";
        }
        else
        {
            String zOther = PLUS.equals( pChar ) ? MINUS : PLUS;
            if ( pData.indexOf( zOther ) == -1 )
            {
                return pData.trim();
            }
            zWhyPlus = "a '" + zOther + "'";
        }
        throw new IllegalArgumentException( "Unable to parse \"" + pOrig + "\", it " + pWhy + " with '" + pChar + "' and contained " + zWhyPlus );
    }
}