/**
    * Copyright (C) 2009 Erik Putrycz <erik.putrycz@gmail.com>
    * 
    * 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 net.ep.db4o.javassist;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Modifier;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import javassist.ClassPool;
  import javassist.LoaderClassPath;
  import net.ep.db4o.activator.TransparentActivation;
  
  import com.db4o.internal.Platform4;
  import com.db4o.reflect.ReflectArray;
  import com.db4o.reflect.ReflectClass;
  import com.db4o.reflect.Reflector;
  import com.db4o.reflect.ReflectorConfiguration;
  import com.db4o.reflect.jdk.ClassLoaderJdkLoader;
  import com.db4o.reflect.jdk.JdkClass;
  import com.db4o.reflect.jdk.JdkLoader;
  import com.db4o.reflect.jdk.JdkReflector;
  import com.db4o.ta.Activatable;
  
  @SuppressWarnings("unchecked")
  public class JVSTReflector implements Reflector {
  
  	private static final boolean debug = false;
  	
  
  	private static final Map<Class, List<ClassData>> _classCache = new HashMap<Class, List<ClassData>>();
  	
  	public static class ClassData {
  		ReflectClass _reflectClass;
  		boolean ignoreNullActivator;
  		boolean threadLocal;
  		@Override
  		public String toString() {
  			return _reflectClass + " ignoreNullActivator:" + ignoreNullActivator + " threadLocal:" + threadLocal;
  		}
  	}
  	
  	public static final <T> Class<? super T> getRealClass(Class<? super T> clazz) {
  		if (isEnhanced(clazz)) {
  			clazz = clazz.getSuperclass();
  		}
  		return clazz;
  	}
  
  	public static final boolean hasPublicConstructor(Class clazz) {
  		boolean hasPublic = true;
  		for (Constructor constr : clazz.getDeclaredConstructors()) {
  			if (Modifier.isPublic(constr.getModifiers()))
  				return true;
  			hasPublic = false;
  		}
  		return hasPublic;
  	}
  
  	public static final boolean isEnhanced(Class clazz) {
  		if (clazz.equals(TransparentActivation.class))
  			return false;
  		return TransparentActivation.class.isAssignableFrom(clazz);
  	}
  
  	public static final boolean shouldBeEnhanced(Class clazz) {
  		return canBeEnhanced(clazz)
  				&& hasPublicConstructor(clazz)
  				&& (clazz.getPackage().getName() == null || !clazz.getPackage()
  						.getName().startsWith("java")
  						&& !clazz.getPackage().getName().startsWith("com.db4o"));
  	}
  	
  	public static final boolean canBeEnhanced(Class clazz) {
  		return !Modifier.isFinal(clazz.getModifiers())
  				&& !clazz.isInterface()
  				&& !clazz.isAnnotation()
  				&& !clazz.isPrimitive()
  				&& !clazz.isArray()
  				&& !clazz.isAnonymousClass()
  				&& !Activatable.class.isAssignableFrom(clazz);
  	}	
  	
 	public static String explainWhyNotEnhanced(Class clazz) {
 		List<String> reasons = new ArrayList<String>();
 		StringBuilder sb = new StringBuilder();
 		if (Modifier.isFinal(clazz.getModifiers()))
 			reasons.add("modifiers are final");
 		if (clazz.isInterface())
 			reasons.add("class is an interface");
 		if (clazz.isAnnotation())
 			reasons.add("class is an annotation");
 		if (clazz.isPrimitive())
 			reasons.add("the class represents a primitive type");
 		if (clazz.isArray())
 			reasons.add("the class represents an array");
 		if (clazz.isAnonymousClass())
 			reasons.add("the class represents an anonymous class");
 		if (Activatable.class.isAssignableFrom(clazz))
 			reasons.add("the class already implements " + Activatable.class.getName());
 //		if (!hasPublicConstructor(clazz))
 //			reasons.add("no public constructors have been found");
 //		if (clazz.getPackage().getName() == null)
 //			reasons.add("the package is empty");
 //		if (clazz.getPackage()
 //							.getName().startsWith("java"))
 //			reasons.add("the package starts with 'java.xxxx'");
 //		if (clazz.getPackage().getName().startsWith("com.db4o"))
 //			reasons.add("the class seems to be an internal db4o class (package starts with 'com.db4o')");
 		boolean first = true;
 		for (String reason:reasons) {
 			if (!first)
 				sb.append("\n");
 			sb.append(reason);
 			first = false;
 		}
 		return sb.toString();
 	}
 
 	/**
 	 * Creates Class[] array from the ReflectClass[] array
 	 * 
 	 * @param claxx
 	 *          ReflectClass array
 	 * @return Class[] array
 	 */
 	static Class[] toNative(ReflectClass[] claxx) {
 		Class[] clazz = null;
 		if (claxx != null) {
 			clazz = new Class[claxx.length];
 			for (int i = 0; i < claxx.length; i++) {
 				clazz[i] = JdkReflector.toNative(claxx[i]);
 			}
 		}
 		return clazz;
 	}
 
 	private ReflectArray _array;
 
 	private final JdkLoader _classLoader;
 
 	private ClassPool _classPool;
 
 	private ReflectorConfiguration _config;
 
 	private JdkReflector _jdkReflect;
 
 	private Reflector _parent;
 
 	private boolean _threadLocal;
 
 	private PersistOnMethodPolicy _persistPolicy;
 
 	private ActivateOnMethodPolicy _activationPolicy;
 
 	private boolean _ignoreNullActivator;
 
 	/**
 	 * Constructor
 	 * 
 	 * @param classLoader
 	 *          class loader
 	 */
 	public JVSTReflector(ClassLoader classLoader) {
 		this(new ClassLoaderJdkLoader(classLoader));
 	}
 	
 	/**
 	 * Constructor
 	 * 
 	 * @param classLoader
 	 *          class loader
 	 */
 	public JVSTReflector(JdkLoader classLoader) {
 		_classLoader = classLoader;
 		_classPool = new ClassPool();
 		_classPool.appendClassPath(new LoaderClassPath(Thread.currentThread()
 				.getContextClassLoader()));
 		_jdkReflect = new JdkReflector(classLoader);
 		// _classPool.appendSystemPath();
 	}
 
 	private JVSTReflector(JdkLoader classLoader, ReflectorConfiguration config){
 		_classLoader = classLoader;
 		_config = config;
 	}
 
 	/**
 	 * ReflectArray factory
 	 * 
 	 * @return ReflectArray instance
 	 */
 	public ReflectArray array() {
 		if (_array == null) {
 			_array = new JVSTArray(parent());
 		}
 		return _array;
 	}
 	
 	public ReflectorConfiguration configuration() {
 		return _config;
 	}	
 
 	public void configuration(ReflectorConfiguration config) {
 		_config = config;
 		_jdkReflect.configuration(config);
 	}
 
 	private ReflectClass findInCache(Class clazz) {
 		List<ClassData> clList = _classCache.get(clazz);
 		if (clList == null)
 			return null;
 		if (debug)
 			System.out.println(clazz.getName() + " - cache contains " + clList.size() + " items " + clList.toString());
 		for (ClassData clData:clList) {
 			if (clData.ignoreNullActivator == _ignoreNullActivator && clData.threadLocal == _threadLocal)
 				return clData._reflectClass;
 		}
 		return null;
 	}
 	
 	protected ReflectClass createClass(Class clazz) {				
 		ReflectClass res = findInCache(clazz);
 		if (res != null)
 			return res;
 		if (shouldBeEnhanced(clazz)) {
 			if (debug)
 				System.out.println("enhancing:" + clazz + " threadLocal:" + _threadLocal);
 			res = enhanceClass(clazz);
 		} else {
 			res = new JdkClass(parent(), _jdkReflect, getRealClass(clazz));
 			addToCache(clazz, res);
 		}
 		return res;
 	}
 
 	private void addToCache(Class clazz, ReflectClass res) {
 		ClassData clData = new ClassData();
 		clData._reflectClass = res;
 		clData.ignoreNullActivator = _ignoreNullActivator;
 		clData.threadLocal = _threadLocal;
 		List<ClassData> list = new ArrayList<ClassData>();
 		list.add(clData);
 		_classCache.put(clazz, list);
 	} 
 
 	public JVSTClass enhanceClass(Class clazz) {
 		ReflectClass res = findInCache(clazz);
 		if (res != null && res instanceof JVSTClass)
 			return (JVSTClass) res;
 		JVSTClass jclazz = new JVSTClass(parent(), this, _classPool, clazz, _threadLocal, _ignoreNullActivator, _persistPolicy,_activationPolicy);
 		addToCache(clazz, jclazz);
 		return jclazz;
 	}
 	
 	/**
 	 * Creates a copy of the object
 	 * 
 	 * @param obj
 	 *          object to copy
 	 * @return object copy
 	 */
 	public Object deepClone(Object obj) {
 		JVSTReflector clone = new JVSTReflector(_classLoader, _config);
 		return clone;
 	}
 
 	/**
 	 * Returns ReflectClass for the specified class
 	 * 
 	 * @param clazz
 	 *          class
 	 * @return ReflectClass for the specified class
 	 */
 	public ReflectClass forClass(Class clazz) {
 		return createClass(clazz);
 	}
 
 	/**
 	 * Returns ReflectClass for the specified class name
 	 * 
 	 * @param className
 	 *          class name
 	 * @return ReflectClass for the specified class name
 	 */
 	public ReflectClass forName(String className) {
 		Class clazz = _classLoader.loadClass(className);
 		if (clazz == null)
 			return null;
 		return createClass(clazz);
 	}
 
 	/**
 	 * Returns ReflectClass for the specified class object
 	 * 
 	 * @param a_object
 	 *          class object
 	 * @return ReflectClass for the specified class object
 	 */
 	public ReflectClass forObject(Object a_object) {
 		if (a_object == null)
 			return null;
 		return parent().forClass(a_object.getClass());
 	}
 	
 	public ActivateOnMethodPolicy getActivationPolicy() {
 		return _activationPolicy;
 	}	
 	
 	public PersistOnMethodPolicy getPersistPolicy() {
 		return _persistPolicy;
 	}
 
 	/**
 	 * Method stub. Returns false.
 	 */
 	public boolean isCollection(ReflectClass candidate) {
 		return false;
 	}
 
 	/**
 	 * Method stub. Returns false.
 	 */
 	public boolean methodCallsSupported() {
 		return true;
 	}
 
 	Object nullValue(ReflectClass clazz) {
 		return Platform4.nullValue(JdkReflector.toNative(clazz));
 	}
 
 	private Reflector parent() {
 		if(_parent == null){
 			return this;
 		}
 		return _parent; 
 	}
 
 	public void setActivationPolicy(ActivateOnMethodPolicy activationPolicy) {
 		_activationPolicy = activationPolicy;
 	}
 
 	/**
 	 * Sets parent reflector
 	 * 
 	 * @param reflector
 	 *          parent reflector
 	 */
 	public void setParent(Reflector reflector) {
 		_parent = reflector;
 	}
 
 	public void setPersistPolicy(PersistOnMethodPolicy persistPolicy) {
 		_persistPolicy = persistPolicy;
 	}
 
 	public void setThreadLocal(boolean threadLocal) {
 		_threadLocal = threadLocal;
 	}
 	
 	public void setIgnoreNullActivator(boolean ignore) {
 		_ignoreNullActivator = ignore;
 	}
 
 }