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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.commonfoundation.charstreams.*;

/**
 * Convert Float value to/from a self-terminating string representation
 */
public abstract class AbstractNumericPartsTypedTerminatingCodec<T> extends AbstractTypedTerminatingCodec<T>
{
    private final String mType;
    private final List<NumericPart> mNumericParts = Lists.newArrayList();
    private final List<SeparatorPart> mSeparatorParts = Lists.newArrayList();

    protected AbstractNumericPartsTypedTerminatingCodec( String pType, Part... pParts )
    {
        mType = pType;
        for ( int i = 0; i < pParts.length; i++ )
        {
            Part zPart = pParts[i];
            if ( Integers.isEven( i ) )
            {
                mNumericParts.add( (NumericPart) zPart );
            }
            else
            {
                mSeparatorParts.add( (SeparatorPart) zPart );
            }
        }
    }

    protected void encodeParts( CharSink pCharSink, String pValue )
    {
        List<Integer> zNumericPartParsedValues = Lists.newArrayList();
        CharSourceFromSequence zCharSource = new CharSourceFromSequence( pValue );
        int zPart = 0;
        while ( zPart < mSeparatorParts.size() )
        {
            zNumericPartParsedValues.add( mNumericParts.get( zPart ).parse( mType, zCharSource ) );
            mSeparatorParts.get( zPart++ ).parse( mType, zCharSource );
        }
        zNumericPartParsedValues.add( mNumericParts.get( zPart ).parse( mType, zCharSource ) );
        for ( int i = zNumericPartParsedValues.size(); --i > 0; )
        {
            if ( zNumericPartParsedValues.get( i ) == 0 )
            {
                zNumericPartParsedValues.remove( i );
            }
        }
        IntegerTypedTerminatingCodec.NON_NEGATIVE.encode( pCharSink, zNumericPartParsedValues.size() - 1 );
        for ( int i = 0; i < zNumericPartParsedValues.size(); i++ )
        {
            mNumericParts.get( i ).encode( pCharSink, zNumericPartParsedValues.get( i ) );
        }
    }

    protected String decodeParts( CharSource pCharSource )
    {
        int zPartCount = IntegerTypedTerminatingCodec.NON_NEGATIVE.decode( pCharSource ) + 1;
        List<Integer> zNumericPartParsedValues = Lists.newArrayList();
        for ( int i = 0; i < zPartCount; i++ )
        {
            zNumericPartParsedValues.add( mNumericParts.get( i ).decode( pCharSource ) );
        }
        StringBuilder sb = new StringBuilder();
        int zPart = 0;
        while ( zPart < mSeparatorParts.size() )
        {
            mNumericParts.get( zPart ).format( sb, zNumericPartParsedValues );
            mSeparatorParts.get( zPart++ ).format( sb );
        }
        mNumericParts.get( zPart ).format( sb, zNumericPartParsedValues );
        return sb.toString();
    }

    protected interface Part
    {
    }

    protected static class SeparatorPart implements Part
    {
        private final char mSeparator;

        public SeparatorPart( char pSeparator )
        {
            mSeparator = pSeparator;
        }

        public void parse( String pType, CharSource pCharSource )
        {
            char zChar = pCharSource.getRequired();
            if ( zChar != mSeparator )
            {
                throw new IllegalArgumentException( "Parsing " + pType + ", Expected '" + mSeparator + "' but got a '" + zChar + "'" );
            }
        }

        public void format( StringBuilder pSB )
        {
            pSB.append( mSeparator );
        }
    }

    protected static SeparatorPart DASH = new SeparatorPart( '-' );
    protected static SeparatorPart SPACE = new SeparatorPart( ' ' );
    protected static SeparatorPart COLON = new SeparatorPart( ':' );
    protected static SeparatorPart PERIOD = new SeparatorPart( '.' );

    protected static class NumericPart implements Part
    {
        private final int mMinimumWidth;
        private final PrimitiveIntegerCodec mCodec;

        protected NumericPart( int pMinimumWidth, PrimitiveIntegerCodec pCodec )
        {
            mMinimumWidth = pMinimumWidth;
            mCodec = pCodec;
        }

        protected NumericPart( int pMinimumWidth )
        {
            this( pMinimumWidth, PrimitiveIntegerCodec.NON_NEGATIVE );
        }

        protected NumericPart()
        {
            this( 2 );
        }

        public void encode( CharSink pCharSink, int pInt )
        {
            mCodec.encode( pCharSink, pInt );
        }

        public int decode( CharSource pCharSource )
        {
            return mCodec.decode( pCharSource );
        }

        public int parse( String pType, CharSource pCharSource )
        {
            int zChar = pCharSource.getRequired();
            if ( !Characters.isNumeric( (char) zChar ) )
            {
                throw new IllegalArgumentException( "Parsing " + pType + ", Expected digit but got a '" + zChar + "'" );
            }
            int rv = zChar - '0';
            while ( -1 != (zChar = pCharSource.peek()) )
            {
                if ( !Characters.isNumeric( (char) zChar ) )
                {
                    break;
                }
                rv = (rv * 10) + (pCharSource.get() - '0');
            }
            return rv;
        }

        public void format( StringBuilder pSB, List<Integer> pNumericPartParsedValues )
        {
            pSB.append( Integers.zeroPadIt( mMinimumWidth, pNumericPartParsedValues.isEmpty() ? 0 : pNumericPartParsedValues.remove( 0 ) ) );
        }
    }
}