package org.kite9.diagram.builders;
   
   import java.lang.reflect.Field;
   import java.lang.reflect.Method;
   import java.lang.reflect.Modifier;
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.LinkedHashSet;
   import java.util.List;
  import java.util.Set;
  
  import org.kite9.framework.model.MemberHandle;
  import org.kite9.framework.model.ProjectModel;
  
  public class ClassBuilder extends AbstractAnnotatedElementBuilder<Class<?>> {
  
  	public ClassBuilder(List<Tie<? extends Object, Class<?>>> forX, ProjectModel model) {
  		super(forX, model);
  	}
  
  	public ClassBuilder showVisibility(Format f) {
  		for (Class<?> c : allElements) {
  			if (Modifier.isPublic(c.getModifiers())) {
  				f.write(c, HasRelationship.VISIBILITY, new JavaModifier("public"));
  			} else if (Modifier.isPrivate(c.getModifiers())) {
  				f.write(c, HasRelationship.VISIBILITY, new JavaModifier("private"));
  			} else if (Modifier.isProtected(c.getModifiers())) {
  				f.write(c, HasRelationship.VISIBILITY, new JavaModifier("protected"));
  			}
  		}
  		return this;
  	}
  
  	public ClassBuilder showStatic(Format f) {
  		for (Class<?> c : allElements) {
  			if (c.getEnclosingClass() != null) {
  				// inner class
  				if (Modifier.isStatic(c.getModifiers())) {
  					f.write(c, HasRelationship.MODIFIER, new JavaModifier("static"));
  				}
  			}
  		}
  		return this;
  	}
  
  	public ClassBuilder show(Format f) {
  		return (ClassBuilder) super.show(f);
  	}
  
  	public ClassBuilder showFinal(Format f) {
  		for (Class<?> c : allElements) {
  			if (Modifier.isFinal(c.getModifiers())) {
  				f.write(c, HasRelationship.MODIFIER, new JavaModifier("final"));
  			}
  		}
  		return this;
  	}
  
  	/***
  	 * Creates a helper to allow you to manipulate the superclasses of the
  	 * classes that this builder manages.
  	 * 
  	 * @param f
  	 *            An optional filter to reduce the number of interfaces being
  	 *            considered.
  	 */
  	public ClassBuilder withSuperClasses(Filter<? super Class<?>> f) {
  		return new ClassBuilder(packContent(allElements, f, new ClassContentSelector<Class<?>>() {
  
  			public Class<?>[] contents(Class<?> c) {
  				return new Class<?>[] { c.getSuperclass() };
  			}
  
  			public Set<? extends Class<?>> traverse(Class<?> c) {
  				throw new UnsupportedOperationException("Not implemented for superClass selector");
  			}
  
  		}, false, Relationship.EXTENDS), model);
  	}
  
  	/***
  	 * Creates a helper to allow you to manipulate the interfaces this class
  	 * implements or extends
  	 * 
  	 * @param f
  	 *            An optional filter to reduce the number of interfaces being
  	 *            considered.
  	 * 
  	 * @param traverse
  	 *            Set to true if you want interfaces declared by superclasses
  	 *            and superinterfaces too
  	 */
  	public ClassBuilder withInterfaces(Filter<? super Class<?>> f, boolean traverse) {
  		return new ClassBuilder(packContent(allElements, f, new ClassContentSelector<Class<?>>() {
  
  			public Class<?>[] contents(Class<?> c) {
  				return c.getInterfaces();
  			}
  
 			public Set<? extends Class<?>> traverse(Class<?> c) {
 				return superTraverse(c);
 			}
 
 		}, traverse, Relationship.IMPLEMENTS), model);
 	}
 
 	/***
 	 * Creates a helper to allow you to manipulate methods on this class.
 	 * 
 	 * @param f
 	 *            An optional filter to reduce the number of methods being
 	 *            considered.
 	 * 
 	 * @oparam traverse Set to true if you want declarations from superclasses
 	 *         and superinterfaces too
 	 */
 	public MethodBuilder withMethods(Filter<? super Method> f, boolean traverse) {
 		return new MethodBuilder(packContent(allElements, f, new ClassContentSelector<Method>() {
 			public Method[] contents(Class<?> c) {
 				return c.getDeclaredMethods();
 			}
 
 			public Set<? extends Class<?>> traverse(Class<?> c) {
 				return superTraverse(c);
 			}
 
 		}, traverse, HasRelationship.METHOD), model);
 	}
 
 	/***
 	 * Creates a helper to allow you to manipulate inner classes on this class.
 	 * 
 	 * @param f
 	 *            An optional filter to reduce the number of methods being
 	 *            considered.
 	 * 
 	 * @oparam traverse Set to true if you want declarations from superclasses
 	 *         too
 	 */
 	public ClassBuilder withInnerClasses(Filter<? super Class<?>> f, boolean traverse) {
 		return new ClassBuilder(packContent(allElements, f, new ClassContentSelector<Class<?>>() {
 			public Class<?>[] contents(Class<?> c) {
 				return c.getDeclaredClasses();
 			}
 
 			public Set<? extends Class<?>> traverse(Class<?> c) {
 				return Collections.singleton(c.getSuperclass());
 			}
 		}, traverse, HasRelationship.INNER_CLASS), model);
 	}
 
 	/***
 	 * Creates a helper to allow you to manipulate subclasses within the project
 	 * of the current class or classes.
 	 * 
 	 * @param f
 	 *            Optional filter to reduce the number of returned classes
 	 * @param traverse
 	 *            set to true if you want the entire subclass tree (i.e.
 	 *            sub-sub-classes etc)s
 	 * @return
 	 */
 	public ClassBuilder withSubClasses(Filter<? super Class<?>> f, boolean traverse) {
 		final ClassLoader cl = Thread.currentThread().getContextClassLoader();
 		return new ClassBuilder(packContent(allElements, f, new ClassContentSelector<Class<?>>() {
 			public Class<?>[] contents(Class<?> c) {
 				return MemberHandle.hydrateClasses(model.getSubclasses(MemberHandle.convertClassName(c)), cl).toArray(
 						new Class<?>[] {});
 			}
 
 			public Set<Class<?>> traverse(Class<?> c) {
 				return MemberHandle.hydrateClasses(model.getSubclasses(MemberHandle.convertClassName(c)), cl);
 			}
 		}, traverse, Relationship.EXTENDS), model);
 
 	}
 
 	protected interface ClassContentSelector<T> extends ContentSelector<T, Class<?>> {
 
 	}
 
 	/***
 	 * Creates a helper to allow you to manipulate fields on this class.
 	 * 
 	 * @param f
 	 *            An optional filter to reduce the number of methods being
 	 *            considered.
 	 * @oparam traverse Set to true if you want declarations from superclasses
 	 *         too
 	 */
 	public FieldBuilder withFields(Filter<? super Field> f, boolean traverse) {
 		return new FieldBuilder(packContent(allElements, f, new ClassContentSelector<Field>() {
 			public Field[] contents(Class<?> c) {
 				return c.getDeclaredFields();
 			}
 
 			public Set<? extends Class<?>> traverse(Class<?> c) {
 				return Collections.singleton(c.getSuperclass());
 			}
 		}, traverse, HasRelationship.FIELD), model);
 	}
 
 	private Set<? extends Class<?>> superTraverse(Class<?> c) {
 		LinkedHashSet<Class<?>> out = new LinkedHashSet<Class<?>>();
 		if (c.getSuperclass() != null)
 			out.add(c.getSuperclass());
 		for (int i = 0; i < c.getInterfaces().length; i++) {
 			out.add(c.getInterfaces()[i]);
 		}
 		return out;
 	}
 
 	/***
 	 * This is a helper method used to create a list of ties correctly, by
 	 * applying a ContentSelector.
 	 */
 	protected <Y> List<Tie<? extends Object, Y>> packContent(Set<? extends Class<?>> allElements, Filter<? super Y> f,
 			ClassContentSelector<Y> ccs, boolean traverse, Relationship r) {
 		List<Tie<? extends Object, Y>> out = new ArrayList<Tie<? extends Object, Y>>();
 		packContentInner(allElements, f, ccs, traverse, r, out);
 		return out;
 	}
 
 	protected <Y> void packContentInner(Set<? extends Class<?>> allElements, Filter<? super Y> f,
 			ClassContentSelector<Y> ccs, boolean traverse, Relationship r, List<Tie<? extends Object, Y>> out) {
 		for (Class<?> orig : allElements) {
 			Class<?> c = orig;
 			if (model.withinModel(MemberHandle.convertClassName(c))) {
 				for (Y Y : ccs.contents(c)) {
 					if ((f == null) || (f.accept(Y))) {
 						out.add(new Tie<Object, Y>(orig, r, Y));
 					}
 				}
 
 				if (traverse) {
 					packContentInner(ccs.traverse(c), f, ccs, traverse, r, out);
 				}
 			}
 		}
 	}
 
 	@Override
 	public ClassBuilder reduce(Filter<? super Class<?>> f) {
 		return new ClassBuilder(reduceInner(f), model);
 	}
 
 	/***
 	 * Assumes that the classes in this builder are annotations, and provides
 	 * you with a classbuilder of classes that have declared these annotations.
 	 */
 	public ClassBuilder withAnnotatedClasses(Filter<? super Class<?>> f) {
 		final ClassLoader cl = Thread.currentThread().getContextClassLoader();
 		return new ClassBuilder(packContent(allElements, f, new ClassContentSelector<Class<?>>() {
 			public Class<?>[] contents(Class<?> c) {
 				Set<String> classNames = model.getClassesWithAnnotation(MemberHandle.convertClassName(c));
 				Class<?>[] out = new Class<?>[classNames.size()];
 				int i = 0;
 				for (String name : classNames) {
 					out[i++] = MemberHandle.hydrateClass(name, cl);
 				}
 				return out;
 			}
 
 			public Set<? extends Class<?>> traverse(Class<?> c) {
 				return Collections.singleton(c.getSuperclass());
 			}
 		}, false, HasRelationship.ANNOTATION_OF), model);
 	}
 
 }