package org.webslinger.containers;

 import java.io.File;

 import java.io.IOException;

 import java.io.PrintStream;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import javax.imageio.spi.ServiceRegistry;

 import gnu.getopt.LongOpt;

 import gnu.getopt.Getopt;

 import junit.framework.AssertionFailedError;

 import junit.framework.Test;

 import junit.framework.TestResult;

 import junit.framework.TestSuite;

 import junit.textui.TestRunner;

 import org.codehaus.janino.DebuggingInformation;

 import org.codehaus.janino.JavaSourceClassLoader;

 import org.webslinger.junit.TestBuilder;

 import org.webslinger.launcher.AbstractGnuoptContainer;

 import org.webslinger.launcher.Container;

 import org.webslinger.launcher.Main;

 import org.webslinger.util.GenericTestCase;

 public final class TestContainer extends AbstractGnuoptContainer {

     protected static final HashMap<ClassLoader, File> locationsByLoader = new HashMap<ClassLoader, File>();

     private static ThreadLocal<TestContainer> tl = new ThreadLocal<TestContainer>();

     private String[] testPaths;

     private boolean doStandardTests = true;

     private ArrayList<Test> tests = new ArrayList<Test>();

     public TestContainer() {

     }

     public void addTests(TestSuite suite) {

         Enumeration en = suite.tests();

         while (en.hasMoreElements()) tests.add((Test) en.nextElement());

     }

     public void addTests(Class<?> clz) {

         addTests(new TestSuite(clz));

     }

     public void addTests(TestBuilder builder) {

         builder.addTests(tests);

     }

     public void addTest(Test test) {

         tests.add(test);

     }

     public void setTestPaths(String[] testPaths) {

         this.testPaths = testPaths;

     }

     public String[] getTestPaths() {

         return testPaths;

     }

     public File getModuleRoot() throws IOException {

         return main.getModuleRoot();

     }

     public void setDoStandardTests(boolean doStandardTests) {

         this.doStandardTests = doStandardTests;

     }

     public boolean getDoStandardTests() {

         return doStandardTests;

     }

     public void showHelp(PrintStream out) throws IOException {

         out.println("test help");

     }

     protected Getopt getGetopt(String[] args) {

         LongOpt[] longOpts = new LongOpt[] {

             new LongOpt("standard-tests", LongOpt.NO_ARGUMENT, null, 0),

             new LongOpt("no-standard-tests", LongOpt.NO_ARGUMENT, null, 0),

             new LongOpt("add-builder", LongOpt.REQUIRED_ARGUMENT, null, 0),

             new LongOpt("add-suite", LongOpt.REQUIRED_ARGUMENT, null, 0),

             new LongOpt("add-class", LongOpt.REQUIRED_ARGUMENT, null, 0),

         };

         return new Getopt("webslinger=test", args, "", longOpts);

     }

     protected int processOneArg(int c, Getopt g) throws Exception {

         switch (c) {

             case 0:

                 switch (g.getLongind()) {

                     case 0:

                         setDoStandardTests(true);

                         break;

                     case 1:

                         setDoStandardTests(false);

                         break;

                     case 2:

                         addTests((TestBuilder) getClass().getClassLoader().loadClass(g.getOptarg()).newInstance());

                         return 0;

                     case 3:

                         addTests((TestSuite) getClass().getClassLoader().loadClass(g.getOptarg()).newInstance());

                         return 0;

                     case 4:

                         addTests(getClass().getClassLoader().loadClass(g.getOptarg()));

                         return 0;

                 }

                 break;

             default:

         }

         return 0;

     }

     protected boolean processRest(List<String> rest) {

         setTestPaths(rest.toArray(new String[rest.size()]));

         return true;

     }

     public void modifyClassPath(Main main, Collection<URL> urls) throws Exception {

         switch (main.getLayout()) {

             case SVN:

                 urls.add(Main.getFile(main.getRoot(), "build/lib/webslinger-tests.jar").toURL());

                 break;

             case UNIX:

                 urls.add(Main.getFile(main.getRoot(), "lib/webslinger/webslinger-tests.jar").toURL());

                 break;

         }

     }

     public void init() throws Exception {

     }

     public void run() throws Exception {

         TestSuite suite = new TestSuite();

         ArrayList<Test> tests = new ArrayList<Test>();

         if (getDoStandardTests()) {

             Iterator<TestBuilder> it = ServiceRegistry.lookupProviders(TestBuilder.class, getClass().getClassLoader());

             while (it.hasNext()) {

                 try {

                     it.next().addTests(tests);

                 } catch (RuntimeException e) {

                 } catch (UnsupportedClassVersionError e) {

                 }

             }

         }

         for (Test test: tests) suite.addTest(test);

         for (Test test: this.tests) suite.addTest(test);

         for (String testPath: testPaths) {

             File location = new File(testPath).getAbsoluteFile();

             File[] children = location.listFiles();

             if (children != null) for (File child: children) {

                 String name = child.getName();

                 if (!name.endsWith(".java")) continue;

                 if (!name.startsWith("Test")) continue;

                 suite.addTest(new TestContainerTest(location, name.substring(0, name.length() - 5)));

             }

         }

         TestRunner runner = new TestRunner();

         tl.set(this);

         try {

             if (!runner.doRun(suite, false).wasSuccessful()) System.exit(1);

         } finally {

             tl.set(null);

         }

     }

     public static class TestContainerTestCase extends GenericTestCase {

         private File base;

         protected TestContainerTestCase(String name) {

             super(name);

         }

         protected void setUp() throws Exception {

             super.setUp();

             base = new File(getTestLocation(), getName());

         }

         protected File getTestLocation() {

             return locationsByLoader.get(getClass().getClassLoader());

         }

         protected File getBase() {

             return base;

         }

         protected File getModuleRoot() throws IOException {

             return tl.get().getModuleRoot();

         }

     }

     private static final class TestContainerTest implements Test {

         private final File location;

         private final String className;

         protected TestContainerTest(File location, String className) {

             this.location = location;

             this.className = className;

         }

         public int countTestCases() {

             return 1;

         }

         public void run(TestResult result) {

             result.startTest(this);

             try {

                 Exception exception;

                 Class clz;

                 ClassLoader loader = null;

                 try {

                     loader = new JavaSourceClassLoader(

                         getClass().getClassLoader(),

                         new File[] {location},

                         "UTF-8",

                         DebuggingInformation.ALL

                     );

                     locationsByLoader.put(loader, location);

                     try {

                         clz = loader.loadClass(className);

                         exception = null;

                     } catch (ClassNotFoundException e) {

                         exception = e;

                         clz = null;

                     }

                     if (clz == null) {

                         result.addFailure(this, (AssertionFailedError) new AssertionFailedError("Couldn't find " + className + " at " + location).initCause(exception));

                     } else {

                         new TestSuite(clz).run(result);

                     }

                 } finally {

                     locationsByLoader.remove(loader);

                     loader = null;

                 }

             } finally {

                 result.endTest(this);

             }

         }

     }

 }