package org.litesoft.aokeyhole.objects.support;

import java.util.*;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.core.util.*;

public abstract class StringArrayValueStringConverter implements ValueStringConverter
{
    public Object validateAndNormalize( Object pValue )
            throws ParseException
    {
        return parse( pValue );
    }

    public String valueToString( Object pValue )
    {
        if ( pValue == null )
        {
            return "";
        }
        return (pValue instanceof String) ? (String) pValue : join( (String[]) pValue );
    }

    public Object parse( Object pValue )
            throws ParseException
    {
        if ( pValue == null )
        {
            return pValue;
        }
        if ( pValue instanceof String )
        {
            return validateEntries( split( (String) pValue ) );
        }
        if ( pValue instanceof String[] )
        {
            return validateEntries( (String[]) pValue );
        }
        throw new ParseException( "" + pValue + " is not a String Array" );
    }

    /**
     * Will remove all leading and trailing blank entries
     */
    private String[] validateEntries( String[] pEntries )
    {
        if ( (pEntries != null) && (pEntries.length != 0) )
        {
            int addBlanks = 0;
            List<String> zOptions = new ArrayList<String>( pEntries.length );
            for ( String zEntry : pEntries )
            {
                zEntry = validateEntry( zEntry );
                if ( zEntry != null )
                {
                    if ( zEntry.indexOf( '\n' ) != -1 )
                    {
                        throw new ParseException( "Array Entry may not be multi-lined" );
                    }
                    if ( zEntry.indexOf( '|' ) != -1 )
                    {
                        throw new ParseException( "Array Entry may not contain '|' as it is entry seperator" );
                    }
                    if ( zEntry.length() != 0 )
                    {
                        for (; addBlanks > 0; addBlanks-- )
                        {
                            zOptions.add( "" );
                        }
                        zOptions.add( zEntry );
                    }
                    else if ( !zOptions.isEmpty() )
                    {
                        addBlanks++;
                    }
                }
            }
            if ( !zOptions.isEmpty() )
            {
                return zOptions.toArray( new String[zOptions.size()] );
            }
        }
        return null;
    }

    abstract protected String validateEntry( String pOption );

    private String join( String[] pStrings )
    {
        if ( pStrings.length == 0 )
        {
            return null;
        }
        int len = -1;
        for ( String string : pStrings )
        {
            len += 1 + string.length();
        }
        StringBuilder sb = new StringBuilder( len );
        sb.append( pStrings[0] );
        for ( int i = 1; i < pStrings.length; i++ )
        {
            sb.append( '|' );
            sb.append( pStrings[i] );
        }
        return sb.toString();
    }

    public String[] split( String pString )
    {
        if ( pString != null )
        {
            if ( (pString = UtilsCommon.trimTrailingSpaces( pString )).length() != 0 )
            {
                return splitOn( pString, (pString.indexOf( '\n' ) != -1) ? '\n' : '|' );
            }
        }
        return null;
    }

    private static String[] splitOn( String pString, char pSeperator )
    {
        List<String> collector = new ArrayList<String>();
        int from = 0;
        for ( int at; -1 != (at = pString.indexOf( pSeperator, from )); from = at + 1 )
        {
            collector.add( pString.substring( from, at ) );
        }
        collector.add( pString.substring( from ) );
        return collector.toArray( new String[collector.size()] );
    }

    public static StringArrayValueStringConverter TRIM_TRAILING = new StringArrayValueStringConverter()
    {
        @Override
        protected String validateEntry( String pOption )
        {
            return pOption != null ? UtilsCommon.trimTrailingSpaces( pOption ) : null;
        }
    };

    public static StringArrayValueStringConverter TRIM_DROP_EMPTY = new StringArrayValueStringConverter()
    {
        @Override
        protected String validateEntry( String pOption )
        {
            if ( pOption != null )
            {
                if ( (pOption = pOption.trim()).length() != 0 )
                {
                    return pOption;
                }
            }
            return null;
        }
    };
}