package test;


import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.testng.ISuite;
import org.testng.ITestResult;
import org.testng.ITestRunnerFactory;
import org.testng.SuiteRunner;
import org.testng.TestListenerAdapter;
import org.testng.TestNG;
import org.testng.TestRunner;
import org.testng.reporters.JUnitXMLReporter;
import org.testng.reporters.TestHTMLReporter;
import org.testng.xml.XmlClass;
import org.testng.xml.XmlSuite;
import org.testng.xml.XmlTest;
import org.testng.internal.annotations.DefaultAnnotationTransformer;
import org.testng.internal.annotations.IAnnotationFinder;
import org.testng.internal.annotations.IAnnotationTransformer;
import org.testng.internal.annotations.JDK14AnnotationFinder;


/**
 * Base class for tests
 *
 * @author Cedric Beust, May 5, 2004
 * @author <a href='mailto:the_mindstorm@evolva.ro'>Alexandru Popescu</a>
 */
public class BaseTest {
  private static final String m_outputDirectory = "test-output-tests";

  private XmlSuite            m_suite           = null;
  private ITestRunnerFactory  m_testRunnerFactory;
  private IAnnotationTransformer m_defaultAnnotationTransformer= new DefaultAnnotationTransformer();
  private IAnnotationFinder m_javadocAnnotationFinder;


  public BaseTest() {
    m_testRunnerFactory = new InternalTestRunnerFactory(this);
  }

  protected void setDebug() {
    getTest().setVerbose(9);
  }

  protected void setParallel(String parallel) {
    getTest().setParallel(parallel);
  }
  
  public void setThreadCount(int threadCount) {
    getTest().getSuite().setThreadCount(threadCount);
  }  

  protected void setVerbose(int n) {
    getTest().setVerbose(n);
  }

  private Map m_tests = new HashMap();
  private Map m_passedTests  = new HashMap();
  private Map m_failedTests = new HashMap();
  private Map m_skippedTests = new HashMap();
  private Map m_failedButWithinSuccessPercentageTests = new HashMap();

  protected Map getTests(Map map) {
    Map result = (Map) map.get(getId());
    if(null == result) {
      result = new HashMap();
      map.put(getId(), result);
    }
    return result;
  }

  protected XmlTest getTest() {
    return (XmlTest) m_tests.get(getId());
  }

  protected void setTests(Map map, Map m) {
    map.put(getId(), m);
  }

  public Map getFailedTests() {
    return getTests(m_failedTests);
  }

  // Map<String, List<ITestResult>>
  public Map getFailedButWithinSuccessPercentageTests() {
    return getTests(m_failedButWithinSuccessPercentageTests);
  }

  public Map getPassedTests() {
    return getTests(m_passedTests);
  }

  public Map getSkippedTests() {
    return getTests(m_skippedTests);
  }

  public void setSkippedTests(Map m) {
    setTests(m_skippedTests, m);
  }

  public void setPassedTests(Map m) {
    setTests(m_passedTests, m);
  }

  public void setFailedTests(Map m) {
    setTests(m_failedTests, m);
  }

  public void setFailedButWithinSuccessPercentageTests(Map m) {
    setTests(m_failedButWithinSuccessPercentageTests, m);
  }

  protected void run() {
    assert null != getTest() : "Test wasn't set, maybe @Configuration methodSetUp() was never called";
    setPassedTests(new HashMap());
    setFailedTests(new HashMap());
    setSkippedTests(new HashMap());
    setFailedButWithinSuccessPercentageTests(new HashMap());

    m_suite.setVerbose(new Integer(0));
    SuiteRunner suite = new SuiteRunner(m_suite, 
        m_outputDirectory, 
        m_testRunnerFactory,
        new IAnnotationFinder[] {m_javadocAnnotationFinder, null});

    suite.run();
  }

  public void addIncludedMethod(String className, String m) {
    XmlClass xmlClass = findClass(className);
    xmlClass.getIncludedMethods().add(m);
    getTest().getXmlClasses().add(xmlClass);
  }

  public void addExcludedMethod(String className, String m) {
    XmlClass xmlClass = findClass(className);
    xmlClass.getExcludedMethods().add(m);
    getTest().getXmlClasses().add(xmlClass);
  }

  private XmlClass findClass(String className) {
    for (Iterator it = getTest().getXmlClasses().iterator(); it.hasNext(); ) {
      XmlClass cl = (XmlClass) it.next();
      if (cl.getName().equals(className)) {
        return cl;
      }
    }
    
    XmlClass result = addClass(className);
    return result;
  }

  public void addIncludedGroup(String g) {
    getTest().getIncludedGroups().add(g);
  }

  public void addExcludedGroup(String g) {
    getTest().getExcludedGroups().add(g);
  }

  public void addMetaGroup(String mg, List l) {
    getTest().getMetaGroups().put(mg, l);
  }

  public void addMetaGroup(String mg, String n) {
    List l = new ArrayList();
    l.add(n);
    addMetaGroup(mg, l);
  }

