/*

  * 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);

         }

     }

 }