EnvAppDefinitionKeyHelper

/*
 * 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.config.domain.key.ApplicationId.ANY_APP;
import static de.smartics.properties.api.config.domain.key.EnvironmentId.ANY_ENV;

import java.io.Serializable;
import java.util.StringTokenizer;

import javax.annotation.concurrent.ThreadSafe;

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.spi.config.definition.DefinitionKeyHelper;
import de.smartics.properties.spi.config.domain.key.ConfigurationKeyContextManager;
import de.smartics.util.lang.Arg;

/**
 * Derives a {@link ConfigurationKey} from a path found in a definition file.
 */
@ThreadSafe
public final class EnvAppDefinitionKeyHelper implements Serializable,
    DefinitionKeyHelper
{
  // ********************************* Fields *********************************

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

  /**
   * The class version identifier.
   */
  private static final long serialVersionUID = 1L;

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

  /**
   * The context to evaluate the configuration keys from properties file paths.
   *
   * @serial
   */
  private final EnvAppPropertiesDefinitionContext context;

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

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

  /**
   * Convenience constructor using the default TLDs and not registering any
   * environments, nodes or groups.
   */
  public EnvAppDefinitionKeyHelper()
  {
    this(new EnvAppPropertiesDefinitionContext());
  }

  /**
   * Default constructor.
   *
   * @param context the context to evaluate the configuration keys from
   *          properties file paths.
   * @throws NullPointerException if {@code context} is <code>null</code>.
   */
  public EnvAppDefinitionKeyHelper(
      final EnvAppPropertiesDefinitionContext context)
    throws NullPointerException
  {
    this.context = Arg.checkNotNull("context", context);
  }

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

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

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

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

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

  /**
   * Parses the given path to create a configuration key.
   * <p>
   * The expected syntax is as follows:
   * </p>
   * <ol>
   * <li><code>/environment</code></li>
   * <li><code>/environment/node</code></li>
   * <li><code>/environment/node/group</code></li>
   * <li><code>/environment/node/group/application</code></li>
   * <li><code>/environment/node/group/application/version</code></li>
   * <li><code>/environment/group</code></li>
   * <li><code>/environment/group/application</code></li>
   * <li><code>/environment/group/application/version</code></li>
   * <li><code>/group</code></li>
   * <li><code>/group/application</code></li>
   * <li><code>/group/application/version</code></li>
   * </ol>
   * <p>
   * A file ending with properties following the path will be chopped.
   * </p>
   * <p>
   * The parser has to determine whether a part of the path is a
   * <code>environment</code>, a <code>node</code> or a <code>group</code>.
   * Since a <code>node</code> is always prefixed by an <code>environment</code>
   * only the following two cases have to be dealt with:
   * </p>
   * <ol>
   * <li><code>environment</code> vs. <code>group</code></li>
   * <li><code>node</code> vs. <code>group</code></li>
   * </ol>
   * <p>
   * <code>group</code>s start with
   * </p>
   * <ol>
   * <li>A TLD as registered by default by
   * {@link TenantUserPropertiesDefinitionContext#DEFAULT_TLDS} or explicitly
   * registered with {@link TenantUserPropertiesDefinitionContext}</li>
   * <li>Two letters followed by a dot (<code>.</code>)</li>
   * <li>Any sequence of characters that is explicitly registered as a group in
   * the <code>definition.xml</code> file</li>
   * </ol>
   * <p>
   * <code>environment</code>s and <code>node</code>s do not start as
   * <code>groups</code> except they are explicitly registered in the
   * <code>definition.xml</code> file.
   * </p>
   *
   * @param pathWithFile the path to parse.
   * @return the configuration key.
   * @throws IllegalArgumentException if the given {@code path} is not valid
   *           according to the rules given above.
   */
  @Override
  public ConfigurationKey<?> parse(final String pathWithFile)
    throws IllegalArgumentException
  {
    final ConfigurationKey<?> explicitKey = fetchExplicitKey(pathWithFile);
    if (explicitKey != null)
    {
      return explicitKey;
    }

    final String path = chopFile(pathWithFile);

    final StringTokenizer tokenizer = new StringTokenizer(path, "/");
    if (tokenizer.hasMoreTokens())
    {
      final ConfigurationKey<?> key;

      final String token = tokenizer.nextToken();
      if (isGroup(token))
      {
        key = parseApplicationKey(token, tokenizer);
      }
      else
      {
        key = parseEnvironmentKey(token, tokenizer);
      }

      return key;
    }

    return ConfigurationKeyContextManager.INSTANCE.context()
        .configurationKeyFactory().createDefaultKey();
    // throw new IllegalArgumentException(
    // "Path '" + path + "' does not contain an environment or group.");
  }

  private static String chopFile(final String pathWithFile)
  {
    if (pathWithFile.endsWith(".properties"))
    {
      final int lastSlash = pathWithFile.lastIndexOf('/');
      if (lastSlash != -1)
      {
        final String path = pathWithFile.substring(0, lastSlash);
        return path;
      }

      return "";
    }
    return pathWithFile;
  }

  private ConfigurationKey<?> fetchExplicitKey(final String path)
  {
    ConfigurationKey<?> key = context.getKey(path);
    if (key == null)
    {
      key = context.getKey(null);
    }
    return key;
  }

  private boolean isGroup(final String token)
  {
    if (context.isRegisteredEnvironment(token)
        || context.isRegisteredNode(token))
    {
      return false;
    }

    return context.isGroup(token);
  }

  private ConfigurationKey<?> parseEnvironmentKey(final String environment,
      final StringTokenizer tokenizer)
  {
    final EnvironmentId envId;
    final ApplicationId appId;
    if (tokenizer.hasMoreTokens())
    {
      final String token = tokenizer.nextToken();
      if (isGroup(token))
      {
        envId = new EnvironmentId(environment);
        appId = parseAppId(token, tokenizer);
      }
      else
      {
        envId = new EnvironmentId(environment, token);
        if (tokenizer.hasMoreTokens())
        {
          appId = parseAppId(tokenizer.nextToken(), tokenizer);
        }
        else
        {
          appId = ANY_APP;
        }
      }
    }
    else
    {
      envId = new EnvironmentId(environment);
      appId = ANY_APP;
    }

    final ConfigurationKey<?> key = new EnvAppConfigurationKey(envId, appId);

    return key;
  }

  private ApplicationId parseAppId(final String group,
      final StringTokenizer tokenizer)
  {
    String artifact = null;
    String version = null;
    if (tokenizer.hasMoreTokens())
    {
      artifact = tokenizer.nextToken();
      if (tokenizer.hasMoreTokens())
      {
        version = tokenizer.nextToken();
      }
    }

    return new ApplicationId(group, artifact, version);
  }

  private ConfigurationKey<?> parseApplicationKey(final String group,
      final StringTokenizer tokenizer)
  {
    final EnvironmentId envId = ANY_ENV;
    final ApplicationId appId = parseAppId(group, tokenizer);

    return new EnvAppConfigurationKey(envId, appId);
  }

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

}