package org.testng;

import org.testng.internal.ConfigurationMethod;
import org.testng.internal.NoOpTestClass;
import org.testng.internal.RunInfo;
import org.testng.internal.TestNGMethod;
import org.testng.internal.annotations.IAnnotationFinder;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * This class represents a test class:
 * - The test methods
 * - The configuration methods (test and method)
 * - The class file
 * 
 * @author <a href="mailto:cedric@beust.com">Cedric Beust</a>
 * @author <a href='mailto:the_mindstorm@evolva.ro'>Alexandru Popescu</a>
 */
public class TestClass extends NoOpTestClass implements ITestClass {
	/* generated */
	private static final long serialVersionUID = -8077917128278361294L;
  transient private IAnnotationFinder m_annotationFinder = null;
  // The Strategy used to locate test methods (TestNG, JUnit, etc...)
  transient private ITestMethodFinder m_testMethodFinder = null;

  transient protected Map<Class, Class> m_testClasses = new HashMap<Class, Class>();
  transient protected Map<Class, Object[]> m_instanceMap = new HashMap<Class, Object[]>();
  
  private IClass m_iClass = null;
  private TestRunner m_testRunner = null;
  private RunInfo m_runInfo = null;
  
  public TestClass(IClass cls, 
                   String testName,
                   ITestMethodFinder testMethodFinder, 
                   IAnnotationFinder annotationFinder,
                   RunInfo runInfo, 
                   TestRunner testRunner) {
    init(cls, testName, testMethodFinder, annotationFinder, runInfo, testRunner);
  }
  
  public TestClass(IClass cls, TestClass tc) {
    init(cls, 
         tc.getTestName(), 
         tc.getTestMethodFinder(), 
         tc.getAnnotationFinder(),
         tc.getRunInfo(), 
         tc.getTestRunner());
  }
  
  public String getTestName() {
    return m_testName;
  }
  
  public IAnnotationFinder getAnnotationFinder() {
    return m_annotationFinder;
  }
  
  private void init(IClass cls, 
                    String testName,
                    ITestMethodFinder testMethodFinder, 
                    IAnnotationFinder annotationFinder,
                    RunInfo runInfo, 
                    TestRunner testRunner) {
    log(3, "Creating TestClass for " + cls);
    m_iClass = cls;
    m_testClass = cls.getRealClass();
    m_testName = testName;
    m_runInfo = runInfo;
    m_testRunner = testRunner;
    m_testMethodFinder = testMethodFinder;
    m_annotationFinder = annotationFinder;
//    m_testMethodFinder.setTestClass(this);
    initMethods();
    initTestClassesAndInstances();
  }
  
  private void initTestClassesAndInstances() {
    //
    // TestClasses and instances
    //
   Object[] instances = getInstances(false);
    for (Object instance : instances) {
      Class cls = instance.getClass();
      if (null == m_testClasses.get(cls)) {
        m_testClasses.put(cls, cls);
        m_instanceMap.put(cls, instances);
      }
    }
    
  }
    
  public Object[] getInstances(boolean create) {
    return m_iClass.getInstances(create);
  }
  
  public long[] getInstanceHashCodes() {
    return m_iClass.getInstanceHashCodes();
  }
  
  public int getInstanceCount() {
    return m_iClass.getInstanceCount();
  }
  
  public void addInstance(Object instance) {
    m_iClass.addInstance(instance);
  }

