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

public class NumericFormatter
{
    private String mFormat;
    private NumericFormatPartHelper[] mToUndecorated;
    private NumericFormatPartHelper[] mToDecorated;

    /**
     * @deprecated for Serialization
     */
    protected NumericFormatter()
    {
    }

    public NumericFormatter( String pFormat, //
                             NumericFormatPartHelper[] pToUndecorated, NumericFormatPartHelper[] pToDecorated )
    {
        mFormat = pFormat;
        mToUndecorated = pToUndecorated;
        mToDecorated = pToDecorated;
    }

    public String decorate( String pValue )
    {
        return convert( pValue, mToDecorated );
    }

    public String undecorate( String pValue )
    {
        return convert( pValue, mToUndecorated );
    }

    public String getFormat()
    {
        return mFormat;
    }

    public String toString()
    {
        return "NumericFormatter( '" + getFormat() + "' )";
    }

    private String convert( String pValue, NumericFormatPartHelper[] pHelpers )
    {
        NFparsedparts zParts = parseInto( pValue );
        StringBuilder sb = new StringBuilder();
        for ( int i = 0; i < pHelpers.length; i++ )
        {
            NumericFormatPartHelper helper = pHelpers[i];
            helper.process( sb, zParts );
        }
        return sb.toString();
    }

    protected NFparsedparts parseInto( String pValue )
    {
        NFparsedparts zParts = new NFparsedparts();

        if ( pValue != null )
        {
            int dotIndex = pValue.indexOf( "." );

            if ( dotIndex >= 0 ) // Dot exists
            {
                if ( (pValue.length() - 1) > dotIndex ) // Numbers after dot exist
                {
                    zParts.setDecimalFound();

                    String beforeDot = pValue.substring( 0, dotIndex );
                    String afterDot = pValue.substring( dotIndex + 1 );

                    if ( beforeDot.length() == 0 )
                    {
                        beforeDot = "0";
                    }
                    if ( (beforeDot.length() == 1) && ("-".equals( beforeDot )) ) // Starts with minus-dot
                    {
                        if ( Integer.parseInt( afterDot ) > 0 )
                        {
                            beforeDot = beforeDot + "0";
                        }
                        else
                        {
                            beforeDot = "0";
                        }
                    }

                    parseBeforeDot( beforeDot, zParts );
                    parseAfterDot( afterDot, zParts );
                }
                else
                {
                    String zBeforeDot = pValue.substring( 0, dotIndex );
                    parseBeforeDot( zBeforeDot, zParts );
                }
            }
            else
            {
                if ( pValue.startsWith( "-" ) )
                {
                    String zVal = pValue.substring( 1 );
                    int zIntVal = Integer.parseInt( zVal );

                    if ( zIntVal > 0 )
                    {
                        parseBeforeDot( pValue, zParts );
                    }
                    else
                    {
                        parseBeforeDot( zVal, zParts );
                    }
                }
                else if ( pValue.length() == 0 )
                {
                    parseBeforeDot( "0", zParts );
                }
                else
                {
                    parseBeforeDot( pValue, zParts );
                }
            }
        }
        else
        {
            parseBeforeDot( "0", zParts );
        }

        return zParts;
    }

    private void parseBeforeDot( String pBeforeDot, NFparsedparts pParts )
    {
        char[] zChars = pBeforeDot.toCharArray();

        int zFirstDigit = 0;

        for ( int i = 0; i < zChars.length; i++ )
        {
            char zChar = zChars[i];
            if ( Character.isDigit( zChar ) )
            {
                zFirstDigit = i;
                break;
            }
        }

        String zBeforeDigits = pBeforeDot.substring( 0, zFirstDigit );
        String zDigitStr = pBeforeDot.substring( zFirstDigit );

        char[] zB4Digits = zBeforeDigits.toCharArray();
        for ( int i = 0; i < zB4Digits.length; i++ )
        {
            char zChar = zB4Digits[i];
            pParts.addBeforeAnyDigits( zChar );
        }

        char[] zDigits = zDigitStr.toCharArray();
        for ( int j = 0; j < zDigits.length; j++ )
        {
            char zDigit = zDigits[j];
            pParts.addWholeDigits( zDigit );
        }
    }

    private void parseAfterDot( String pAfterDot, NFparsedparts pParts )
    {
        char[] zChars = pAfterDot.toCharArray();

        for ( int i = 0; i < zChars.length; i++ )
        {
            char zChar = zChars[i];

            if ( !Character.isDigit( zChar ) )
            {
                pParts.addAfterAnyDigits( zChar );
            }
            else if ( Character.isDigit( zChar ) )
            {
                pParts.addFractionalDigits( zChar );
            }
        }
    }
}