/*
 * Copyright 2002-2019 the original author or authors.
 *
 * 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
 *
 *      https://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.springframework.beans.factory.support;

import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
import java.util.function.Supplier;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.ConstructorArgumentValues;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

/**
 * A root bean definition represents the merged bean definition that backs
 * a specific bean in a Spring BeanFactory at runtime. It might have been created
 * from multiple original bean definitions that inherit from each other,
 * typically registered as {@link GenericBeanDefinition GenericBeanDefinitions}.
 * A root bean definition is essentially the 'unified' bean definition view at runtime.
 *
 * <p>Root bean definitions may also be used for registering individual bean definitions
 * in the configuration phase. However, since Spring 2.5, the preferred way to register
 * bean definitions programmatically is the {@link GenericBeanDefinition} class.
 * GenericBeanDefinition has the advantage that it allows to dynamically define
 * parent dependencies, not 'hard-coding' the role as a root bean definition.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @see GenericBeanDefinition
 * @see ChildBeanDefinition
 */
@SuppressWarnings("serial")
public class RootBeanDefinition extends AbstractBeanDefinition {

        @Nullable
        private BeanDefinitionHolder decoratedDefinition;

        @Nullable
        private AnnotatedElement qualifiedElement;

        /** Determines if the definition needs to be re-merged. */
        volatile boolean stale;

        boolean allowCaching = true;

        boolean isFactoryMethodUnique = false;

        @Nullable
        volatile ResolvableType targetType;

        /** Package-visible field for caching the determined Class of a given bean definition. */
        @Nullable
        volatile Class<?> resolvedTargetType;

        /** Package-visible field for caching if the bean is a factory bean. */
        @Nullable
        volatile Boolean isFactoryBean;

        /** Package-visible field for caching the return type of a generically typed factory method. */
        @Nullable
        volatile ResolvableType factoryMethodReturnType;

        /** Package-visible field for caching a unique factory method candidate for introspection. */
        @Nullable
        volatile Method factoryMethodToIntrospect;

        /** Common lock for the four constructor fields below. */
        final Object constructorArgumentLock = new Object();

        /** Package-visible field for caching the resolved constructor or factory method. */
        @Nullable
        Executable resolvedConstructorOrFactoryMethod;

        /** Package-visible field that marks the constructor arguments as resolved. */
        boolean constructorArgumentsResolved = false;

        /** Package-visible field for caching fully resolved constructor arguments. */
        @Nullable
        Object[] resolvedConstructorArguments;

        /** Package-visible field for caching partly prepared constructor arguments. */
        @Nullable
        Object[] preparedConstructorArguments;

        /** Common lock for the two post-processing fields below. */
        final Object postProcessingLock = new Object();

        /** Package-visible field that indicates MergedBeanDefinitionPostProcessor having been applied. */
        boolean postProcessed = false;

        /** Package-visible field that indicates a before-instantiation post-processor having kicked in. */
        @Nullable
        volatile Boolean beforeInstantiationResolved;

        @Nullable
        private Set<Member> externallyManagedConfigMembers;

        @Nullable
        private Set<String> externallyManagedInitMethods;

        @Nullable
        private Set<String> externallyManagedDestroyMethods;


        /**
         * Create a new RootBeanDefinition, to be configured through its bean
         * properties and configuration methods.
         * @see #setBeanClass
         * @see #setScope
         * @see #setConstructorArgumentValues
         * @see #setPropertyValues
         */
        public RootBeanDefinition() {
                super();
        }

        /**
         * Create a new RootBeanDefinition for a singleton.
         * @param beanClass the class of the bean to instantiate
         * @see #setBeanClass
         */
        public RootBeanDefinition(@Nullable Class<?> beanClass) {
                super();
                setBeanClass(beanClass);
        }

        /**
         * Create a new RootBeanDefinition for a singleton bean, constructing each instance
         * through calling the given supplier (possibly a lambda or method reference).
         * @param beanClass the class of the bean to instantiate
         * @param instanceSupplier the supplier to construct a bean instance,
         * as an alternative to a declaratively specified factory method
         * @since 5.0
         * @see #setInstanceSupplier
         */
        public <T> RootBeanDefinition(@Nullable Class<T> beanClass, @Nullable Supplier<T> instanceSupplier) {
                super();
                setBeanClass(beanClass);
                setInstanceSupplier(instanceSupplier);
        }

        /**
         * Create a new RootBeanDefinition for a scoped bean, constructing each instance
         * through calling the given supplier (possibly a lambda or method reference).
         * @param beanClass the class of the bean to instantiate
         * @param scope the name of the corresponding scope
         * @param instanceSupplier the supplier to construct a bean instance,
         * as an alternative to a declaratively specified factory method
         * @since 5.0
         * @see #setInstanceSupplier
         */
        public <T> RootBeanDefinition(@Nullable Class<T> beanClass, String scope, @Nullable Supplier<T> instanceSupplier) {
                super();
                setBeanClass(beanClass);
                setScope(scope);
                setInstanceSupplier(instanceSupplier);
        }

