/*
 * JBoss, Home of Professional Open Source
 * Copyright 2009, Red Hat Middleware LLC, and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * 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.
 */
package org.jboss.shrinkwrap.api;

import java.util.Collection;
import java.util.regex.Pattern;

import javax.annotation.processing.Filer;

Factory class for the creation of new Filter instances. Filter instances using this shorthand class will be created using the ClassLoader associated with the default Domain's Configuration. 
Author:
Aslak Knutsen
Version:
$Revision: $/**
 * Factory class for the creation of new {@link Filter} instances. Filter instances using this shorthand class will be
 * created using the {@link ClassLoader} associated with the default {@link Domain}'s {@link Configuration}.
 *
 *
 * @author <a href="mailto:aslak@conduct.no">Aslak Knutsen</a>
 * @version $Revision: $
 */
public final class Filters {
    // -------------------------------------------------------------------------------------||
    // Class Members ----------------------------------------------------------------------||
    // -------------------------------------------------------------------------------------||

    private static final String IMPL_CLASS_NAME_INCLUDE_ALL_PATHS = "org.jboss.shrinkwrap.impl.base.filter.IncludeAllPaths";

    private static final String IMPL_CLASS_NAME_INCLUDE_REGEXP_PATHS = "org.jboss.shrinkwrap.impl.base.filter.IncludeRegExpPaths";

    private static final String IMPL_CLASS_NAME_EXCLUDE_REGEXP_PATHS = "org.jboss.shrinkwrap.impl.base.filter.ExcludeRegExpPaths";

    private static final String IMPL_CLASS_NAME_INCLUDE_PATHS = "org.jboss.shrinkwrap.impl.base.filter.IncludePaths";

    private static final String IMPL_CLASS_NAME_EXCLUDE_PATHS = "org.jboss.shrinkwrap.impl.base.filter.ExcludePaths";

    
Filter that includes all ArchivePaths. Only meant to be used internally. 
Returns:
A Filter that always return true/**
     * {@link Filter} that includes all {@link ArchivePath}s.
     *
     * Only meant to be used internally.
     *
     * @return A {@link Filter} that always return true
     */
    public static Filter<ArchivePath> includeAll() {
        return getFilterInstance(IMPL_CLASS_NAME_INCLUDE_ALL_PATHS, new Class<?>[] {}, new Object[] {});
    }

    
Filer that include all ArchivePaths that match the given Regular Expression Pattern. 
Params:
regexp – 
           The expression to include
Returns:
A Regular Expression based include Filter/**
     * {@link Filer} that include all {@link ArchivePath}s that match the given Regular Expression {@link Pattern}.
     *
     * @param regexp
     *            The expression to include
     * @return A Regular Expression based include {@link Filter}
     */
    public static Filter<ArchivePath> include(String regexp) {
        return getFilterInstance(IMPL_CLASS_NAME_INCLUDE_REGEXP_PATHS, new Class<?>[] { String.class },
            new Object[] { regexp });
    }

    
Filter that exclude all ArchivePaths that match a given Regular Expression Pattern. 
Params:
regexp – 
           The expression to exclude
Returns:
A Regular Expression based exclude Filter/**
     * {@link Filter} that exclude all {@link ArchivePath}s that match a given Regular Expression {@link Pattern}.
     *
     * @param regexp
     *            The expression to exclude
     * @return A Regular Expression based exclude {@link Filter}
     */
    public static Filter<ArchivePath> exclude(final String regexp) {
        return getFilterInstance(IMPL_CLASS_NAME_EXCLUDE_REGEXP_PATHS, new Class<?>[] { String.class },
            new Object[] { regexp });
    }

    
Filer that include all ArchivePaths that match the given List of paths.. 
Params:
paths – 
           The paths to included
Returns:
A Path list based include Filter/**
     * {@link Filer} that include all {@link ArchivePath}s that match the given List of paths..
     *
     * @param paths
     *            The paths to included
     * @return A Path list based include {@link Filter}
     */
    public static Filter<ArchivePath> includePaths(final String... paths) {
        return getFilterInstance(IMPL_CLASS_NAME_INCLUDE_PATHS, new Class<?>[] { String[].class },
            new Object[] { paths });
    }

    
Filer that include all ArchivePaths that match the given List of paths.. 
Params:
paths – 
           The paths to included
Returns:
A Path list based include Filter/**
     * {@link Filer} that include all {@link ArchivePath}s that match the given List of paths..
     *
     * @param paths
     *            The paths to included
     * @return A Path list based include {@link Filter}
     */
    public static Filter<ArchivePath> includePaths(final Collection<String> paths) {
        return getFilterInstance(IMPL_CLASS_NAME_INCLUDE_PATHS, new Class<?>[] { Collection.class },
            new Object[] { paths });
    }

    
Filter that exclude all ArchivePaths that match the given List of paths. 
Params:
paths – 
           The paths to exclude
Returns:
A Path list based exclude Filter/**
     * {@link Filter} that exclude all {@link ArchivePath}s that match the given List of paths.
     *
     * @param paths
     *            The paths to exclude
     * @return A Path list based exclude {@link Filter}
     */
    public static Filter<ArchivePath> excludePaths(final String... paths) {
        return getFilterInstance(IMPL_CLASS_NAME_EXCLUDE_PATHS, new Class<?>[] { String[].class },
            new Object[] { paths });
    }

    
Filter that exclude all ArchivePaths that match the given List of paths. 
Params:
paths – 
           The paths to exclude
Returns:
A Path list based exclude Filter/**
     * {@link Filter} that exclude all {@link ArchivePath}s that match the given List of paths.
     *
     * @param paths
     *            The paths to exclude
     * @return A Path list based exclude {@link Filter}
     */
    public static Filter<ArchivePath> excludePaths(final Collection<String> paths) {
        return getFilterInstance(IMPL_CLASS_NAME_EXCLUDE_PATHS, new Class<?>[] { Collection.class },
            new Object[] { paths });
    }

    
Filter that includes listed Package. 
Params:
packages – 
           To be included
Returns:
/**
     * {@link Filter} that includes listed {@link Package}.
     *
     * @param packages
     *            To be included
     * @return
     */
    public static Filter<ArchivePath> exclude(Package... packages) {
        return createRegExpFilter(IMPL_CLASS_NAME_EXCLUDE_REGEXP_PATHS, packages);
    }

    
Filter that excludes listed Package. 
Params:
packages – 
           To be excluded
Returns:
/**
     * {@link Filter} that excludes listed {@link Package}.
     *
     * @param packages
     *            To be excluded
     * @return
     */
    public static Filter<ArchivePath> include(Package... packages) {
        return createRegExpFilter(IMPL_CLASS_NAME_INCLUDE_REGEXP_PATHS, packages);
    }

