package org.apache.commons.digester3.binder;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 static java.lang.String.format;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.digester3.RuleSet;

/**
 * The default Digester EDSL implementation.
 *
 * @since 3.0
 */
final class DefaultRulesBinder
    implements RulesBinder
{

    /**
     * Errors that can occur during binding time or rules creation.
     */
    private final List<ErrorMessage> errors = new ArrayList<ErrorMessage>();

    /**
     *
     */
    private final FromBinderRuleSet fromBinderRuleSet = new FromBinderRuleSet();

    /**
     *
     */
    private ClassLoader classLoader;

    /**
     *
     *
     * @param classLoader
     */
    void initialize( ClassLoader classLoader )
    {
        this.classLoader = classLoader;
        fromBinderRuleSet.clear();
        errors.clear();
    }

    /**
     * {@inheritDoc}
     */
    public ClassLoader getContextClassLoader()
    {
        return this.classLoader;
    }

    /**
     * {@inheritDoc}
     */
    public void addError( String messagePattern, Object... arguments )
    {
        StackTraceElement[] stackTrace = new Exception().getStackTrace();
        StackTraceElement element = null;

        int stackIndex = stackTrace.length - 1;
        while ( element == null && stackIndex > 0 ) // O(n) there's no better way
        {
            Class<?> moduleClass;
            try
            {
                // check if the set ClassLoader resolves the Class in the StackTrace
                moduleClass = Class.forName( stackTrace[stackIndex].getClassName(), false, this.classLoader );
            }
            catch ( ClassNotFoundException e )
            {
                try
                {
                    // try otherwise with current ClassLoader
                    moduleClass =
                        Class.forName( stackTrace[stackIndex].getClassName(), false, this.getClass().getClassLoader() );
                }
                catch ( ClassNotFoundException e1 )
                {
                    // Class in the StackTrace can't be found, don't write the file name:line number detail in the
                    // message
                    moduleClass = null;
                }
            }

            if ( moduleClass != null && RulesModule.class.isAssignableFrom( moduleClass ) )
            {
                element = stackTrace[stackIndex];
            }

            stackIndex--;
        }

        if ( element != null )
        {
            messagePattern = format( "%s (%s:%s)", messagePattern, element.getFileName(), element.getLineNumber() );
        }
        addError( new ErrorMessage( messagePattern, arguments ) );
    }

    /**
     * {@inheritDoc}
     */
    public void addError( Throwable t )
    {
        String message = "An exception was caught and reported. Message: " + t.getMessage();
        addError( new ErrorMessage( message, t ) );
    }

    /**
     * Records an error, the full details of which will be logged, and the message of which will be presented to the
     * user at a later time.
     *
     * @param errorMessage The error to record.
     */
    private void addError( ErrorMessage errorMessage )
    {
        this.errors.add( errorMessage );
    }

    /**
     * {@inheritDoc}
     */
    public void install( RulesModule rulesModule )
    {
        rulesModule.configure( this );
    }

    /**
     * {@inheritDoc}
     */
    public LinkedRuleBuilder forPattern( String pattern )
    {
        final String keyPattern;

        if ( pattern == null || pattern.length() == 0 )
        {
            addError( "Null or empty pattern is not valid" );
            keyPattern = null;
        }
        else
        {
            if ( pattern.endsWith( "/" ) )
            {
                // to help users who accidently add '/' to the end of their patterns
                keyPattern = pattern.substring( 0, pattern.length() - 1 );
            }
            else
            {
                keyPattern = pattern;
            }
        }

        return new LinkedRuleBuilder( this, fromBinderRuleSet, classLoader, keyPattern );
    }

    /**
     *
     *
     * @return
     */
    boolean hasError()
    {
        return !errors.isEmpty();
    }

    /**
     *
     *
     * @return
     */
    int errorsSize()
    {
        return errors.size();
    }

    /**
     *
     *
     * @return
     */
    Iterable<ErrorMessage> getErrors()
    {
        return errors;
    }

    /**
     *
     *
     * @return
     */
    RuleSet getFromBinderRuleSet()
    {
        return fromBinderRuleSet;
    }

}