        /**
         * Create a new RootBeanDefinition for a singleton,
         * using the given autowire mode.
         * @param beanClass the class of the bean to instantiate
         * @param autowireMode by name or type, using the constants in this interface
         * @param dependencyCheck whether to perform a dependency check for objects
         * (not applicable to autowiring a constructor, thus ignored there)
         */
        public RootBeanDefinition(@Nullable Class<?> beanClass, int autowireMode, boolean dependencyCheck) {
                super();
                setBeanClass(beanClass);
                setAutowireMode(autowireMode);
                if (dependencyCheck && getResolvedAutowireMode() != AUTOWIRE_CONSTRUCTOR) {
                        setDependencyCheck(DEPENDENCY_CHECK_OBJECTS);
                }
        }

        /**
         * Create a new RootBeanDefinition for a singleton,
         * providing constructor arguments and property values.
         * @param beanClass the class of the bean to instantiate
         * @param cargs the constructor argument values to apply
         * @param pvs the property values to apply
         */
        public RootBeanDefinition(@Nullable Class<?> beanClass, @Nullable ConstructorArgumentValues cargs,
                        @Nullable MutablePropertyValues pvs) {

                super(cargs, pvs);
                setBeanClass(beanClass);
        }

        /**
         * Create a new RootBeanDefinition for a singleton,
         * providing constructor arguments and property values.
         * <p>Takes a bean class name to avoid eager loading of the bean class.
         * @param beanClassName the name of the class to instantiate
         */
        public RootBeanDefinition(String beanClassName) {
                setBeanClassName(beanClassName);
        }

