/**
    * This file Copyright (c) 2010-2011 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.template;
  
  import java.util.Collection;
  import java.util.List;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.InitializingBean;
  import org.springframework.context.ApplicationEvent;
  import org.springframework.context.ApplicationListener;
  
  import info.magnolia.module.blossom.annotation.Area;
  import info.magnolia.module.blossom.annotation.Template;
  import info.magnolia.module.blossom.dialog.BlossomDialogDescription;
  import info.magnolia.module.blossom.dialog.BlossomDialogRegistry;
  import info.magnolia.module.blossom.dialog.DialogDescriptionBuilder;
  import info.magnolia.module.blossom.dispatcher.BlossomDispatcher;
  import info.magnolia.module.blossom.dispatcher.BlossomDispatcherAware;
  import info.magnolia.module.blossom.dispatcher.BlossomDispatcherInitializedEvent;
  import info.magnolia.module.blossom.support.AbstractUrlMappedHandlerPostProcessor;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.rendering.template.AreaDefinition;
  import info.magnolia.rendering.template.registry.TemplateDefinitionRegistry;
  
  /**
   * Detects templates by inspecting HandlerMappings.
   *
   * @since 1.1.1
   */
  public class TemplateExporter extends AbstractUrlMappedHandlerPostProcessor implements InitializingBean, ApplicationListener, BlossomDispatcherAware {
  
      private static final String TEMPLATE_DIALOG_PREFIX = "blossom-template-dialog:";
      private static final String AREA_DIALOG_PREFIX = "blossom-area-dialog:";
  
      private final Logger logger = LoggerFactory.getLogger(getClass());
  
      private BlossomDispatcher dispatcher;
      private TemplateDefinitionBuilder templateDefinitionBuilder;
      private DialogDescriptionBuilder dialogDescriptionBuilder;
  
      private DetectedHandlersMetaData detectedHandlers = new DetectedHandlersMetaData();
  
      public void setTemplateDefinitionBuilder(TemplateDefinitionBuilder templateDefinitionBuilder) {
          this.templateDefinitionBuilder = templateDefinitionBuilder;
      }
  
      public void setDialogDescriptionBuilder(DialogDescriptionBuilder dialogDescriptionBuilder) {
          this.dialogDescriptionBuilder = dialogDescriptionBuilder;
      }
  
      @Override
      public void setBlossomDispatcher(BlossomDispatcher dispatcher) {
          this.dispatcher = dispatcher;
      }
  
      @Override
      protected void postProcessHandler(Object handler, String handlerPath) {
          if (handler.getClass().isAnnotationPresent(Area.class)) {
              detectedHandlers.addArea(new HandlerMetaData(handler, handlerPath));
          } else if (handler.getClass().isAnnotationPresent(Template.class)) {
              detectedHandlers.addTemplate(new HandlerMetaData(handler, handlerPath));
          }
      }
  
     @Override
     public void onApplicationEvent(ApplicationEvent event) {
         if (event instanceof BlossomDispatcherInitializedEvent && event.getSource() == dispatcher) {
             exportTemplates();
         }
     }
 
     protected void exportTemplates() {
         for (HandlerMetaData template : detectedHandlers.getTemplates()) {
 
             BlossomTemplateDefinition definition = templateDefinitionBuilder.buildTemplateDefinition(dispatcher, detectedHandlers, template);
 
             Components.getComponent(TemplateDefinitionRegistry.class).register(new BlossomTemplateDefinitionProvider(definition));
 
             if (StringUtils.isEmpty(definition.getDialog())) {
                 registerTemplateDialog(definition);
             }
 
             registerDialogFactories(definition);
 
             registerAreaDialogs(definition.getAreas().values());
         }
 
         // We're done with this structure so there's no need to keep it around
         detectedHandlers = null;
     }
 
     protected void registerDialogFactories(BlossomTemplateDefinition templateDefinition) {
 
         List<BlossomDialogDescription> dialogDescriptions = dialogDescriptionBuilder.buildDescriptions(templateDefinition.getHandler());
         for (BlossomDialogDescription dialogDescription : dialogDescriptions) {
             try {
                 Components.getComponent(BlossomDialogRegistry.class).addDialogDescription(dialogDescription);
             } catch (RepositoryException e) {
                 logger.error("Unable to register dialog factory within template [" + dialogDescription.getFactoryMetaData().getFactoryMethod() + "] with handlerPath [" + templateDefinition.getHandlerPath() + "]", e);
             }
 
             if (logger.isDebugEnabled()) {
                 logger.debug("Registered dialog factory within template [" + templateDefinition.getId() + "] with id [" + dialogDescription.getId() + "]");
             }
         }
     }
 
     protected void registerTemplateDialog(BlossomTemplateDefinition templateDefinition) {
 
         String templateId = templateDefinition.getId();
 
         String dialogId = TEMPLATE_DIALOG_PREFIX + templateDefinition.getHandler().getClass().getName();
 
         BlossomDialogDescription dialogDescription = dialogDescriptionBuilder.buildDescription(dialogId, templateDefinition.getTitle(), templateDefinition.getHandler());
 
         if (dialogDescription.getFactoryMetaData().isEmpty()) {
             return;
         }
 
         templateDefinition.setDialog(dialogId);
 
         try {
             Components.getComponent(BlossomDialogRegistry.class).addDialogDescription(dialogDescription);
         } catch (RepositoryException e) {
             logger.error("Failed to register dialog for template [" + templateId + "] with id [" + dialogId + "]", e);
             return;
         }
 
         if (logger.isDebugEnabled()) {
             logger.debug("Registered dialog for template [" + templateId + "] with id [" + dialogId + "]");
         }
     }
 
     protected void registerAreaDialogs(Collection<AreaDefinition> areas) {
         for (AreaDefinition areaDefinition : areas) {
             if (StringUtils.isEmpty(areaDefinition.getDialog())) {
                 registerAreaDialog((BlossomAreaDefinition) areaDefinition);
             }
             registerAreaDialogs(areaDefinition.getAreas().values());
         }
     }
 
     protected void registerAreaDialog(BlossomAreaDefinition areaDefinition) {
 
         String areaName = areaDefinition.getName();
 
         String dialogId = AREA_DIALOG_PREFIX + areaDefinition.getHandler().getClass().getName();
 
         BlossomDialogDescription dialogDescription = dialogDescriptionBuilder.buildDescription(dialogId, areaDefinition.getTitle(), areaDefinition.getHandler());
 
         if (dialogDescription.getFactoryMetaData().isEmpty()) {
             return;
         }
 
         areaDefinition.setDialog(dialogId);
 
         try {
             Components.getComponent(BlossomDialogRegistry.class).addDialogDescription(dialogDescription);
         } catch (RepositoryException e) {
             logger.error("Failed to register dialog for area [" + areaName + "] with id [" + dialogId + "]", e);
             return;
         }
 
         if (logger.isDebugEnabled()) {
             logger.debug("Registered dialog for area [" + areaName + "] with id [" + dialogId + "]");
         }
     }
 
     @Override
     public void afterPropertiesSet() throws Exception {
         if (templateDefinitionBuilder == null) {
             templateDefinitionBuilder = new TemplateDefinitionBuilder();
         }
         if (dialogDescriptionBuilder == null) {
             dialogDescriptionBuilder = new DialogDescriptionBuilder();
         }
     }
 }