/**
    * This file Copyright (c) 2010-2013 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.blossom.preexecution;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.springframework.beans.BeansException;
  import org.springframework.beans.factory.InitializingBean;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.ApplicationContextAware;
  import org.springframework.web.servlet.HandlerExecutionChain;
  import org.springframework.web.servlet.HandlerMapping;
  import org.springframework.web.servlet.handler.AbstractUrlHandlerMapping;
  import org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping;
  import org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping;
  
  import info.magnolia.context.MgnlContext;
  import info.magnolia.module.blossom.dispatcher.BlossomDispatcher;
  import info.magnolia.module.blossom.dispatcher.BlossomDispatcherAware;
  
  /**
   * Detects pre-execution requests and decorates handlers in order to either grab the returned ModelAndView or render
   * one that was previously returned and now should be rendered.
   *
   * @since 0.5
   */
  public class BlossomHandlerMapping implements HandlerMapping, InitializingBean, ApplicationContextAware, BlossomDispatcherAware {
  
      private ApplicationContext applicationContext;
      private AbstractUrlHandlerMapping[] targetHandlerMappings;
      private DirectRenderingVoter directRenderingVoter;
      private BlossomDispatcher dispatcher;
  
      public AbstractUrlHandlerMapping[] getTargetHandlerMappings() {
          return targetHandlerMappings;
      }
  
      public void setTargetHandlerMapping(AbstractUrlHandlerMapping targetHandlerMapping) {
          this.targetHandlerMappings = new AbstractUrlHandlerMapping[]{targetHandlerMapping};
      }
  
      public void setTargetHandlerMappings(AbstractUrlHandlerMapping[] targetHandlerMappings) {
          this.targetHandlerMappings = targetHandlerMappings;
      }
  
      public DirectRenderingVoter getDirectRenderingPolicy() {
          return directRenderingVoter;
      }
  
      public void setDirectRenderingPolicy(DirectRenderingVoter directRenderingVoter) {
          this.directRenderingVoter = directRenderingVoter;
      }
  
      @Override
      public HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  
          PreexecutionContext preexecutionContext = PreexecutionContextHolder.get(request);
  
          // If it's not a pre-execution request we simply delegate to the target HandlerMapping.
          if (preexecutionContext == null) {
              return getTargetHandler(request);
          }
  
          // If this is a pre-execution request but not for this paragraph then also delegate.
          String localUuid = MgnlContext.getAggregationState().getCurrentContentNode().getIdentifier();
          if (!preexecutionContext.getUuid().equals(localUuid)) {
              return getTargetHandler(request);
          }
 
         // If there's already a MAV from a pre-executed handler, it should be rendered now.
         if (preexecutionContext.isModelAndViewSet()) {
             return new HandlerExecutionChain(new ModelAndViewReuseController(preexecutionContext));
         }
 
         // At this point we know that we're being called by the BlossomFilter to do pre-execution.
 
         // Have the target HandlerMapping return a HandlerExecutionChain.
         HandlerExecutionChain executionChain = getTargetHandler(request);
         if (executionChain == null) {
             return null;
         }
 
         // Return a wrapper that will execute the HandlerExecutionChain and grab it's result.
         return new HandlerExecutionChain(new ModelAndViewGrabbingController(preexecutionContext, executionChain, directRenderingVoter, dispatcher));
     }
 
     private HandlerExecutionChain getTargetHandler(HttpServletRequest request) throws Exception {
         for (AbstractUrlHandlerMapping targetHandlerMapping : targetHandlerMappings) {
             HandlerExecutionChain executionChain = targetHandlerMapping.getHandler(request);
             if (executionChain != null) {
                 return executionChain;
             }
         }
         return null;
     }
 
     @Override
     public void afterPropertiesSet() throws Exception {
 
         if (directRenderingVoter == null) {
             directRenderingVoter = new DefaultDirectRenderingVoter();
         }
 
         if (targetHandlerMappings == null) {
             this.targetHandlerMappings = new AbstractUrlHandlerMapping[2];
             this.targetHandlerMappings[0] = (AbstractUrlHandlerMapping) applicationContext.getAutowireCapableBeanFactory().createBean(BeanNameUrlHandlerMapping.class);
             DefaultAnnotationHandlerMapping defaultAnnotationHandlerMapping = (DefaultAnnotationHandlerMapping) applicationContext.getAutowireCapableBeanFactory().createBean(DefaultAnnotationHandlerMapping.class);
             defaultAnnotationHandlerMapping.setUseDefaultSuffixPattern(false);
             this.targetHandlerMappings[1] = defaultAnnotationHandlerMapping;
         }
     }
 
     @Override
     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
         this.applicationContext = applicationContext;
     }
 
     @Override
     public void setBlossomDispatcher(BlossomDispatcher dispatcher) {
         this.dispatcher = dispatcher;
     }
 }