        /**
         * Create a new RootBeanDefinition for a singleton,
         * providing constructor arguments and property values.
         * <p>Takes a bean class name to avoid eager loading of the bean class.
         * @param beanClassName the name of the class to instantiate
         * @param cargs the constructor argument values to apply
         * @param pvs the property values to apply
         */
        public RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
                super(cargs, pvs);
                setBeanClassName(beanClassName);
        }

        /**
         * Create a new RootBeanDefinition as deep copy of the given
         * bean definition.
         * @param original the original bean definition to copy from
         */
        public RootBeanDefinition(RootBeanDefinition original) {
                super(original);
                this.decoratedDefinition = original.decoratedDefinition;
                this.qualifiedElement = original.qualifiedElement;
                this.allowCaching = original.allowCaching;
                this.isFactoryMethodUnique = original.isFactoryMethodUnique;
                this.targetType = original.targetType;
                this.factoryMethodToIntrospect = original.factoryMethodToIntrospect;
        }

        /**
         * Create a new RootBeanDefinition as deep copy of the given
         * bean definition.
         * @param original the original bean definition to copy from
         */
        RootBeanDefinition(BeanDefinition original) {
                super(original);
        }


        @Override
        public String getParentName() {
                return null;
        }

        @Override
        public void setParentName(@Nullable String parentName) {
                if (parentName != null) {
                        throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
                }
        }

        /**
         * Register a target definition that is being decorated by this bean definition.
         */
        public void setDecoratedDefinition(@Nullable BeanDefinitionHolder decoratedDefinition) {
                this.decoratedDefinition = decoratedDefinition;
        }

        /**
         * Return the target definition that is being decorated by this bean definition, if any.
         */
        @Nullable
        public BeanDefinitionHolder getDecoratedDefinition() {
                return this.decoratedDefinition;
        }

        /**
         * Specify the {@link AnnotatedElement} defining qualifiers,
         * to be used instead of the target class or factory method.
         * @since 4.3.3
         * @see #setTargetType(ResolvableType)
         * @see #getResolvedFactoryMethod()
         */
        public void setQualifiedElement(@Nullable AnnotatedElement qualifiedElement) {
                this.qualifiedElement = qualifiedElement;
        }

        /**
         * Return the {@link AnnotatedElement} defining qualifiers, if any.
         * Otherwise, the factory method and target class will be checked.
         * @since 4.3.3
         */
        @Nullable
        public AnnotatedElement getQualifiedElement() {
                return this.qualifiedElement;
        }

        /**
         * Specify a generics-containing target type of this bean definition, if known in advance.
         * @since 4.3.3
         */
        public void setTargetType(ResolvableType targetType) {
                this.targetType = targetType;
        }

        /**
         * Specify the target type of this bean definition, if known in advance.
         * @since 3.2.2
         */
        public void setTargetType(@Nullable Class<?> targetType) {
                this.targetType = (targetType != null ? ResolvableType.forClass(targetType) : null);
        }

        /**
         * Return the target type of this bean definition, if known
         * (either specified in advance or resolved on first instantiation).
         * @since 3.2.2
         */
        @Nullable
        public Class<?> getTargetType() {
                if (this.resolvedTargetType != null) {
                        return this.resolvedTargetType;
                }
                ResolvableType targetType = this.targetType;
                return (targetType != null ? targetType.resolve() : null);
        }

        /**
         * Return a {@link ResolvableType} for this bean definition,
         * either from runtime-cached type information or from configuration-time
         * {@link #setTargetType(ResolvableType)} or {@link #setBeanClass(Class)},
         * also considering resolved factory method definitions.
         * @since 5.1
         * @see #setTargetType(ResolvableType)
         * @see #setBeanClass(Class)
         * @see #setResolvedFactoryMethod(Method)
         */
        @Override
        public ResolvableType getResolvableType() {
                ResolvableType targetType = this.targetType;
                if (targetType != null) {
                        return targetType;
                }
                ResolvableType returnType = this.factoryMethodReturnType;
                if (returnType != null) {
                        return returnType;
                }
                Method factoryMethod = this.factoryMethodToIntrospect;
                if (factoryMethod != null) {
                        return ResolvableType.forMethodReturnType(factoryMethod);
                }
                return super.getResolvableType();
        }

        /**
         * Determine preferred constructors to use for default construction, if any.
         * Constructor arguments will be autowired if necessary.
         * @return one or more preferred constructors, or {@code null} if none
         * (in which case the regular no-arg default constructor will be called)
         * @since 5.1
         */
        @Nullable
        public Constructor<?>[] getPreferredConstructors() {
                return null;
        }

        /**
         * Specify a factory method name that refers to a non-overloaded method.
         */
        public void setUniqueFactoryMethodName(String name) {
                Assert.hasText(name, "Factory method name must not be empty");
                setFactoryMethodName(name);
                this.isFactoryMethodUnique = true;
        }

        /**
         * Specify a factory method name that refers to an overloaded method.
         * @since 5.2
         */
        public void setNonUniqueFactoryMethodName(String name) {
                Assert.hasText(name, "Factory method name must not be empty");
                setFactoryMethodName(name);
                this.isFactoryMethodUnique = false;
        }

        /**
         * Check whether the given candidate qualifies as a factory method.
         */
        public boolean isFactoryMethod(Method candidate) {
                return candidate.getName().equals(getFactoryMethodName());
        }

        /**
         * Set a resolved Java Method for the factory method on this bean definition.
         * @param method the resolved factory method, or {@code null} to reset it
         * @since 5.2
         */
        public void setResolvedFactoryMethod(@Nullable Method method) {
                this.factoryMethodToIntrospect = method;
        }

        /**
         * Return the resolved factory method as a Java Method object, if available.
         * @return the factory method, or {@code null} if not found or not resolved yet
         */
        @Nullable
        public Method getResolvedFactoryMethod() {
                return this.factoryMethodToIntrospect;
        }

        public void registerExternallyManagedConfigMember(Member configMember) {
                synchronized (this.postProcessingLock) {
                        if (this.externallyManagedConfigMembers == null) {
                                this.externallyManagedConfigMembers = new HashSet<>(1);
                        }
                        this.externallyManagedConfigMembers.add(configMember);
                }
        }

        public boolean isExternallyManagedConfigMember(Member configMember) {
                synchronized (this.postProcessingLock) {
                        return (this.externallyManagedConfigMembers != null &&
                                        this.externallyManagedConfigMembers.contains(configMember));
                }
        }

        public void registerExternallyManagedInitMethod(String initMethod) {
                synchronized (this.postProcessingLock) {
                        if (this.externallyManagedInitMethods == null) {
                                this.externallyManagedInitMethods = new HashSet<>(1);
                        }
                        this.externallyManagedInitMethods.add(initMethod);
                }
        }

        public boolean isExternallyManagedInitMethod(String initMethod) {
                synchronized (this.postProcessingLock) {
                        return (this.externallyManagedInitMethods != null &&
                                        this.externallyManagedInitMethods.contains(initMethod));
                }
        }

        public void registerExternallyManagedDestroyMethod(String destroyMethod) {
                synchronized (this.postProcessingLock) {
                        if (this.externallyManagedDestroyMethods == null) {
                                this.externallyManagedDestroyMethods = new HashSet<>(1);
                        }
                        this.externallyManagedDestroyMethods.add(destroyMethod);
                }
        }

        public boolean isExternallyManagedDestroyMethod(String destroyMethod) {
                synchronized (this.postProcessingLock) {
                        return (this.externallyManagedDestroyMethods != null &&
                                        this.externallyManagedDestroyMethods.contains(destroyMethod));
                }
        }


        @Override
        public RootBeanDefinition cloneBeanDefinition() {
                return new RootBeanDefinition(this);
        }

        @Override
        public boolean equals(@Nullable Object other) {
                return (this == other || (other instanceof RootBeanDefinition && super.equals(other)));
        }

        @Override
        public String toString() {
                return "Root bean: " + super.toString();
        }

}