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

import org.litesoft.core.typeutils.Objects;

import java.util.*;

/**
 * SimpleMessage is similar to MessageFormat in that it utilizes {} to identify the substitution positions
 * and index of the parameters.  It differs in that nothing but simple indexes are supported and if no substitutions
 * are indicated, then "{0} " is added to the front, and all other parameters are added to the end.<p>
 * <p/>
 * The following example creates a <code>MessageFormat</code> instance that
 * can be used repeatedly:
 * <blockquote><pre>
 * int fileCount = 1273;
 * String diskName = "MyDisk";
 * Object[] testArgs = {new Long(fileCount), diskName};
 * <p/>
 * MessageFormat form = new MessageFormat(
 *     "The disk \"{1}\" contains {0} file(s).");
 */
public class SimpleMessage
{
    public static final char START_SUB = '{';
    public static final char END_SUB = '}';

    public static String format( String pPattern, Object... pParameters )
    {
        if ( pPattern == null )
        {
            pPattern = "?";
        }
        AbstractFormatter zFormatter;
        synchronized ( sCached )
        {
            if ( null == (zFormatter = sCached.get( pPattern )) )
            {
                sCached.put( pPattern, zFormatter = createFormatter( pPattern ) );
            }
        }
        return zFormatter.format( pParameters );
    }

    private static final Map<String, AbstractFormatter> sCached = new HashMap<String, AbstractFormatter>();

    private static String getParam( Object[] pParameters, int pIndex )
    {
        return (pParameters != null) && (0 <= pIndex) && (pIndex < pParameters.length) ? Objects.toString( pParameters[pIndex] ) : "";
    }

    private static interface AbstractFormatter
    {
        abstract public String format( Object[] pParameters );
    }

    private static class NoSubsFormatter implements AbstractFormatter
    {
        private String mPattern;

        protected NoSubsFormatter( String pPattern )
        {
            mPattern = pPattern;
        }

        @Override
        public String format( Object[] pParameters )
        {
            if ( Objects.isNullOrEmpty( pParameters ) )
            {
                return mPattern;
            }
            StringBuilder sb = new StringBuilder();
            sb.append( getParam( pParameters, 0 ) ).append( ' ' ).append( mPattern );
            for ( int i = 1; i < pParameters.length; i++ )
            {
                sb.append( ' ' ).append( getParam( pParameters, i ) );
            }
            return sb.toString();
        }
    }

    private static class PartsFormatter implements AbstractFormatter
    {
        private Part[] mParts;

        protected PartsFormatter( Part[] pParts )
        {
            mParts = pParts;
        }

        @Override
        public String format( Object[] pParameters )
        {
            StringBuilder sb = new StringBuilder();
            for ( Part part : mParts )
            {
                sb.append( part.get( pParameters ) );
            }
            return sb.toString();
        }
    }

    private interface Part
    {
        String get( Object[] pParameters );
    }

    private static class StringPart implements Part
    {
        private String mString;

        public StringPart( String pString )
        {
            mString = pString;
        }

        @Override
        public String get( Object[] pParameters )
        {
            return mString;
        }
    }

    private static class ParamPart implements Part
    {
        private int mIndex;

        public ParamPart( int pIndex )
        {
            mIndex = pIndex;
        }

        @Override
        public String get( Object[] pParameters )
        {
            return getParam( pParameters, mIndex );
        }
    }

    private static final Map<String, StringPart> sStringParts = new HashMap<String, StringPart>();
    private static final Map<Integer, ParamPart> sParamParts = new HashMap<Integer, ParamPart>();

    private static StringPart getStringPart( String pString )
    {
        StringPart rv = sStringParts.get( pString );
        if ( rv == null )
        {
            sStringParts.put( pString, rv = new StringPart( pString ) );
        }
        return rv;
    }

    private static ParamPart parse( String pIndex )
    {
        try
        {
            Integer index = Integer.valueOf( pIndex );
            ParamPart rv = sParamParts.get( index );
            if ( rv == null )
            {
                sParamParts.put( index, rv = new ParamPart( index ) );
            }
            return rv;
        }
        catch ( NumberFormatException e )
        {
            return null;
        }
    }

    private static AbstractFormatter createFormatter( String pPattern )
    {
        int sAT = pPattern.indexOf( START_SUB );
        int eAT = pPattern.indexOf( END_SUB, sAT + 1 );
        if ( (sAT == -1) || (eAT == -1) )
        {
            return new NoSubsFormatter( pPattern );
        }

        List<Part> zParts = new ArrayList<Part>();

        StringBuilder sb = new StringBuilder();
        do
        {
            sb.append( pPattern.substring( 0, sAT ) );
            String index = pPattern.substring( sAT + 1, eAT );
            ParamPart part = parse( index );
            if ( part == null )
            {
                sb.append( START_SUB ).append( index ).append( END_SUB );
            }
            else
            {
                zParts.add( getStringPart( sb.toString() ) );
                sb = new StringBuilder();
                zParts.add( part );
            }
            pPattern = pPattern.substring( eAT + 1 );
            sAT = pPattern.indexOf( START_SUB );
            eAT = pPattern.indexOf( END_SUB, sAT + 1 );
        }
        while ( (sAT != -1) && (eAT != -1) );

        String restOfString = sb.append( pPattern ).toString();

        if ( zParts.isEmpty() )
        {
            return new NoSubsFormatter( restOfString );
        }

        zParts.add( getStringPart( restOfString ) );

        return new PartsFormatter( zParts.toArray( new Part[zParts.size()] ) );
    }
}