  public void setParameter(String key, String value) {
    getTest().addParameter(key, value);
  }

  protected XmlClass addClass(String className) {
    XmlClass result = new XmlClass(className);
    getTest().getXmlClasses().add(result);
    return result;
  }
  
  private void setTest(XmlTest test) {
    XmlTest t = (XmlTest) m_tests.get(getId());
    if(null == t) {
      m_tests.put(getId(), t);
    }
  }

  /**
   * @testng.configuration beforeTestMethod="true" groups="init,initTest,current"
   */
  public void methodSetUp() {
    m_javadocAnnotationFinder= new JDK14AnnotationFinder(m_defaultAnnotationTransformer);
    m_javadocAnnotationFinder.addSourceDirs(new String[] {"./test-14/v4/src"});
    m_suite = new XmlSuite();
    m_suite.setAnnotations("javadoc");
    m_tests.put(getId(), new XmlTest(m_suite));
    getTest().setName("Internal test, failures are expected");
  }

  protected void verifyResults(Map tests, int expected, String message) {
    //  protected void verifyResults(Map<String, List<ITestResult>> tests, int expected, String message) {
    if(tests.size() > 0) {
      Set keys = tests.keySet();
      Object firstKey = keys.iterator().next();
      List passedResult = (List) tests.get(firstKey);
      int n = passedResult.size();
      assert n == expected : "Expected " + expected + " " + message + " but found " + n;
    } else {
      assert expected == 0 : "Expected " + expected + " " + message + " but found " + tests.size();
    }
  }

  protected void verifyTests(String title, String[] exp, Map found) {
    Map expected = new HashMap();
    for(int i = 0; i < exp.length; i++) {
      expected.put(exp[i], exp[i]);
    }

    assert expected.size() == found.size() : "Expected " + expected.size() + " " + title
        + " tests but found " + found.size();

    for(Iterator it = expected.values().iterator(); it.hasNext();) {
      String name = (String) it.next();
      if(null == found.get(name)) {
        dumpMap("Expected", expected);
        dumpMap("Found", found);
      }
      assert null != found.get(name) : "Expected to find method " + name + " in " + title
          + " but didn't find it.";
    }
  }

  private void dumpMap(String title, Map m) {
    System.out.println("==== " + title);
    for(Iterator it = m.keySet().iterator(); it.hasNext();) {
      Object key = it.next();
      Object value = m.get(key);
      ppp(key + "  => " + value);
    }

  }

  private Collection computeDifferences(Map m1, Map m2) {
    List result = new ArrayList();

    for(Iterator it = m1.keySet().iterator(); it.hasNext();) {
      Object key = it.next();
    }

    return result;
  }

  /** Map<String, List<ITestResult>> */
  private void addTest(Map tests, ITestResult t) {
    List l = (List) tests.get(t.getName());
    if(null == l) {
      l = new ArrayList();
      tests.put(t.getName(), l);
    }
    l.add(t);
  }

  public void addPassedTest(ITestResult t) {
    addTest(getPassedTests(), t);
  }

  public void addFailedTest(ITestResult t) {
    addTest(getFailedTests(), t);
  }

  public void addFailedButWithinSuccessPercentageTest(ITestResult t) {
    addTest(getFailedButWithinSuccessPercentageTests(), t);
  }

  public void addSkippedTest(ITestResult t) {
    addTest(getSkippedTests(), t);
  }

  private void ppp(String s) {
    System.out.println("[BaseTest " + getId() + "] " + s);
  }

  protected Long getId() { 
    return new Long(Thread.currentThread().hashCode());
  }

  public XmlSuite getSuite() {
    return m_suite;
  }

  private static class InternalTestRunnerFactory implements ITestRunnerFactory {
    private final BaseTest m_baseTest;

    public InternalTestRunnerFactory(final BaseTest baseTest) {
      m_baseTest = baseTest;
    }

    /**
     * @see org.testng.ITestRunnerFactory#newTestRunner(org.testng.ISuite, org.testng.xml.XmlTest)
     */
    public TestRunner newTestRunner(ISuite suite, XmlTest test) {
      TestRunner testRunner = new TestRunner(suite, test, false);

      testRunner.addTestListener(new TestHTMLReporter());
      testRunner.addTestListener(new JUnitXMLReporter());
      testRunner.addTestListener(new TestListener(m_baseTest));

      return testRunner;
    }
  }

  private static class TestListener extends TestListenerAdapter {
    private BaseTest m_test = null;

    public TestListener(BaseTest t1) {
      m_test = t1;
    }

    public void onTestSuccess(ITestResult tr) {
      m_test.addPassedTest(tr);
    }

    public void onTestFailure(ITestResult tr) {
      m_test.addFailedTest(tr);
    }

    public void onTestSkipped(ITestResult tr) {
      m_test.addSkippedTest(tr);
    }

    public void onTestFailedButWithinSuccessPercentage(ITestResult result) {
      m_test.addFailedButWithinSuccessPercentageTest(result);
    }
  } // TestListener

} // BaseTest