/*
    * 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.rtaware;
  
  import static de.smartics.properties.api.core.domain.ConfigMessageBean.namespace;
  import static de.smartics.properties.api.core.domain.ConfigMessageBean.systemId;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Set;
  
  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.ConfigCode;
  import de.smartics.properties.api.core.domain.ConfigException;
  import de.smartics.properties.impl.config.domain.key.envapp.AbstractDefinitionConfigParser;
  import de.smartics.properties.spi.config.domain.key.PropertyResourceMatchers;
  import de.smartics.util.lang.NullArgumentException;
  
  /**
   * Parses the <code>definition.xml</code> file for properties.
   */
  public final class TenantUserDefinitionConfigParser extends
      AbstractDefinitionConfigParser<TenantUserPropertiesDefinitionContext>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The namespace of definition files parsed by this parser.
     */
    private static final Namespace NS = Namespace
        .getNamespace("http://smartics.de/properties/definition/rt/1");
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Default constructor.
     */
    public TenantUserDefinitionConfigParser()
    {
      super(NS);
    }
  
    // --- object basics --------------------------------------------------------
  
    /**
     * 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.
     */
    @Override
    public TenantUserPropertiesDefinitionContext parse(final String systemId,
        final InputStream input) throws ConfigException
    {
      try
      {
        final SAXBuilder parser = new SAXBuilder();
        final Document document = parser.build(input, systemId);
  
        checkNamespace(systemId, document);
 
       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 PropertyResourceMatchers files = readFiles(systemId, rootNode);
 
       final TenantUserPropertiesDefinitionContext context;
       if (tlds == null)
       {
         context =
             new TenantUserPropertiesDefinitionContext(environments, nodes,
                 groups, files);
       }
       else
       {
         context =
             new TenantUserPropertiesDefinitionContext(tlds, environments,
                 nodes, groups, files);
       }
       return context;
     }
     catch (final JDOMException e)
     {
       throw new ConfigException(systemId(ConfigCode.CONFIG_FILE_CANNOT_BE_READ,
           e, systemId));
     }
     catch (final IOException e)
     {
       throw new ConfigException(systemId(ConfigCode.CONFIG_FILE_CANNOT_BE_READ,
           e, systemId));
     }
   }
 
   private static void checkNamespace(final String systemId,
       final Document document)
   {
     final Namespace actualNamespace = document.getRootElement().getNamespace();
     if (!NS.equals(actualNamespace))
     {
       throw new ConfigException(namespace(systemId, NS.getURI(),
           actualNamespace.getURI()));
     }
   }
 
   @Override
   protected ConfigurationKey<?> readKey(final Element element)
     throws NullArgumentException
   {
     final EnvironmentId environmentId = readEnvironment(element);
     final ApplicationId applicationId = readApplication(element);
     final TenantId tenantId = readTenant(element);
     final UserId userId = readUser(element);
 
     final ConfigurationKey<?> key =
         new TenantUserConfigurationKey(environmentId, applicationId, tenantId,
             userId);
     return key;
   }
 
   private TenantId readTenant(final Element element)
   {
     final Element tenant = element.getChild("tenant", namespace);
 
     final TenantId tenantId;
     if (tenant != null)
     {
       final String name = norm(tenant.getChildTextNormalize("name", namespace));
 
       tenantId = new TenantId(name);
     }
     else
     {
       tenantId = TenantId.ANY_TENANT;
     }
     return tenantId;
   }
 
   private UserId readUser(final Element element)
   {
     final Element user = element.getChild("user", namespace);
 
     final UserId userId;
     if (user != null)
     {
       final String name = norm(user.getChildTextNormalize("name", namespace));
 
       userId = new UserId(name);
     }
     else
     {
       userId = UserId.ANY_USER;
     }
     return userId;
   }
 }