// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.aokeyhole.objects.support;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

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

    @Override
    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 = Strings.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 ? Strings.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;
        }
    };
}