package org.codehaus.plexus.interpolation;

/*
 * Copyright 2001-2008 Codehaus Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class StringSearchInterpolator
    implements Interpolator
{

    private Map<String,Object> existingAnswers = new HashMap<String,Object>();

    private List<ValueSource> valueSources = new ArrayList<ValueSource>();

    private List<InterpolationPostProcessor> postProcessors = new ArrayList<InterpolationPostProcessor>();

    private boolean cacheAnswers = false;

    public static final String DEFAULT_START_EXPR = "${";

    public static final String DEFAULT_END_EXPR = "}";

    private String startExpr;

    private String endExpr;

    private String escapeString;

    public StringSearchInterpolator()
    {
        this.startExpr = DEFAULT_START_EXPR;
        this.endExpr = DEFAULT_END_EXPR;
    }

    public StringSearchInterpolator( String startExpr, String endExpr )
    {
        this.startExpr = startExpr;
        this.endExpr = endExpr;
    }


    /**
     * {@inheritDoc}
     */
    public void addValueSource( ValueSource valueSource )
    {
        valueSources.add( valueSource );
    }

    /**
     * {@inheritDoc}
     */
    public void removeValuesSource( ValueSource valueSource )
    {
        valueSources.remove( valueSource );
    }

    /**
     * {@inheritDoc}
     */
    public void addPostProcessor( InterpolationPostProcessor postProcessor )
    {
        postProcessors.add( postProcessor );
    }

    /**
     * {@inheritDoc}
     */
    public void removePostProcessor( InterpolationPostProcessor postProcessor )
    {
        postProcessors.remove( postProcessor );
    }

    public String interpolate( String input, String thisPrefixPattern )
        throws InterpolationException
    {
        return interpolate( input, new SimpleRecursionInterceptor() );
    }

    public String interpolate( String input, String thisPrefixPattern, RecursionInterceptor recursionInterceptor )
        throws InterpolationException
    {
        return interpolate( input, recursionInterceptor );
    }

    public String interpolate( String input )
        throws InterpolationException
    {
        return interpolate( input, new SimpleRecursionInterceptor() );
    }

    /**
     * Entry point for recursive resolution of an expression and all of its
     * nested expressions.
     *
     * TODO: Ensure unresolvable expressions don't trigger infinite recursion.
     */
    public String interpolate( String input, RecursionInterceptor recursionInterceptor )
        throws InterpolationException
    {
        try
        {
            return interpolate( input, recursionInterceptor, new HashSet<String>() );
        }
        finally
        {
            if ( !cacheAnswers )
            {
                existingAnswers.clear();
            }
        }
    }

    private String interpolate( String input, RecursionInterceptor recursionInterceptor, Set<String> unresolvable )
        throws InterpolationException
    {
        if ( input == null )
        {
            // return empty String to prevent NPE too
            return "";
        }

        int startIdx;
        int endIdx = -1;
        if ( ( startIdx = input.indexOf( startExpr, endIdx + 1 ) ) > -1 )
        {
            StringBuilder result = new StringBuilder( input.length() * 2 );
            do
                {
                result.append( input, endIdx + 1, startIdx );

                endIdx = input.indexOf( endExpr, startIdx + 1 );
                if ( endIdx < 0 )
                {
                    break;
                }

                final String wholeExpr = input.substring( startIdx, endIdx + endExpr.length() );
                String realExpr = wholeExpr.substring( startExpr.length(), wholeExpr.length() - endExpr.length() );

                if ( startIdx >= 0 && escapeString != null && escapeString.length() > 0 )
                {
                    int startEscapeIdx = startIdx == 0 ? 0 : startIdx - escapeString.length();
                    if ( startEscapeIdx >= 0 )
                    {
                        String escape = input.substring( startEscapeIdx, startIdx );
                        if ( escapeString.equals( escape ) )
                        {
                            result.append(wholeExpr);
                            result.replace(startEscapeIdx, startEscapeIdx + escapeString.length(), "");
                            continue;
                        }
                    }
                }

                boolean resolved = false;
                if ( !unresolvable.contains( wholeExpr ) )
                {
                    if ( realExpr.startsWith( "." ) )
                    {
                        realExpr = realExpr.substring(1);
                    }

                    if ( recursionInterceptor.hasRecursiveExpression( realExpr ) )
                    {
                        throw new InterpolationCycleException( recursionInterceptor, realExpr, wholeExpr );
                    }

                    recursionInterceptor.expressionResolutionStarted( realExpr );
                    try
                    {
                        Object value = existingAnswers.get( realExpr );
                        Object bestAnswer = null;

                        for ( ValueSource valueSource : valueSources )
                        {
                            if ( value != null )
                            {
                                break;
                            }
                            value = valueSource.getValue( realExpr );

                            if ( value != null && value.toString().contains( wholeExpr ) )
                            {
                                bestAnswer = value;
                                value = null;
                            }
                        }

                        // this is the simplest recursion check to catch exact recursion
                        // (non synonym), and avoid the extra effort of more string
                        // searching.
                        if ( value == null && bestAnswer != null )
                        {
                            throw new InterpolationCycleException( recursionInterceptor, realExpr, wholeExpr );
                        }

                        if ( value != null )
                        {
                            value = interpolate( String.valueOf(value), recursionInterceptor, unresolvable );

                            if ( postProcessors != null && !postProcessors.isEmpty() )
                            {
                                for ( InterpolationPostProcessor postProcessor : postProcessors )
                                {
                                    Object newVal = postProcessor.execute( realExpr, value );
                                    if ( newVal != null )
                                    {
                                        value = newVal;
                                        break;
                                    }
                                }
                            }

                            // could use:
                            // result = matcher.replaceFirst( stringValue );
                            // but this could result in multiple lookups of stringValue, and replaceAll is not correct
                            // behaviour
                            result.append( String.valueOf( value ) );
                            resolved = true;
                        }
                        else
                        {
                            unresolvable.add( wholeExpr );
                        }
                    }
                    finally
                    {
                        recursionInterceptor.expressionResolutionFinished( realExpr );
                    }
                }

                if (!resolved)
                {
                    result.append( wholeExpr );
                }

                if ( endIdx > -1 )
                {
                    endIdx += endExpr.length() - 1;
                }
            }
            while ( ( startIdx = input.indexOf( startExpr, endIdx + 1 ) ) > -1);

            if ( endIdx == -1 && startIdx > -1 )
            {
                result.append( input, startIdx, input.length());
            }
            else if ( endIdx < input.length() )
            {
                result.append( input, endIdx + 1, input.length() );
            }

            return result.toString();
        }
        else
        {
            return input;
        }
    }

    /**
     * Return any feedback messages and errors that were generated - but
     * suppressed - during the interpolation process. Since unresolvable
     * expressions will be left in the source string as-is, this feedback is
     * optional, and will only be useful for debugging interpolation problems.
     *
     * @return a {@link List} that may be interspersed with {@link String} and
     *         {@link Throwable} instances.
     */
    public List getFeedback()
    {
        List<?> messages = new ArrayList();
        for ( ValueSource vs : valueSources )
        {
            List feedback = vs.getFeedback();
            if ( feedback != null && !feedback.isEmpty() )
            {
                messages.addAll( feedback );
            }
        }

        return messages;
    }

    /**
     * Clear the feedback messages from previous interpolate(..) calls.
     */
    public void clearFeedback()
    {
        for ( ValueSource vs : valueSources )
        {
            vs.clearFeedback();
        }
    }

    public boolean isCacheAnswers()
    {
        return cacheAnswers;
    }

    public void setCacheAnswers( boolean cacheAnswers )
    {
        this.cacheAnswers = cacheAnswers;
    }

    public void clearAnswers()
    {
        existingAnswers.clear();
    }

    public String getEscapeString()
    {
        return escapeString;
    }

    public void setEscapeString( String escapeString )
    {
        this.escapeString = escapeString;
    }

}
