/*

  * 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.spi.config.definition;

 import java.io.BufferedInputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.net.URL;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.apache.commons.io.IOUtils;

 import org.apache.commons.lang.StringUtils;

 import org.jdom.Document;

 import org.jdom.Element;

 import org.jdom.JDOMException;

 import org.jdom.Namespace;

 import org.jdom.input.SAXBuilder;

 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.ConfigException;

 import de.smartics.properties.api.core.domain.PropertiesContext;

 import de.smartics.properties.spi.core.util.ClassLoaderUtils;

 import de.smartics.util.lang.ClassPathContext;

 import de.smartics.util.lang.NullArgumentException;

 /**

  * Parses the <code>definition.xml</code> file for properties.

  */

 public final class DefinitionConfigParser

 {

   // ********************************* Fields *********************************

   // --- constants ------------------------------------------------------------

   // --- members --------------------------------------------------------------

   /**

    * The namespace of definition files parsed by this parser.

    */

   private static final Namespace NS = Namespace

       .getNamespace("http://smartics.de/properties/definition/1");

   // ****************************** Initializer *******************************

   // ****************************** Constructors ******************************

   // ****************************** Inner Classes *****************************

   // ********************************* Methods ********************************

   // --- init -----------------------------------------------------------------

   // --- get&set --------------------------------------------------------------

   // --- business -------------------------------------------------------------

   /**

    * Default constructor.

    */

   public DefinitionConfigParser()

   {

   }

   // --- object basics --------------------------------------------------------

   /**

    * 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.

    */

   public PropertiesDefinitionContext 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.

    */

   public PropertiesDefinitionContext 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(PropertiesContext.DEFINITION_FILE);

   }

   /**

    * Parses the <code>definition.xml</code> from the given stream.

    *

    * @param systemId the identifier of the resource on the stream.

    * @param input the <code>definition.xml</code> on the stream.

    * @return the parsed context.

    * @throws ConfigException on any problem reading from the stream.

    */

   public PropertiesDefinitionContext parse(final String systemId,

       final InputStream input) throws ConfigException

   {

     try

     {

       final SAXBuilder parser = new SAXBuilder();

       final Document document = parser.build(input, systemId);

       final Element rootNode = document.getRootElement();

       final Set<String> tlds = readSet(rootNode, "tlds", "tld", null);

       final Set<String> environments =

           readSet(rootNode, "environments", "environment");

       final Set<String> nodes = readSet(rootNode, "nodes", "node");

       final Set<String> groups = readSet(rootNode, "groups", "group");

       final Map<String, ConfigurationKey> files = readFiles(rootNode);

       final PropertiesDefinitionContext context;

       if (tlds == null)

       {

         context =

             new PropertiesDefinitionContext(environments, nodes, groups, files);

       }

       else

       {

         context =

             new PropertiesDefinitionContext(tlds, environments, nodes, groups,

                 files);

       }

       return context;

     }

     catch (final JDOMException e)

     {

       throw new ConfigException(systemId, e);

     }

     catch (final IOException e)

     {

       throw new ConfigException(systemId, e);

     }

   }

   private Set<String> readSet(final Element rootNode, final String setGi,

       final String elementGi)

   {

     return readSet(rootNode, setGi, elementGi, new HashSet<String>());

   }

   @SuppressWarnings("unchecked")

   private Set<String> readSet(final Element rootNode, final String setGi,

       final String elementGi, final Set<String> defaultSet)

   {

     final Element set = rootNode.getChild(setGi, NS);

     if (set != null)

     {

       final Set<String> collection = new HashSet<String>();

       final List<Element> elements = set.getChildren(elementGi, NS);

       for (final Element element : elements)

       {

         final String text = element.getTextNormalize();

         collection.add(text);

       }

       return collection;

     }

     return defaultSet;

   }

   @SuppressWarnings("unchecked")

   private Map<String, ConfigurationKey> readFiles(final Element rootNode)

   {

     final Map<String, ConfigurationKey> keys =

         new HashMap<String, ConfigurationKey>();

     final Element keySet = rootNode.getChild("key-set", NS);

     if (keySet != null)

     {

       final List<Element> elements = keySet.getChildren("key", NS);

       for (final Element element : elements)

       {

         final ConfigurationKey key = readKey(element);

         final Element files = element.getChild("files", NS);

         if (files != null)

         {

           final List<Element> fileElements = files.getChildren("file", NS);

           for (final Element file : fileElements)

           {

             final String text = file.getTextNormalize();

             keys.put(text, key);

           }

         }

         else

         {

           keys.put(null, key);

         }

       }

     }

     return keys;

   }

   private ConfigurationKey readKey(final Element element)

     throws NullArgumentException

   {

     final EnvironmentId environmentId = readEnvironment(element);

     final ApplicationId applicationId = readApplication(element);

     final ConfigurationKey key =

         new ConfigurationKey(environmentId, applicationId);

     return key;

   }

   private EnvironmentId readEnvironment(final Element element)

   {

     final Element environment = element.getChild("environment", NS);

     final EnvironmentId environmentId;

     if (environment != null)

     {

       final String name = norm(environment.getChildTextNormalize("name", NS));

       final String node = norm(environment.getChildTextNormalize("node", NS));

       environmentId = new EnvironmentId(name, node);

     }

     else

     {

       environmentId = EnvironmentId.ANY_ENV;

     }

     return environmentId;

   }

   private ApplicationId readApplication(final Element element)

   {

     final Element application = element.getChild("application", NS);

     final ApplicationId applicationId;

     if (application != null)

     {

       final String group = norm(application.getChildTextNormalize("group", NS));

       final String artifact =

           norm(application.getChildTextNormalize("artifact", NS));

       final String version =

           norm(application.getChildTextNormalize("version", NS));

       applicationId = new ApplicationId(group, artifact, version);

     }

     else

     {

       applicationId = ApplicationId.ANY_APP;

     }

     return applicationId;

   }

   private static String norm(final String text)

   {

     if (StringUtils.isBlank(text))

     {

       return null;

     }

     return text;

   }

 }