/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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
    *
    *     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 de.smartics.properties.impl.config.domain.key.envapp;
  
  import static de.smartics.properties.api.core.domain.ConfigMessageBean.systemId;
  
  import static de.smartics.properties.api.core.domain.ConfigMessageBean.duplicate;
  import java.io.BufferedInputStream;
  import java.io.InputStream;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang.StringUtils;
  import org.jdom.Element;
  import org.jdom.Namespace;
  
  import de.smartics.properties.api.config.domain.key.ApplicationId;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.config.domain.key.EnvironmentId;
  import de.smartics.properties.api.core.domain.ConfigCode;
  import de.smartics.properties.api.core.domain.ConfigException;
  import de.smartics.properties.api.core.domain.DuplicateDefaultKeyException;
  import de.smartics.properties.api.core.domain.PropertiesContext;
  import de.smartics.properties.spi.config.definition.DefinitionConfigParser;
  import de.smartics.properties.spi.config.definition.PropertiesDefinitionContext;
  import de.smartics.properties.spi.config.domain.key.PathMatcher;
  import de.smartics.properties.spi.config.domain.key.PropertiesResourceMatcher;
  import de.smartics.properties.spi.config.domain.key.PropertyResourceMatchers;
  import de.smartics.properties.spi.core.util.ClassLoaderUtils;
  import de.smartics.util.lang.classpath.ClassPathContext;
  
  /**
   * Base implementation for parsing a <code>definition.xml</code> file for
   * properties.
   *
   * @param <T> the type of context returned by the parser.
   */
  public abstract class AbstractDefinitionConfigParser<T extends PropertiesDefinitionContext>
      implements DefinitionConfigParser<T>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The namespace of definition files parsed by this parser.
     */
    protected final Namespace namespace;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param namespace the namespace of definition files parsed by this parser.
     */
    protected AbstractDefinitionConfigParser(final Namespace namespace)
    {
      this.namespace = namespace;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Convenience method using a class' class loader to locate the configuration
     * file to parse the configuration file at
     * {@link PropertiesContext#DEFINITION_FILE}.
     *
     * @param type the type whose class loader to use to locate the configuration
     *          file.
    * @return the read configuration, never <code>null</code>.
    * @throws ConfigException on any problem loading the file.
    */
   @Override
   public final T parse(final Class<?> type) throws ConfigException
   {
     final ClassLoader loader = type.getClassLoader();
     final String path = ClassLoaderUtils.calcArchivePath(type);
     return parse(new ClassPathContext(loader, path));
   }
 
   /**
    * Parses the configuration file at {@link PropertiesContext#DEFINITION_FILE}.
    *
    * @param context the class loader with its context to use to locate the
    *          configuration file.
    * @return the read configuration, never <code>null</code>.
    * @throws ConfigException on any problem loading the file.
    */
   @Override
   public final T parse(final ClassPathContext context) throws ConfigException
   {
     final URL url = context.getResource(PropertiesContext.DEFINITION_FILE);
     if (url != null)
     {
       final String systemId = url.toExternalForm();
       InputStream in = null;
       try
       {
         in =
             new BufferedInputStream(
                 context.getResourceAsStream(PropertiesContext.DEFINITION_FILE));
         return parse(systemId, in);
       }
       finally
       {
         IOUtils.closeQuietly(in);
       }
     }
     throw new ConfigException(systemId(ConfigCode.CONFIG_FILE_NOT_FOUND,
         PropertiesContext.DEFINITION_FILE));
   }
 
   /**
    * Parses a set.
    *
    * @param rootNode the root node that contains the set.
    * @param setGi the name of the element that is the set.
    * @param elementGi the name of the elements within the set.
    * @return the parsed set.
    */
   protected final Set<String> readSet(final Element rootNode,
       final String setGi, final String elementGi)
   {
     return readSet(rootNode, setGi, elementGi, new HashSet<String>());
   }
 
   /**
    * Parses a set.
    *
    * @param rootNode the root node that contains the set.
    * @param setGi the name of the element that is the set.
    * @param elementGi the name of the elements within the set.
    * @param defaultSet the set to return if no set is found within the root
    *          node.
    * @return the parsed set.
    */
   @SuppressWarnings("unchecked")
   protected final Set<String> readSet(final Element rootNode,
       final String setGi, final String elementGi, final Set<String> defaultSet)
   {
     final Element set = rootNode.getChild(setGi, namespace);
     if (set != null)
     {
       final Set<String> collection = new HashSet<String>();
       final List<Element> elements = set.getChildren(elementGi, namespace);
       for (final Element element : elements)
       {
         final String text = element.getTextNormalize();
         collection.add(text);
       }
 
       return collection;
     }
 
     return defaultSet;
   }
 
   /**
    * Parsed the map of files from the given element.
    *
    * @param systemId the identifier of the configuration file that is parsed.
    * @param rootNode the node within which the files are.
    * @return the map of files.
    * @throws ConfigException if the configuration is not valid.
    */
   @SuppressWarnings("unchecked")
   protected final PropertyResourceMatchers readFiles(final String systemId,
       final Element rootNode) throws ConfigException
   {
     final List<PropertiesResourceMatcher> matchers =
         new ArrayList<PropertiesResourceMatcher>();
     ConfigurationKey<?> anyKey = null;
 
     final Element keySet = rootNode.getChild("key-set", namespace);
     if (keySet != null)
     {
       final List<Element> elements = keySet.getChildren("key", namespace);
       for (final Element element : elements)
       {
         final ConfigurationKey<?> key = readKey(element);
         final Element files = element.getChild("files", namespace);
         if (files != null)
         {
           final List<Element> fileElements =
               files.getChildren("file", namespace);
           final List<PathMatcher.Matcher> pathMatcher =
               new ArrayList<PathMatcher.Matcher>(fileElements.size());
           for (final Element file : fileElements)
           {
             final String text = file.getTextNormalize();
             final PathMatcher.Matcher matcher = new PathMatcher.Matcher(text);
             pathMatcher.add(matcher);
           }
           final PropertiesResourceMatcher matcher =
               PathMatcher.forMatchers(key, pathMatcher);
           matchers.add(matcher);
         }
         else
         {
           checkDuplication(systemId, anyKey, key);
           anyKey = key;
         }
       }
     }
 
     return new PropertyResourceMatchers(anyKey, matchers);
   }
 
   private void checkDuplication(final String systemId,
       final ConfigurationKey<?> anyKey, final ConfigurationKey<?> key)
   {
     if (anyKey != null)
     {
       throw new DuplicateDefaultKeyException(duplicate(systemId,
           anyKey.toString(), key.toString()));
     }
   }
 
   /**
    * Parses the configuration key.
    *
    * @param element the element within which the elements of the key are
    *          located.
    * @return the configuration key.
    */
   protected abstract ConfigurationKey<?> readKey(Element element);
 
   /**
    * Parses environment information.
    *
    * @param rootNode the element to parse from.
    * @return the environment information.
    */
   protected final EnvironmentId readEnvironment(final Element rootNode)
   {
     final Element environment = rootNode.getChild("environment", namespace);
 
     final EnvironmentId environmentId;
     if (environment != null)
     {
       final String name =
           norm(environment.getChildTextNormalize("name", namespace));
       final String node =
           norm(environment.getChildTextNormalize("node", namespace));
 
       environmentId = new EnvironmentId(name, node);
     }
     else
     {
       environmentId = EnvironmentId.ANY_ENV;
     }
     return environmentId;
   }
 
   /**
    * Parses application information.
    *
    * @param rootNode the element to parse from.
    * @return the application information.
    */
   protected final ApplicationId readApplication(final Element rootNode)
   {
     final Element application = rootNode.getChild("application", namespace);
 
     final ApplicationId applicationId;
     if (application != null)
     {
       final String group =
           norm(application.getChildTextNormalize("group", namespace));
       final String artifact =
           norm(application.getChildTextNormalize("artifact", namespace));
       final String version =
           norm(application.getChildTextNormalize("version", namespace));
       applicationId = new ApplicationId(group, artifact, version);
     }
     else
     {
       applicationId = ApplicationId.ANY_APP;
     }
     return applicationId;
   }
 
   /**
    * Normalizes the text.
    *
    * @param text the text to normalize.
    * @return <code>null</code> if {@code text} is blank, the text otherwise.
    */
   protected static final String norm(final String text)
   {
     if (StringUtils.isBlank(text))
     {
       return null;
     }
     return text;
   }
 
   // --- object basics --------------------------------------------------------
 
 }