/**
    * 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.template;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import javax.jcr.Node;
  
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.util.ClassUtils;
  
  import info.magnolia.cms.core.Content;
  import info.magnolia.cms.util.ContentUtil;
  import info.magnolia.module.blossom.annotation.Area;
  import info.magnolia.module.blossom.annotation.Available;
  import info.magnolia.module.blossom.annotation.AvailableComponentClasses;
  import info.magnolia.module.blossom.annotation.AvailableComponents;
  import info.magnolia.module.blossom.annotation.ComponentCategory;
  import info.magnolia.module.blossom.annotation.I18nBasename;
  import info.magnolia.module.blossom.annotation.Inherits;
  import info.magnolia.module.blossom.annotation.Template;
  import info.magnolia.module.blossom.annotation.TemplateDescription;
  import info.magnolia.module.blossom.annotation.TernaryBoolean;
  import info.magnolia.module.blossom.dispatcher.BlossomDispatcher;
  import info.magnolia.module.blossom.support.MethodInvocationUtils;
  import info.magnolia.module.blossom.support.ParameterResolver;
  import info.magnolia.rendering.template.AreaDefinition;
  import info.magnolia.rendering.template.ComponentAvailability;
  import info.magnolia.rendering.template.InheritanceConfiguration;
  import info.magnolia.rendering.template.TemplateAvailability;
  import info.magnolia.rendering.template.TemplateDefinition;
  import info.magnolia.rendering.template.configured.ConfiguredComponentAvailability;
  import info.magnolia.rendering.template.configured.ConfiguredInheritance;
  
  /**
   * Builds template descriptions from annotations.
   *
   * @since 1.0
   */
  public class TemplateDefinitionBuilder {
  
      private final Logger logger = LoggerFactory.getLogger(getClass());
  
      public BlossomTemplateDefinition buildTemplateDefinition(BlossomDispatcher dispatcher, DetectedHandlersMetaData detectedHandlers, HandlerMetaData template) {
  
          Class<?> handlerClass = template.getHandlerClass();
          Object handler = template.getHandler();
          String handlerPath = template.getHandlerPath();
          Template annotation = handlerClass.getAnnotation(Template.class);
  
          BlossomTemplateDefinition definition = new BlossomTemplateDefinition();
          definition.setId(resolveTemplateId(handlerClass));
          definition.setName(definition.getId());
          definition.setTitle(resolveTemplateTitle(template));
          definition.setDescription(resolveDescription(template));
          definition.setI18nBasename(getI18nBasename(template));
          definition.setHandlerPath(handlerPath);
          definition.setDialog(StringUtils.trimToNull(annotation.dialog()));
          definition.setVisible(annotation.visible());
          definition.setDispatcher(dispatcher);
          definition.setHandler(handler);
          TemplateAvailability templateAvailability = resolveTemplateAvailability(template);
         if (templateAvailability != null) {
             definition.setTemplateAvailability(templateAvailability);
         }
         definition.setRenderType("blossom");
 
         definition.setAreas(buildAreaDefinitionsForTemplate(dispatcher, detectedHandlers, template));
 
         return definition;
     }
 
     protected String resolveTemplateId(Class<?> handlerClass) {
         Template annotation = handlerClass.getAnnotation(Template.class);
         if (annotation == null) {
             throw new IllegalArgumentException("Could not resolve template id, @Template is not present on class [" + handlerClass.getName() + "]");
         }
         return annotation.id();
     }
 
     protected String resolveTemplateTitle(HandlerMetaData template) {
         Template annotation = template.getHandlerClass().getAnnotation(Template.class);
         return annotation.title();
     }
 
     protected String resolveDescription(HandlerMetaData template) {
         TemplateDescription templateDescription = template.getHandlerClass().getAnnotation(TemplateDescription.class);
         if (templateDescription != null && StringUtils.isNotEmpty(templateDescription.value())) {
             return templateDescription.value();
         }
         return "";
     }
 
     protected String getI18nBasename(HandlerMetaData handler) {
         I18nBasename i18nBasename = handler.getHandlerClass().getAnnotation(I18nBasename.class);
         return i18nBasename != null ? i18nBasename.value() : null;
     }
 
     protected Map<String, AreaDefinition> buildAreaDefinitionsForTemplate(BlossomDispatcher dispatcher, DetectedHandlersMetaData detectedHandlers, HandlerMetaData template) {
         Map<String, AreaDefinition> areas = new HashMap<String, AreaDefinition>();
         List<HandlerMetaData> list = detectedHandlers.getAreasByEnclosingClass(template.getHandlerClass());
         if (list != null) {
             for (HandlerMetaData area : list) {
                 BlossomAreaDefinition areaDefinition = buildAreaDefinition(dispatcher, detectedHandlers, area);
                 areas.put(areaDefinition.getId(), areaDefinition);
             }
         }
         return areas;
     }
 
     protected BlossomAreaDefinition buildAreaDefinition(BlossomDispatcher dispatcher, DetectedHandlersMetaData detectedHandlers, HandlerMetaData area) {
 
         Area annotation = area.getHandlerClass().getAnnotation(Area.class);
 
         BlossomAreaDefinition definition = new BlossomAreaDefinition();
         definition.setId(annotation.value());
         definition.setName(annotation.value());
         definition.setTitle(StringUtils.isNotEmpty(annotation.title()) ? annotation.title() : StringUtils.capitalize(annotation.value()));
         definition.setRenderType("blossom");
         definition.setHandlerPath(area.getHandlerPath());
         definition.setHandler(area.getHandler());
         definition.setDispatcher(dispatcher);
         definition.setDialog(StringUtils.trimToNull(annotation.dialog()));
         definition.setI18nBasename(getI18nBasename(area));
         definition.setType(annotation.type().getDefinitionFormat());
         if (annotation.optional() != TernaryBoolean.UNSPECIFIED) {
             definition.setOptional(TernaryBoolean.toBoolean(annotation.optional()));
         }
 
         // If the templateScript is null the area is rendered simply by looping the components, to prevent this we
         // need to set it to something. The actual template script used later when rendering will be the one returned
         // by the controller
         definition.setTemplateScript("<area-script-placeholder>");
 
         definition.setInheritance(resolveInheritanceConfiguration(area));
         definition.setAvailableComponents(resolveAvailableComponents(detectedHandlers, area));
         definition.setAreas(buildAreaDefinitionsForTemplate(dispatcher, detectedHandlers, area));
 
         return definition;
     }
 
     protected Map<String, ComponentAvailability> resolveAvailableComponents(DetectedHandlersMetaData detectedHandlers, HandlerMetaData area) {
         Map<String, ComponentAvailability> map = new HashMap<String, ComponentAvailability>();
         AvailableComponents availableComponents = area.getHandlerClass().getAnnotation(AvailableComponents.class);
         if (availableComponents != null) {
             for (String componentId : availableComponents.value()) {
                 ConfiguredComponentAvailability availability = new ConfiguredComponentAvailability();
                 availability.setId(componentId);
                 map.put(componentId, availability);
             }
         }
         AvailableComponentClasses availableComponentClasses = area.getHandlerClass().getAnnotation(AvailableComponentClasses.class);
         if (availableComponentClasses != null) {
             for (Class<?> clazz : availableComponentClasses.value()) {
                 if (clazz.isAnnotation()) {
                     if (!clazz.isAnnotationPresent(ComponentCategory.class)) {
                         throw new IllegalArgumentException("Annotation [" + clazz.getName() + "] specified on area [" + area.getHandlerClass().getName() + "] is not a @ComponentCategory");
                     }
 
                     List<String> templatesInCategory = detectedHandlers.getTemplatesInCategory((Class<? extends Annotation>) clazz);
                     for (String componentId : templatesInCategory) {
                         ConfiguredComponentAvailability availability = new ConfiguredComponentAvailability();
                         availability.setId(componentId);
                         map.put(componentId, availability);
                     }
                 } else {
                     String componentId = resolveTemplateId(clazz);
                     ConfiguredComponentAvailability availability = new ConfiguredComponentAvailability();
                     availability.setId(componentId);
                     map.put(componentId, availability);
                 }
             }
         }
         return map;
     }
 
     protected InheritanceConfiguration resolveInheritanceConfiguration(HandlerMetaData area) {
         Inherits inherits = area.getHandlerClass().getAnnotation(Inherits.class);
         ConfiguredInheritance inheritance = new ConfiguredInheritance();
         if (inherits != null) {
             inheritance.setEnabled(true);
             inheritance.setComponents(inherits.components().getConfigurationFormat());
             inheritance.setProperties(inherits.properties().getConfigurationFormat());
         }
         return inheritance;
     }
 
     protected TemplateAvailability resolveTemplateAvailability(HandlerMetaData template) {
         Method method = resolveTemplateAvailabilityMethod(template);
         if (method != null) {
             return new DefaultTemplateAvailability(template.getHandler(), method);
         }
         return null;
     }
 
     protected Method resolveTemplateAvailabilityMethod(HandlerMetaData template) {
 
         final Class<?> handlerClass = template.getHandlerClass();
         final List<Method> matchingMethods = new ArrayList<Method>();
 
         // Iterate class hierarchy to find the method also in super classes
 
         Class<?> clazz = handlerClass;
         while (matchingMethods.isEmpty() && clazz != null) {
             Method[] methods = clazz.getDeclaredMethods();
             for (final Method method : methods) {
 
                 // The method must have the annotation
                 if (!method.isAnnotationPresent(Available.class)) {
                     continue;
                 }
 
                 // The method must not be overridden
                 if (!method.equals(ClassUtils.getMostSpecificMethod(method, handlerClass))) {
                     continue;
                 }
 
                 if (!method.getReturnType().equals(Boolean.TYPE)) {
                     if (logger.isWarnEnabled()) {
                         logger.warn("Method annotated with @Available has wrong return type [" + method.getClass() + "] should be boolean.");
                     }
                     continue;
                 }
 
                 matchingMethods.add(method);
             }
             clazz = clazz.getSuperclass();
         }
 
         if (matchingMethods.size() == 0) {
             return null;
         } else if (matchingMethods.size() == 1) {
             return matchingMethods.get(0);
         } else {
             throw new IllegalStateException("Multiple @Available annotated methods found for handler [" + handlerClass + "]");
         }
     }
 
     protected ParameterResolver getTemplateAvailabilityParameters(final Node node, final TemplateDefinition templateDefinition) {
         return new ParameterResolver() {
 
             @Override
             public Object resolveParameter(Class<?> parameterType) {
                 if (parameterType.equals(Node.class)) {
                     return node;
                 }
                 if (parameterType.equals(Content.class)) {
                     return ContentUtil.asContent(node);
                 }
                 if (parameterType.equals(TemplateDefinition.class)) {
                     return templateDefinition;
                 }
                 return super.resolveParameter(parameterType);
             }
         };
     }
 
     private class DefaultTemplateAvailability implements TemplateAvailability {
 
         private final Object handler;
         private final Method method;
 
         public DefaultTemplateAvailability(Object handler, Method method) {
             this.handler = handler;
             this.method = method;
         }
 
         @Override
         public boolean isAvailable(Node node, TemplateDefinition templateDefinition) {
             ParameterResolver parameters = getTemplateAvailabilityParameters(node, templateDefinition);
             return (Boolean) MethodInvocationUtils.invoke(method, handler, parameters);
         }
     }
 }