/*
    * Copyright 2009, Josh Devins, Jitr.org.
    *
    * 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 org.jitr;
  
  import org.apache.log4j.Logger;
  import org.jitr.annotation.JitrConfiguration;
  import org.jitr.container.JettyContainer;
  import org.jitr.core.ConfigurationModel;
  import org.jitr.core.Container;
  import org.jitr.core.Defaults;
  import org.jitr.core.JitrException;
  import org.jitr.core.OperationalMode;
  
  /**
   * A simple factory for creating {@link ConfigurationModel}s. This takes into account any
   * {@link JitrConfiguration} annotations as well as any overriding system properties.
   * 
   * @author Josh Devins (info@joshdevins.net)
   */
  public final class JitrConfigurationFactory {
  
      private static enum From {
          SYSTEM_PROPERTY("system property"), ANNOTATION("annotation"), DEFAULT("default"), OTHER;
  
          private final String str;
  
          private From() {
              str = null;
          }
  
          private From(final String str) {
              this.str = str;
          }
  
          @Override
          public String toString() {
              return str == null ? super.toString() : str;
          }
      }
  
      /**
       * Prefix string used for all Jitr system properties.
       */
      public static final String SP_KEY_PREFIX = "jitr.";
  
      /**
       * The system property key to use when setting the base URI from the command line. This is
       * mostly useful when disabling the container from the command line and you are taking care of
       * running the container yourself.
       * 
       * {@value #BASE_URI_SP_KEY}
       * 
       * @see #MODE_SP_KEY
       */
      public static final String BASE_URI_SP_KEY = SP_KEY_PREFIX + "baseUri";
  
      /**
       * The system property key to use when setting the container class from the command line.
       * 
       * {@value #MODE_SP_KEY}
       */
      public static final String CONTAINER_CLASS_SP_KEY = SP_KEY_PREFIX + "containerClass";
  
      /**
       * The system property key to use when setting the operational mode from the command line.
       * 
       * {@value #MODE_SP_KEY}
       */
      public static final String MODE_SP_KEY = SP_KEY_PREFIX + "mode";
  
      /**
       * The system property key to use when setting the port from the command line. This is mostly
       * useful when disabling the container from the command line and you are taking care of running
       * the container yourself.
       * 
       * {@value #PORT_SP_KEY}
       * 
       * @see #MODE_SP_KEY
       */
      public static final String PORT_SP_KEY = SP_KEY_PREFIX + "port";
  
      private static final Logger LOG = Logger.getLogger(JitrConfigurationFactory.class);
  
      private JitrConfigurationFactory() {
          // do not instantiate
     }
 
     public static ConfigurationModel createConfigurationFromAnnotation(final JitrConfiguration annot) {
 
         final Class<?> containerClass = determineContainerClass(annot);
         final String containerWorkPath = determineContainerWorkPath(annot);
         final String contextPath = determineContextPath(annot);
         final OperationalMode mode = determineOperationalMode(annot);
         final int port = determinePort(annot);
         final String warPath = determineWarPath(annot);
 
         // determine after port and context path
         final String baseUri = determineBaseUri(port, contextPath);
 
         ConfigurationModel config =
                 new ConfigurationModel(baseUri, containerClass, containerWorkPath, contextPath,
                         mode, port, warPath);
 
         return config;
     }
 
     static String determineBaseUri(final int port, final String contextPath) {
 
         final From from;
         final String baseUri;
 
         // always use system property first
         final String baseUriSp = System.getProperty(BASE_URI_SP_KEY);
         if (baseUriSp != null) {
 
             baseUri = baseUriSp;
             from = From.SYSTEM_PROPERTY;
         }
 
         // otherwise use the port and context path parameters
         else {
             baseUri = "http://localhost:" + port + contextPath;
             from = From.OTHER;
         }
 
         logSettingConfigValue("base URI", from, baseUri);
 
         return baseUri;
     }
 
     static Class<?> determineContainerClass(final JitrConfiguration annot) {
 
         final From from;
         final Class<?> containerClass;
 
         // always use system property first
         final String containerClassSp = System.getProperty(CONTAINER_CLASS_SP_KEY);
         if (containerClassSp != null) {
             try {
                 containerClass = Class.forName(containerClassSp);
                 from = From.SYSTEM_PROPERTY;
             } catch (final ClassNotFoundException cnfe) {
                 throw new JitrException(
                         "Could not load specified container class (" + containerClassSp
                                 + "). Make sure you use the fully qualified class name.", cnfe);
             }
         }
 
         // otherwise use value from annotation (if it exists)
         else if (annot != null) {
             if (annot.containerClass() != Object.class) {
                 containerClass = annot.containerClass();
             } else {
                 containerClass = JettyContainer.class;
             }
 
             from = From.ANNOTATION;
         } else {
             containerClass = JettyContainer.class;
             from = From.DEFAULT;
         }
 
         // make sure the class is of type Container
         if (!Container.class.isAssignableFrom(containerClass)) {
             throw new JitrException("Container class is not of type Container: "
                     + containerClass.toString());
         }
 
         logSettingConfigValue("container class", from, containerClass.toString());
 
         return containerClass;
     }
 
     static String determineContainerWorkPath(final JitrConfiguration annot) {
 
         final From from;
         final String containerWorkPath;
 
         // if no annotation, use default value
         if (annot == null) {
             containerWorkPath = Defaults.DEFAULT_CONTAINER_WORK_PATH;
             from = From.DEFAULT;
         } else {
             containerWorkPath = annot.containerWorkPath();
             from = From.ANNOTATION;
         }
 
         logSettingConfigValue("container work path", from, containerWorkPath);
 
         return containerWorkPath;
     }
 
     static String determineContextPath(final JitrConfiguration annot) {
 
         final From from;
         final String contextPath;
 
         // if no annotation, use default value
         if (annot == null) {
             contextPath = Defaults.DEFAULT_CONTEXT_PATH;
             from = From.DEFAULT;
         } else {
             contextPath = annot.contextPath();
             from = From.ANNOTATION;
         }
 
         logSettingConfigValue("context path", from, contextPath);
 
         return contextPath;
     }
 
     static OperationalMode determineOperationalMode(final JitrConfiguration annot) {
 
         final From from;
         final OperationalMode mode;
 
         // always use system property first
         final String modeSp = System.getProperty(MODE_SP_KEY);
         if (modeSp != null) {
             mode = OperationalMode.valueOf(modeSp);
             from = From.SYSTEM_PROPERTY;
         }
 
         // otherwise use value from annotation (if it exists)
         else if (annot != null) {
             mode = annot.mode();
             from = From.ANNOTATION;
         } else {
             mode = Defaults.DEFAULT_MODE;
             from = From.DEFAULT;
         }
 
         logSettingConfigValue("operational mode", from, mode.toString());
 
         return mode;
     }
 
     static int determinePort(final JitrConfiguration annot) {
 
         final From from;
         final int port;
 
         // always use system property first
         final String portSp = System.getProperty(PORT_SP_KEY);
         if (portSp != null) {
             port = Integer.parseInt(portSp);
             from = From.SYSTEM_PROPERTY;
         }
 
         // if the annotation is there and the port has been set
         else if (annot != null && annot.port() != Defaults.DEFAULT_PORT) {
 
             if (annot.port() <= 0) {
                 throw new JitrException("Configured Jitr port must be greater than 0.");
             }
 
             port = annot.port();
             from = From.ANNOTATION;
         }
 
         // if there is no annotation or if the port has not been explicitly set, pick a random port
         else {
             port = JitrUtils.getRandomUnusedPort();
             from = From.OTHER;
         }
 
         logSettingConfigValue("port", from, Integer.toString(port));
 
         return port;
     }
 
     static String determineWarPath(final JitrConfiguration annot) {
 
         final From from;
         final String warPath;
 
         // if no annotation, use default value
         if (annot == null) {
             warPath = Defaults.DEFAULT_WAR_PATH;
             from = From.DEFAULT;
         } else {
             warPath = annot.warPath();
             from = From.ANNOTATION;
         }
 
         logSettingConfigValue("war path", from, warPath);
 
         return warPath;
     }
 
     private static void logSettingConfigValue(final String key, final From from, final String value) {
 
         if (!LOG.isInfoEnabled()) {
             return;
         }
 
         if (from == From.DEFAULT) {
             LOG.info(key + " (" + from + "): " + value);
         } else if (from != From.OTHER) {
             LOG.info(key + " (from " + from + "): " + value);
         } else {
             LOG.info(key + ": " + value);
         }
     }
 }