  private void initMethods() {
    ITestNGMethod[] methods = m_testMethodFinder.getTestMethods(m_testClass);
    m_testMethods = createTestMethods(methods);

    m_beforeSuiteMethods = ConfigurationMethod
        .createSuiteConfigurationMethods(m_testMethodFinder.getBeforeSuiteMethods(m_testClass),
                                         m_annotationFinder,
                                         true);
    m_afterSuiteMethods = ConfigurationMethod
        .createSuiteConfigurationMethods(m_testMethodFinder.getAfterSuiteMethods(m_testClass), 
                                         m_annotationFinder,
                                         false); 


    m_beforeTestConfMethods = ConfigurationMethod 
        .createTestConfigurationMethods(m_testMethodFinder.getBeforeTestConfigurationMethods(m_testClass), 
                                        m_annotationFinder,
                                        true);
    m_afterTestConfMethods = ConfigurationMethod
        .createTestConfigurationMethods(m_testMethodFinder.getAfterTestConfigurationMethods(m_testClass), 
                                        m_annotationFinder,
                                        false);

    m_beforeClassMethods = ConfigurationMethod
        .createClassConfigurationMethods(m_testMethodFinder.getBeforeClassMethods(m_testClass), 
                                         m_annotationFinder,
                                         true);
    m_afterClassMethods = ConfigurationMethod
        .createClassConfigurationMethods(m_testMethodFinder.getAfterClassMethods(m_testClass), 
                                         m_annotationFinder,
                                         false);
    
    m_beforeGroupsMethods = ConfigurationMethod
    .createBeforeConfigurationMethods(m_testMethodFinder.getBeforeGroupsConfigurationMethods(m_testClass), 
                                          m_annotationFinder,
                                          true);
    m_afterGroupsMethods = ConfigurationMethod
    .createAfterConfigurationMethods(m_testMethodFinder.getAfterGroupsConfigurationMethods(m_testClass),
                                          m_annotationFinder,
                                          false); 
    

    m_beforeTestMethods = ConfigurationMethod
        .createTestMethodConfigurationMethods(m_testMethodFinder.getBeforeTestMethods(m_testClass), 
                                              m_annotationFinder,
                                              true);
    m_afterTestMethods = ConfigurationMethod
        .createTestMethodConfigurationMethods(m_testMethodFinder.getAfterTestMethods(m_testClass),
                                              m_annotationFinder,
                                              false);
    
  }
  
  /**
   * Create the test methods that belong to this class (rejects
   * all those that belong to a different class).
   */
  private ITestNGMethod[] createTestMethods(ITestNGMethod[] methods) {
    List<ITestNGMethod> vResult = new ArrayList<ITestNGMethod>();
    for (ITestNGMethod tm : methods) {
      Method m = tm.getMethod();
      if (m.getDeclaringClass().isAssignableFrom(m_testClass)) {
        log(3, "Adding method " + tm + " on TestClass " + m_testClass);
        vResult.add(new TestNGMethod(/* tm.getRealClass(), */ m, m_annotationFinder));
      }
      else {
        log(3, "Rejecting method " + tm + " for TestClass " + m_testClass);
      }
    }
    
    ITestNGMethod[] result = vResult.toArray(new ITestNGMethod[vResult.size()]);
    return result;
  }
  
  public TestRunner getTestRunner() {
    return m_testRunner;
  }
  
  public RunInfo getRunInfo() {
    return m_runInfo;
  }
    
  public ITestMethodFinder getTestMethodFinder() {
    return m_testMethodFinder;
  }
  
  private void log(int level, String s) {
    if (TestRunner.getVerbose() >= level) {
      ppp(s);
    }
  }
  
  private static void ppp(String s) {
    System.out.println("[TestClass] " + s);
  }

//  public Class[] getTestClasses() {
//    return m_testClasses.keySet().toArray(new Class[m_testClasses.size()]);
//  }
  
  public void dump() {
    ppp("\n======\nTESTCLASS: " + m_testClass.getName());
    for (ITestNGMethod m : m_beforeClassMethods) {
      ppp("BeforeClass : " + m);
    }
    for (ITestNGMethod m : m_beforeTestMethods) {
      ppp("BeforeMethod:\t" + m);
    }
    for (ITestNGMethod m : m_testMethods) {
      ppp("Test        :\t\t" + m);
    }
    for (ITestNGMethod m : m_afterTestMethods) {
      ppp("AfterMethod :\t" + m);
    }
    for (ITestNGMethod m : m_afterClassMethods) {
      ppp("AfterClass  : " + m);
    }
    ppp("\n======\n");
  }
  
  @Override
  public String toString() {
    return "[TestClass " + m_testClass + "]";
  }
  
}