/*
    * $Id: ResolvingLocaleUrlDefinitionDAO.java 1297705 2012-03-06 20:44:30Z nlebas $
    *
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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
   *
   * http://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.apache.tiles.definition.dao;
  
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.tiles.Definition;
  import org.apache.tiles.definition.NoSuchDefinitionException;
  import org.apache.tiles.request.ApplicationContext;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * <p>
   * A definitions DAO (loading URLs and using Locale as a customization key) that
   * caches definitions that have been loaded and resolves inheritances.
   * </p>
   * <p>
   * It can check if the URLs change, but by default this feature is turned off.
   * </p>
   *
   * @version $Rev: 1297705 $ $Date: 2012-03-07 07:44:30 +1100 (Wed, 07 Mar 2012) $
   * @since 2.1.0
   */
  public class ResolvingLocaleUrlDefinitionDAO extends
          CachingLocaleUrlDefinitionDAO {
  
      /**
       * The logging object.
       */
      private final Logger log = LoggerFactory.getLogger(ResolvingLocaleUrlDefinitionDAO.class);
  
      public ResolvingLocaleUrlDefinitionDAO(ApplicationContext applicationContext) {
          super(applicationContext);
      }
  
      /** {@inheritDoc} */
      @Override
      protected Map<String, Definition> loadParentDefinitions(Locale parentLocale) {
          return loadRawDefinitionsFromResources(parentLocale);
      }
  
      @Override
      protected Map<String, Definition> loadDefinitions(Locale customizationKey) {
          Map<String, Definition> localeDefsMap = super.loadDefinitions(customizationKey);
          Map<String, Definition> defsMap = definitionResolver
                  .storeDefinitionPatterns(copyDefinitionMap(localeDefsMap),
                          customizationKey);
          resolveInheritances(defsMap, customizationKey);
          locale2definitionMap.put(customizationKey, defsMap);
          return defsMap;
      }
  
      /** {@inheritDoc} */
      @Override
      protected Definition getDefinitionFromResolver(String name,
              Locale customizationKey) {
          Definition retValue = super.getDefinitionFromResolver(name, customizationKey);
          if (retValue != null && retValue.getExtends() != null) {
              Definition parent = getDefinition(retValue.getExtends(), customizationKey);
              retValue.inherit(parent);
          }
  
          return retValue;
      }
  
      /**
       * Resolve locale-specific extended instances.
       *
       * @param map The definition map containing the definitions to resolve.
       * @param locale The locale to use.
       * @throws NoSuchDefinitionException If a parent definition is not found.
       * @since 2.1.0
       */
      protected void resolveInheritances(Map<String, Definition> map, Locale locale) {
          if (map != null) {
             Set<String> alreadyResolvedDefinitions = new HashSet<String>();
             for (Definition definition : map.values()) {
                 resolveInheritance(definition, map, locale,
                         alreadyResolvedDefinitions);
             }  // end loop
         }
     }
 
     /**
      * Resolve locale-specific inheritance. First, resolve parent's inheritance,
      * then set template to the parent's template. Also copy attributes setted
      * in parent, and not set in child If instance doesn't extend anything, do
      * nothing.
      *
      * @param definition The definition to resolve
      * @param definitions The definitions to take when obtaining a parent
      * definition.
      * @param locale The locale to use.
      * @param alreadyResolvedDefinitions The set of the definitions that have
      * been already resolved.
      * @throws NoSuchDefinitionException If an inheritance can not be solved.
      * @since 2.1.0
      */
     protected void resolveInheritance(Definition definition,
             Map<String, Definition> definitions, Locale locale,
             Set<String> alreadyResolvedDefinitions) {
         // Already done, or not needed ?
         if (!definition.isExtending()
                 || alreadyResolvedDefinitions.contains(definition.getName())) {
             return;
         }
 
         log.debug("Resolve definition for child name='{}' extends='{}.",
                 definition.getName(), definition.getExtends());
 
         // Set as visited to avoid endless recursivity.
         alreadyResolvedDefinitions.add(definition.getName());
 
         // Resolve parent before itself.
         Definition parent = definitions.get(definition.getExtends());
         if (parent == null) { // error
             String msg = "Error while resolving definition inheritance: child '"
                 + definition.getName()
                 + "' can't find its ancestor '"
                 + definition.getExtends()
                 + "'. Please check your description file.";
             // to do : find better exception
             throw new NoSuchDefinitionException(msg);
         }
 
         resolveInheritance(parent, definitions, locale,
                 alreadyResolvedDefinitions);
 
         definition.inherit(parent);
     }
 
     /**
      * Copies the definition map to be passed to a higher level of customization
      * key.
      *
      * @param localeDefsMap The map of definition to be copied.
      * @return The copy of the definition map. This particular implementation
      * deep-copies the <code>localeDefsMap</code> into a {@link LinkedHashMap}.
      * @since 2.1.4
      */
     @Override
     protected Map<String, Definition> copyDefinitionMap(
             Map<String, Definition> localeDefsMap) {
         Map<String, Definition> retValue = new LinkedHashMap<String, Definition>(
                 localeDefsMap.size());
 
         for (Map.Entry<String, Definition> entry : localeDefsMap.entrySet()) {
             Definition definition = new Definition(entry.getValue());
             retValue.put(entry.getKey(), definition);
         }
 
         return retValue;
     }
 }