/*
 * 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.
 */
package org.apache.geronimo.arthur.spi;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiPredicate;
import java.util.function.Predicate;
import java.util.stream.Stream;

import org.apache.geronimo.arthur.spi.model.ClassReflectionModel;
import org.apache.geronimo.arthur.spi.model.DynamicProxyModel;
import org.apache.geronimo.arthur.spi.model.ResourceBundleModel;
import org.apache.geronimo.arthur.spi.model.ResourceModel;

/**
 * Enable to enrich the build with some metadata.
 */
public interface ArthurExtension {
    /**
     * @return the priority of this extension (natural order sorting).
     */
    default int order() {
        return 0;
    }

    /**
     * @param context current build context.
     */
    void execute(Context context);

    /**
     * Enables to mutate the native image command generation and to manipulate current "context" (classloader).
     */
    interface Context {
        /**
         * Find classes based on annotation on classes.
         * @param annotation the marker annotation to look for.
         * @param <T> the annotation type.
         * @return the list of classes with this annotation.
         */
        <T extends Annotation> Collection<Class<?>> findAnnotatedClasses(Class<T> annotation);

        /**
         * Simular to {@link #findAnnotatedClasses(Class)} but at method level.
         * @param annotation the marker annotation to look for.
         * @param <T> the annotation type.
         * @return the list of methods with this annotation.
         */
        <T extends Annotation> Collection<Method> findAnnotatedMethods(Class<T> annotation);

        /**
         * Simular to {@link #findAnnotatedMethods(Class)} but at field level.
         * @param annotation the marker annotation to look for.
         * @param <T> the annotation type.
         * @return the list of methods with this annotation.
         */
        <T extends Annotation> Collection<Field> findAnnotatedFields(Class<T> annotation);

        /**
         * Find subclasses and implementation of a parent.
         *
         * @param parent the parent class to use as marker.
         * @param <T> the type of the parent.
         * @return the list of children classes.
         */
        <T> Collection<Class<? extends T>> findImplementations(Class<T> parent);

        /**
         * Adds a reflection model in the context, if it already exists it is replaced.
         * @param classReflectionModel the instance to register.
         */
        void register(ClassReflectionModel classReflectionModel);

        /**
         * Adds a resource model in the context, if it already exists it is replaced.
         * @param resourceModel the instance to register.
         */
        void register(ResourceModel resourceModel);

        /**
         * Adds a bundle model in the context, if it already exists it is replaced.
         * @param resourceModel the instance to register.
         */
        void register(ResourceBundleModel resourceModel);

        /**
         * Adds a proxy model in the context, if it already exists it is replaced.
         * @param dynamicProxyModel the instance to register.
         */
        void register(DynamicProxyModel dynamicProxyModel);

        /**
         * Enables java security in the native image.
         */
        void enableAllSecurityServices();

        /**
         * Includes charsets in the native image.
         */
        void enableAllCharsets();

        /**
         * Includes resource bundle (directly from the CLI since graal has some bugs on that as of today).
         */
        void includeResourceBundle(String name);

        /**
         * Forces classes to be initialized during the build and not at run time.
         * @param classes classes to initialize.
         */
        void initializeAtBuildTime(String... classes);

        /**
         * Forces classes to be initialized during the run only, not the build.
         * @param classes classes to initialize.
         */
        void initializeAtRunTime(String... classes);

        /**
         * Retrieve a context property, used to configured an extension.
         * @param key the key to read.
         * @return the value or null if missing.
         */
        String getProperty(String key);

        /**
         * Sets a property in the context, it can be used if extensions are chained for example.
         * @param key the property key.
         * @param value the value to set for the specified key.
         */
        void setProperty(String key, String value);

        /**
         * Add specific native image option to the command line. Useful for custom graal extension options.
         * @param option the command line option to set.
         */
        void addNativeImageOption(String option);

        /**
         * Loads a class in current context.
         * @param name the class name to load.
         * @return the loaded class.
         * @throws IllegalStateException if the class can't be found.
         */
        Class<?> loadClass(String name);

        /**
         * Enable to add to native-image execution custom classes generated before the native-image execution.
         * It can be common for proxies and classes created at runtime normally.
         *
         * @param name the class name.
         * @param bytecode the class bytecode.
         */
        void registerGeneratedClass(final String name, final byte[] bytecode);

        /**
         * Creates a stream of all classes (class, super classes and interfaces) for the specified class.
         * @param from the class to look the hierarchy for.
         * @return the class hierarchy.
         */
        Stream<Class<?>> findHierarchy(Class<?> from);

        /**
         * Creates a predicate from the specified context property (key). It uses the value as a comma separated list.
         * @param property the key to read the property from in the context.
         * @param type matching type.
         * @return an optional predicate for the specified property.
         */
        Optional<Predicate<String>> createPredicate(String property, PredicateType type);

        /**
         * Use a base property suffixed with "includes" and "excludes" to create a matching predicate.
         * It relies on {@link #createPredicate(String, PredicateType)} and combine both in a single predicate.
         *
         * @param propertyBase the prefix to use to read predicate properties.
         * @param type the type of matching.
         * @return the predicate for that properties pair.
         */
        Predicate<String> createIncludesExcludes(String propertyBase, PredicateType type);

        /**
         * Tries to unwrap current context in another type.
         * @param type type to extract.
         * @param <T> type to extract.
         * @return the extracted instance.
         */
        <T> T unwrap(Class<T> type);
    }

    enum PredicateType implements BiPredicate<String, String> {
        EQUALS {
            @Override
            public boolean test(final String value, final String item) {
                return Objects.equals(value, item);
            }
        },
        STARTS_WITH {
            @Override
            public boolean test(final String value, final String item) {
                return item != null && item.startsWith(value);
            }
        },
        MATCHES {
            @Override
            public boolean test(final String value, final String item) {
                return item != null && item.matches(value);
            }
        }
    }
}