/*
 * Copyright 2002-2020 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.web.servlet;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.lang.Nullable;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

/**
 * Handler execution chain, consisting of handler object and any handler interceptors.
 * Returned by HandlerMapping's {@link HandlerMapping#getHandler} method.
 *
 * @author Juergen Hoeller
 * @since 20.06.2003
 * @see HandlerInterceptor
 */
public class HandlerExecutionChain {

        private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);

        private final Object handler;

        @Nullable
        private HandlerInterceptor[] interceptors;

        @Nullable
        private List<HandlerInterceptor> interceptorList;

        private int interceptorIndex = -1;


        /**
         * Create a new HandlerExecutionChain.
         * @param handler the handler object to execute
         */
        public HandlerExecutionChain(Object handler) {
                this(handler, (HandlerInterceptor[]) null);
        }

        /**
         * Create a new HandlerExecutionChain.
         * @param handler the handler object to execute
         * @param interceptors the array of interceptors to apply
         * (in the given order) before the handler itself executes
         */
        public HandlerExecutionChain(Object handler, @Nullable HandlerInterceptor... interceptors) {
                if (handler instanceof HandlerExecutionChain) {
                        HandlerExecutionChain originalChain = (HandlerExecutionChain) handler;
                        this.handler = originalChain.getHandler();
                        this.interceptorList = new ArrayList<>();
                        CollectionUtils.mergeArrayIntoCollection(originalChain.getInterceptors(), this.interceptorList);
                        CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);
                }
                else {
                        this.handler = handler;
                        this.interceptors = interceptors;
                }
        }


        /**
         * Return the handler object to execute.
         */
        public Object getHandler() {
                return this.handler;
        }

        /**
         * Add the given interceptor to the end of this chain.
         */
        public void addInterceptor(HandlerInterceptor interceptor) {
                initInterceptorList().add(interceptor);
        }

        /**
         * Add the given interceptor at the specified index of this chain.
         * @since 5.2
         */
        public void addInterceptor(int index, HandlerInterceptor interceptor) {
                initInterceptorList().add(index, interceptor);
        }

        /**
         * Add the given interceptors to the end of this chain.
         */
        public void addInterceptors(HandlerInterceptor... interceptors) {
                if (!ObjectUtils.isEmpty(interceptors)) {
                        CollectionUtils.mergeArrayIntoCollection(interceptors, initInterceptorList());
                }
        }

        private List<HandlerInterceptor> initInterceptorList() {
                if (this.interceptorList == null) {
                        this.interceptorList = new ArrayList<>();
                        if (this.interceptors != null) {
                                // An interceptor array specified through the constructor
                                CollectionUtils.mergeArrayIntoCollection(this.interceptors, this.interceptorList);
                        }
                }
                this.interceptors = null;
                return this.interceptorList;
        }

        /**
         * Return the array of interceptors to apply (in the given order).
         * @return the array of HandlerInterceptors instances (may be {@code null})
         */
        @Nullable
        public HandlerInterceptor[] getInterceptors() {
                if (this.interceptors == null && this.interceptorList != null) {
                        this.interceptors = this.interceptorList.toArray(new HandlerInterceptor[0]);
                }
                return this.interceptors;
        }


        /**
         * Apply preHandle methods of registered interceptors.
         * @return {@code true} if the execution chain should proceed with the
         * next interceptor or the handler itself. Else, DispatcherServlet assumes
         * that this interceptor has already dealt with the response itself.
         */
        boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
                HandlerInterceptor[] interceptors = getInterceptors();
                if (!ObjectUtils.isEmpty(interceptors)) {
                        for (int i = 0; i < interceptors.length; i++) {
                                HandlerInterceptor interceptor = interceptors[i];
                                if (!interceptor.preHandle(request, response, this.handler)) {
                                        triggerAfterCompletion(request, response, null);
                                        return false;
                                }
                                this.interceptorIndex = i;
                        }
                }
                return true;
        }

        /**
         * Apply postHandle methods of registered interceptors.
         */
        void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
                        throws Exception {

                HandlerInterceptor[] interceptors = getInterceptors();
                if (!ObjectUtils.isEmpty(interceptors)) {
                        for (int i = interceptors.length - 1; i >= 0; i--) {
                                HandlerInterceptor interceptor = interceptors[i];
                                interceptor.postHandle(request, response, this.handler, mv);
                        }
                }
        }

        /**
         * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
         * Will just invoke afterCompletion for all interceptors whose preHandle invocation
         * has successfully completed and returned true.
         */
        void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)
                        throws Exception {

                HandlerInterceptor[] interceptors = getInterceptors();
                if (!ObjectUtils.isEmpty(interceptors)) {
                        for (int i = this.interceptorIndex; i >= 0; i--) {
                                HandlerInterceptor interceptor = interceptors[i];
                                try {
                                        interceptor.afterCompletion(request, response, this.handler, ex);
                                }
                                catch (Throwable ex2) {
                                        logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
                                }
                        }
                }
        }

        /**
         * Apply afterConcurrentHandlerStarted callback on mapped AsyncHandlerInterceptors.
         */
        void applyAfterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response) {
                HandlerInterceptor[] interceptors = getInterceptors();
                if (!ObjectUtils.isEmpty(interceptors)) {
                        for (int i = interceptors.length - 1; i >= 0; i--) {
                                HandlerInterceptor interceptor = interceptors[i];
                                if (interceptor instanceof AsyncHandlerInterceptor) {
                                        try {
                                                AsyncHandlerInterceptor asyncInterceptor = (AsyncHandlerInterceptor) interceptor;
                                                asyncInterceptor.afterConcurrentHandlingStarted(request, response, this.handler);
                                        }
                                        catch (Throwable ex) {
                                                if (logger.isErrorEnabled()) {
                                                        logger.error("Interceptor [" + interceptor + "] failed in afterConcurrentHandlingStarted", ex);
                                                }
                                        }
                                }
                        }
                }
        }


        /**
         * Delegates to the handler's {@code toString()} implementation.
         */
        @Override
        public String toString() {
                Object handler = getHandler();
                StringBuilder sb = new StringBuilder();
                sb.append("HandlerExecutionChain with [").append(handler).append("] and ");
                if (this.interceptorList != null) {
                        sb.append(this.interceptorList.size());
                }
                else if (this.interceptors != null) {
                        sb.append(this.interceptors.length);
                }
                else {
                        sb.append(0);
                }
                return sb.append(" interceptors").toString();
        }

}