package SBST2015;

import java.lang.reflect.*;
import java.net.URL;
import java.util.*;

import org.reflections.Reflections ;
import org.reflections.scanners.SubTypesScanner;
import org.reflections.util.ClasspathHelper;

import Sequenic.T3.*;


public class Inspection {
	

	/**
	 * Check if C has non-private instance method or constructor that it declares itself.
	 */
	public static boolean has_NonPrivateDeclared_IMethod_OrConstructor(Class C) {
		Method[] methods = C.getDeclaredMethods() ;
		for (Method m : methods) {
			int flag = m.getModifiers() ;
			if (!Modifier.isStatic(flag) && !Modifier.isPrivate(flag)) return true ;
		}
		Constructor[] constructors = C.getDeclaredConstructors() ;
		for (Constructor c : constructors) {
			int flag = c.getModifiers() ;
			if(!Modifier.isStatic(flag) && !Modifier.isPrivate(flag))  return true ;
		}
		return false ;
	}
	
	/**
	 * Check if C has non-private static method that it declares itself.
	 */
	public static boolean has_NonPrivateDeclared_SMethod(Class C) {
		Method[] methods = C.getDeclaredMethods() ;
		for (Method m : methods) {
			int flag = m.getModifiers() ;
			if (Modifier.isStatic(flag) && !Modifier.isPrivate(flag)) return true ;
		}
		return false ;
	}
	
	/**
	 * Return static inner class.
	 */
	public static List<Class> getStaticInnerClasses(Class C) {
		Class[] innerclasses = C.getDeclaredClasses() ;
		List<Class> R = new LinkedList<Class>() ;
		for (Class ic : innerclasses) {
			if (ic.isInterface()) continue ;
			int flag = ic.getModifiers() ;
			//if (Modifier.isStatic(flag) && !Modifier.isPrivate(flag)) R.add(ic) ;
			if (Modifier.isStatic(flag)) R.add(ic) ;
		}
		return R ;
	}
		
	public static List<Constructor> getPrivateConstructors(Class C) {
		List<Constructor> cons = new LinkedList<Constructor>() ;
		Constructor[] constructors = C.getDeclaredConstructors() ;
		for (Constructor c : constructors) {
			int flag = c.getModifiers() ;
			if(Modifier.isPrivate(flag))  cons.add(c) ;
		}
		return cons ;
	}
	
	/**
	 * Get all concrete classes that implement an interface in a package.
	 */
	public static List<Class> getAllConcreteClasses(String pckgName) {
		Reflections reflections = new Reflections(pckgName, new SubTypesScanner(false));

		Set allclasses_ = reflections.getSubTypesOf(Object.class) ;
		Set<Class> allclasses = (Set<Class>) allclasses_ ;
		List<Class> R = new LinkedList<Class>() ;
		for (Class C : allclasses) {
			System.err.println("** seeing " + C + " ...") ;
			if (C.isInterface()) {
				for (Class D : allclasses) {
					int mod = D.getModifiers() ;
					if (!D.isInterface() 
							&& !Modifier.isAbstract(mod) 
							&& Modifier.isPublic(mod)
							&& C.isAssignableFrom(D)) {
						R.add(D) ;
					}
				}
			}
		}
		return R ;
	}

	
	public static Class[] getAllConcreteClassesUnderParentPackage(Class CUT) {
         List<Class> R = new LinkedList<Class>() ;
         try {
           String pckgName = CUT.getPackage().getName() ;
           String pckgParentName = pckgName ;
           System.err.println("** trying to scan " + pckgParentName) ;
           if (pckgName.contains(".")) pckgParentName = pckgName.substring(0, pckgName.lastIndexOf(".")) ;
           R = getAllConcreteClasses(pckgParentName) ;
         }
         catch (Throwable e) {
        	 System.err.println("** fail to scan package for concrete classes.") ;
        	 System.err.println("** " + e) ;
         }
         Class[] R_ = new Class[R.size()] ;
         for (int k=0; k<R_.length ; k++) {
        	 R_[k] = R.get(k) ;
        	 System.err.println("** addding " + R_[k]) ;
         }
         return R_ ;
	}
	
	static public void main(String[] args) {
		//List<Class> cs = getAllConcreteClasses("Sequenic.T3") ;
		//for (Class C : cs) System.out.println(">> " + C) ;
	}
	
	
}