    private static Filter<ArchivePath> createRegExpFilter(String filterClassName, Package... packages) {
        StringBuilder classExpression = new StringBuilder();
        for (Package pack : packages) {
            classExpression.append("|");
            classExpression.append("(.*" + pack.getName().replaceAll("\\.", "\\.") + ".*)");
        }
        classExpression.deleteCharAt(0);

        return getFilterInstance(filterClassName, new Class<?>[] { String.class },
            new Object[] { classExpression.toString() });
    }

    
Filter that includes listed Class. 
Params:
classes – 
           To be included
Returns:
/**
     * {@link Filter} that includes listed {@link Class}.
     *
     * @param classes
     *            To be included
     * @return
     */
    public static Filter<ArchivePath> include(Class<?>... classes) {
        return createRegExpFilter(IMPL_CLASS_NAME_INCLUDE_REGEXP_PATHS, classes);
    }

    
Filter that excludes listed Class. 
Params:
classes – 
           To be excluded
Returns:
/**
     * {@link Filter} that excludes listed {@link Class}.
     *
     * @param classes
     *            To be excluded
     * @return
     */
    public static Filter<ArchivePath> exclude(Class<?>... classes) {
        return createRegExpFilter(IMPL_CLASS_NAME_EXCLUDE_REGEXP_PATHS, classes);
    }

    private static Filter<ArchivePath> createRegExpFilter(String regExpFilterImplName, Class<?>... classes) {
        StringBuilder classExpression = new StringBuilder();
        for (Class<?> clazz : classes) {
            classExpression.append("|");
            classExpression.append("(.*" + clazz.getName().replaceAll("\\.", "\\.") + "\\.class)");
        }
        classExpression.deleteCharAt(0);

        return getFilterInstance(regExpFilterImplName, new Class<?>[] { String.class },
            new Object[] { classExpression.toString() });
    }

    
Creates a new Filter instance using the given impl class name, constructor arguments and type 
Params:
filterClassName – 
ctorTypes – 
ctorArguments – 
Returns:
/**
     * Creates a new {@link Filter} instance using the given impl class name, constructor arguments and type
     *
     * @param filterClassName
     * @param ctorTypes
     * @param ctorArguments
     * @return
     */
    @SuppressWarnings("unchecked")
    private static Filter<ArchivePath> getFilterInstance(final String filterClassName, final Class<?>[] ctorTypes,
        final Object[] ctorArguments) {
        // Precondition checks
        assert filterClassName != null && filterClassName.length() > 0 : "Filter class name must be specified";
        assert ctorTypes != null : "Construction types must be specified";
        assert ctorArguments != null : "Construction arguments must be specified";
        assert ctorTypes.length == ctorArguments.length : "The number of ctor arguments and their types must match";

        // Find the filter impl class in the configured CLs
        final Class<Filter<ArchivePath>> filterClass;
        try {
            filterClass = (Class<Filter<ArchivePath>>) ClassLoaderSearchUtil.findClassFromClassLoaders(filterClassName,
                ShrinkWrap.getDefaultDomain().getConfiguration().getClassLoaders());
        } catch (final ClassNotFoundException cnfe) {
            throw new IllegalStateException("Could not find filter implementation class " + filterClassName
                + " in any of the configured CLs", cnfe);
        }

        // Make the new instance
        return SecurityActions.newInstance(filterClass, ctorTypes, ctorArguments, Filter.class);
    }

    // -------------------------------------------------------------------------------------||
    // Constructor ------------------------------------------------------------------------||
    // -------------------------------------------------------------------------------------||

    
No instantiation
/**
     * No instantiation
     */
    private Filters() {
    }
}