/*
    * 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 java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.LinkedList;
  
  import javax.servlet.ServletContext;
  
  import org.apache.log4j.Logger;
  import org.jitr.annotation.BaseUri;
  import org.jitr.annotation.JitrConfiguration;
  import org.jitr.annotation.Port;
  import org.jitr.core.ConfigurationModel;
  import org.jitr.core.Container;
  import org.jitr.core.JitrException;
  import org.jitr.core.OperationalMode;
  import org.junit.internal.runners.ClassRoadie;
  import org.junit.internal.runners.InitializationError;
  import org.junit.internal.runners.JUnit4ClassRunner;
  import org.junit.runner.notification.RunNotifier;
  import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  import org.springframework.core.annotation.AnnotationUtils;
  import org.springframework.test.context.ContextConfiguration;
  import org.springframework.test.context.ContextLoader;
  import org.springframework.web.context.WebApplicationContext;
  import org.springframework.web.context.support.WebApplicationContextUtils;
  
  /**
   * The heart of Jitr. This provides all of the configuration, Spring application context loading,
   * bootstrapping and wiring of test classes.
   * 
   * @author Josh Devins (info@joshdevins.net)
   */
  @JitrConfiguration
  public final class Jitr extends JUnit4ClassRunner {
  
      private static final Logger LOG = Logger.getLogger(Jitr.class);
  
      private ConfigurationModel config;
  
      private Container<?> container;
  
      private AutowireCapableBeanFactory autowireCapableBeanFactory;
  
      public Jitr(final Class<?> clazz) throws InitializationError {
          super(clazz);
      }
  
      @Override
      public void run(final RunNotifier notifier) {
  
          if (LOG.isInfoEnabled()) {
              LOG.info("Jitr loaded");
          }
  
          // get the Jitr configuration (if any) from the test class
          JitrConfiguration annot =
                  AnnotationUtils.findAnnotation(getTestClass().getJavaClass(),
                          JitrConfiguration.class);
  
          if (LOG.isInfoEnabled() && annot == null) {
              LOG.info("No @JitrConfiguration found on test class");
          }
  
          config = JitrConfigurationFactory.createConfigurationFromAnnotation(annot);
  
          if (config == null) {
              throw new JitrException("Configuration could not be created.");
          }
  
          final ServletContext servletContext = initAndStartContainerIfNeeded();
  
          // setup Spring if we can
          setSpringAutowireCapableBeanFactory(servletContext);
  
          // create JUnit class roadie for running tests
          final ClassRoadie roadie =
                  new ClassRoadie(notifier, getTestClass(), getDescription(), new Runnable() {
                     public void run() {
                         runMethods(notifier);
                     }
                 });
 
         if (LOG.isInfoEnabled()) {
             LOG.info("Running tests");
         }
 
         // run tests regularly with JUnit class roadie
         roadie.runProtected();
 
         if (config.getMode().isContainerEnabled()) {
 
             if (LOG.isInfoEnabled()) {
                 LOG.info("Stopping container: " + container.getName());
             }
 
             container.stop();
         }
     }
 
     @Override
     protected Object createTest() throws Exception {
         Object testInstance = super.createTest();
 
         // autowire the test if we can
         if (autowireCapableBeanFactory != null) {
             autowireCapableBeanFactory.autowireBean(testInstance);
         }
 
         // set @Port field
         final Field portField =
                 JitrUtils.getMostSpecificAnnotatedDeclaredField(testInstance.getClass(), Port.class);
 
         if (portField != null) {
 
             validateModifiersAndSetAccessible(portField, "Port");
             portField.setInt(testInstance, config.getPort());
         }
 
         // set @BaseUri field
         final Field baseUriField =
                 JitrUtils.getMostSpecificAnnotatedDeclaredField(testInstance.getClass(),
                         BaseUri.class);
 
         if (baseUriField != null) {
 
             validateModifiersAndSetAccessible(baseUriField, "BaseUri");
             baseUriField.set(testInstance, config.getBaseUri());
         }
 
         return testInstance;
     }
 
     private ServletContext initAndStartContainerIfNeeded() {
 
         // if the container is disabled, then we don't need to do any of this
         if (!config.getMode().isContainerEnabled()) {
             return null;
         }
 
         final Class<?> containerClass = config.getContainerClass();
 
         // try to instantiate the container implementation class
         try {
             Constructor<?> containerConstructor = containerClass.getConstructor();
             container = (Container<?>) containerConstructor.newInstance();
 
         } catch (final Exception e) {
             throw new JitrException("Could not instantiate Container implementation class: "
                     + containerClass.toString(), e);
         }
 
         if (LOG.isInfoEnabled()) {
             LOG.info("Initializing container: " + container.getName());
         }
 
         ServletContext servletContext =
                 container.initialize(config, getTestClass().getJavaClass().getAnnotations());
 
         if (LOG.isInfoEnabled()) {
             LOG.info("Starting container: " + container.getName());
         }
 
         container.start();
 
         return servletContext;
     }
 
     private void setSpringAutowireCapableBeanFactory(final ServletContext servletContext) {
 
         // using same Spring application context as webapp
         if (config.getMode() == OperationalMode.INTERNAL) {
 
             // load web app context from current Thread
             WebApplicationContext webApplicationContext =
                     org.springframework.web.context.ContextLoader.getCurrentWebApplicationContext();
 
             // sometimes Spring will be loaded in another thread, make sure we have a ServletContext
             if (webApplicationContext == null && servletContext == null) {
                 throw new JitrException(
                         "Servlet context was null and no Spring web application context could"
                                 + " be found in the current Thread.");
             }
 
             if (webApplicationContext == null) {
                 webApplicationContext =
                         WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
             }
 
             // make sure there is a Spring web application context
             if (webApplicationContext == null) {
                 LOG.warn("No Spring web application context was found and Jitr is not configured "
                         + "to use an external Spring application context configuration.");
                 return;
             }
 
             autowireCapableBeanFactory = webApplicationContext.getAutowireCapableBeanFactory();
 
             return;
         }
 
         // need to load an external Spring application context configuration
         ContextConfiguration contextConfiguration =
                 AnnotationUtils.findAnnotation(getTestClass().getJavaClass(),
                         ContextConfiguration.class);
 
         // make sure we can find the configuration
         if (contextConfiguration == null) {
             throw new JitrException(
                     "Jitr is configured to use an external Spring application context but none"
                             + " has been configured. Use @ContextConfiguration on your test class"
                             + " to define what Spring application context configurations should"
                             + " be loaded.");
         }
 
         // TODO: Implement location inheritance.
         // boolean inheritLocations =
         // contextConfiguration.inheritLocations();
 
         Class<? extends ContextLoader> contextLoaderClass = contextConfiguration.loader();
         String[] locations = contextConfiguration.locations();
         ApplicationContext applicationContext;
 
         // if a ContextLoader class was specified on the annotation, use it
         if (contextLoaderClass != null && contextLoaderClass != ContextLoader.class) {
             try {
                 Constructor<? extends ContextLoader> constructor =
                         contextLoaderClass.getConstructor();
                 ContextLoader contextLoader = constructor.newInstance();
                 String[] processedLocations =
                         contextLoader.processLocations(getTestClass().getJavaClass(), locations);
                 applicationContext = contextLoader.loadContext(processedLocations);
 
             } catch (final Exception e) {
                 throw new JitrException("Error loading Spring application contexts.", e);
             }
         } else {
             // use a default XML context loader
             applicationContext = new ClassPathXmlApplicationContext(locations);
         }
 
         autowireCapableBeanFactory = applicationContext.getAutowireCapableBeanFactory();
     }
 
     private void validateModifiersAndSetAccessible(final Field field, final String annotationName) {
 
         final int modifiers = field.getModifiers();
         final Collection<String> problemModifiers = new LinkedList<String>();
 
         if (Modifier.isStatic(modifiers)) {
             problemModifiers.add("static");
         }
 
         if (Modifier.isFinal(modifiers)) {
             problemModifiers.add("final");
         }
 
         if (!problemModifiers.isEmpty()) {
 
             final Iterator<String> iterator = problemModifiers.iterator();
             final StringBuilder stringBuilder = new StringBuilder();
 
             while (iterator.hasNext()) {
                 stringBuilder.append(iterator.next());
 
                 if (iterator.hasNext()) {
                     stringBuilder.append(", ");
                 }
             }
 
             throw new JitrException("Field annotated with @" + annotationName + " cannot be: "
                     + stringBuilder.toString());
         }
 
         field.setAccessible(true);
     }
 }