/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.openjpa.persistence.util;

import java.io.PrintWriter;
import java.util.*;

import org.apache.openjpa.lib.util.Localizer;


/**
 * A utility to help writing Java Source code dynamically.
 * 
 * Provides basic elements of Java Source Code e.g. Package, Class, Field, 
 * Method, Import, Annotation, Argument.
 * 
 * Mutator methods return the operating element for easy chaining. 
 * 
 * @author Pinaki Poddar
 * 
 * @since 2.0.0
 *
 */
public class SourceCode {
	private static Localizer _loc = Localizer.forPackage(SourceCode.class);
	
	/**
	 * List of Java Keywords and primitive types. Populated statically.
	 */
    private static final ArrayList<String> reserved = new ArrayList<String>();
    private static final ArrayList<String> knownTypes = new ArrayList<String>();
	
	private static int TABSIZE                = 4;
	private static final String SPACE         = " ";
	private static final String BLANK         = "";
	private static final String SEMICOLON     = ";";
    public static final String  COMMA         = ",";
    public static final String  DOT           = ".";
    public static final String  EQUAL         = "=";
    public static final String  QUOTE         = "\"";

	private static final Delimiter BLOCK_DELIMITER  = new Delimiter("{}");
	private static final Delimiter ARGS_DELIMITER   = new Delimiter("()");
    private static final Delimiter PARAMS_DELIMITER = new Delimiter("<>");
	
	private List<Comment> comments;
	private final Package pkg;
	private final Class   cls;
    private final Set<Import> imports = new TreeSet<Import>();
	
	
	/**
	 * Create source code for a top-level class with given fully-qualified 
	 * class name. 
	 */
	public SourceCode(String c) {
	    ClassName name = getOrCreateImport(c);
	    this.cls = new Class(c);
        this.pkg = new Package(name.getPackageName());
	}
	
	/**
	 * Gets the top level class represented by this receiver.
	 */
	public Class getTopLevelClass() {
		return cls;
	}
	
	public Package getPackage() {
	    return pkg;
	}
	
    /**
     * Sets the tab size. Tabs are always written as spaces.
     */
    public SourceCode setTabSize(int t) {
        if (t>0) TABSIZE = Math.max(t, 8);
        return this;
    }

    /**
     * Adds import to this source code. Adding an import may force the given class name
     * to use its full name if it is hidden by other imports.
     * 
     * @param name a ClassName instance
     * @return true if the import is added. ClassName starting with <code>java.lang.</code>
     * is not added.
     */
	private boolean addImport(ClassName name) {
		String pkgName = name.getPackageName();
		for (Import i : imports) {
		    if (i.getClassName().hides(name)) {
		        i.getClassName().useFullName();
		        name.useFullName();
		    }
		}
		return imports.add(new Import(name));
	}
	
	/**
	 * Get the class name instance for the given fully-qualified class name.
	 * If the given class name is already imported, then use the existing instance.
	 * Otherwise, creates a new instance and adds it to list of imports. 
	 * 
	 * @see #addImport(ClassName)
	 * @see ClassName
	 * 
	 * @param name fully-qualified name of a class
	 * @return an existing class name instance or a new one. 
	 */
	public ClassName getOrCreateImport(String name) {
	    for (Import i : imports) {
	        if (i.name.getFullName().equals(name))
	            return i.name;
	    }
	    ClassName imp = new ClassName(name);
	    addImport(imp);
	    return imp;
	}
	
	
	public SourceCode addComment(boolean inline, String... lines) {
	    if (lines == null)
	        return this;
		if (comments == null) 
		    comments = new ArrayList<Comment>();
		Comment comment = new Comment();
		comments.add(comment);
		comment.makeInline(inline);
		for (String line:lines) {
		    // Handle long header comment lines...
		    if (line.length() > 120-4) {
		        String[] wrappedLines = wrap(line, 120-4);
		        for (String w:wrappedLines) comment.append(w);
		    } else {
	            comment.append(line);
		    }
		}
		return this;
	}
	
	/**
	 * Prints the class to the given Writer.
	 * @param out
	 */
	public void write(PrintWriter out) {
		if (comments != null) {
		    for (Comment comment : comments) {
		        comment.write(out, 0);
		        out.println();
		    }
		}
		if (pkg != null) {
		    pkg.write(out,0);
		    out.println();
		}
		for (Import imp:imports) {
			imp.write(out, 0);
		}
		out.println();
		cls.write(out, 0);
		out.flush();
	}
	
	/**
	 * Outputs <code>tab</code> number of spaces.
	 */
	static void tab(PrintWriter out, int tab) {
		for (int i=0; i<tab*TABSIZE; i++) {
			out.print(SPACE);
		}
	}
	
    /**
     * Wraps the given string into lines of max length width at word boundaries
     */
    public static String[] wrap(String longLine, int width) {
        String[] words = longLine.split("\\ ");
        List<String> lines = new ArrayList<String>();
        StringBuilder line = new StringBuilder();
        for (int i = 0; i < words.length; i++) {
            String w = words[i];
            if (line.length() + w.length() < width) {
                if (line.length() > 0) line.append(" ");
                line.append(w);
            } else {
                lines.add(line.toString());
                line.setLength(0);
                line.append(w);
            }
        }
        lines.add(line.toString());
        return lines.toArray(new String[lines.size()]);
    }
	
    static void writeList(PrintWriter out, String header, List<?> list) { 
        writeList(out, header, list, new Delimiter(), false);
    }
	
	static void writeList(PrintWriter out, String header, List<?> list, 
			Delimiter bracket, boolean writeEmpty) {
		if (list == null || list.isEmpty()) {
		    if (writeEmpty)
		        out.append(bracket.start)
		           .append(bracket.end);
			return;
		}
		out.append(header);
		out.append(bracket.start);
		for (int i=0; i<list.size(); i++) {
			out.append(list.get(i).toString());
			if (i!=list.size()-1) out.append(COMMA);
		}
		out.append(bracket.end);
	}
	
	static String capitalize(String s) {
		return Character.toUpperCase(s.charAt(0))+s.substring(1);
	}
	
	static boolean isValidToken(String s) {
		return s != null && s.length() > 0 && 
		      !reserved.contains(s) && isJavaIdentifier(s);
	}
	
	public static boolean isKnownType(String s) {
		return knownTypes.contains(s);
	}
	
	static boolean isEmpty(String s) {
		return s == null || s.length()==0;
	}
	
	static LinkedList<String> tokenize(String s, String delim) {
	    StringTokenizer tokenizer = new StringTokenizer(s, delim, false);
		LinkedList<String> tokens = new LinkedList<String>();
		while (tokenizer.hasMoreTokens())
			tokens.add(tokenizer.nextToken());
		return tokens;
	}
	
	public static boolean isJavaIdentifier(String s) {
        if (s == null || s.length() == 0 || 
        	!Character.isJavaIdentifierStart(s.charAt(0))) {
            return false;
        }
        for (int i=1; i<s.length(); i++) {
            if (!Character.isJavaIdentifierPart(s.charAt(i))) {
                return false;
            }
        }
        return true;
    }
	
	
    public enum ACCESS {PUBLIC, PROTECTED, PRIVATE}
		
	/**
	 * Abstract element has a name, optional list of modifiers, annotations
	 * and arguments. 
	 */
	public abstract class Element<T> implements Comparable<Element<T>> {
		protected String name;
		protected ClassName type;
		protected ACCESS access;
		protected boolean isStatic;
		protected boolean isFinal;
		protected Comment comment;
		protected List<ClassName> params = new ArrayList<ClassName>();
		protected List<Annotation> annos = new ArrayList<Annotation>();
		
        protected Element(String name, ClassName type) {
            this.name = name;
            this.type = type;
        }

        public ClassName getType() {
			return type;
		}
				
		public Annotation addAnnotation(String a) {
			Annotation an = new Annotation(a);
			annos.add(an);
			return an;
		}
		
		public Element<T> addParameter(String param) {
		    params.add(getOrCreateImport(param));
		    return this;
		}
		
		public int compareTo(Element<T> other) {
			return name.compareTo(other.name);
		}
		
		public T addComment(boolean inline, String... lines) {
			if (comment == null) comment = new Comment();
			comment.makeInline(inline);
			for (String line:lines) comment.append(line);
			return (T)this;
		}
		
		public T makePublic() {
			access = ACCESS.PUBLIC;
			return (T)this;
		}
		
		public T makeProtected() {
			access = ACCESS.PROTECTED;
			return (T)this;
		}
		
		public T makePrivate() {
			access = ACCESS.PRIVATE;
			return (T)this;
		}
		
		public T makeStatic() {
			isStatic = true;
			return (T)this;
		}
		
		public T makeFinal() {
			isFinal = true;
			return (T)this;
		}
		
		public void write(PrintWriter out, int tab) {
			if (comment != null) comment.write(out, tab);
			for (Annotation a:annos)
				a.write(out, tab);
			tab(out, tab);
			if (access != null) 
			    out.append(access.toString().toLowerCase(Locale.ENGLISH) + SPACE);
			if (isStatic) 
			    out.append("static" + SPACE);
			if (isFinal) 
			    out.append("final" + SPACE);
		}
	}

	/**
	 * Represent <code>class</code> declaration.
	 *
	 */
	public class Class extends Element<Class> {
        private boolean isAbstract;
		private boolean isFinal;
		private ClassName superCls;
		private List<ClassName> interfaces = new ArrayList<ClassName>();
	    private Set<Field> fields   = new TreeSet<Field>();
	    private Set<Method> methods = new TreeSet<Method>();
	    private Set<Constructor> constructors = new TreeSet<Constructor>();
		
		public Class(String name) {
			super(name, getOrCreateImport(name));
			makePublic();
		}
		
		public Class setSuper(String s) {
			superCls = getOrCreateImport(s);
			return this;
		}
		
		public Class addInterface(String s) {
			interfaces.add(getOrCreateImport(s));
			return this;
		}
		
        public Class makeAbstract() {
            if (isFinal)
                throw new IllegalArgumentException(_loc.get("src-invalid-modifier").toString());

            isAbstract = true;
            return this;
        }

        public Class makeFinal() {
            if (isAbstract)
                throw new IllegalArgumentException(_loc.get("src-invalid-modifier").toString());
            isFinal = true;
            return this;
        }
		
	    /**
	     * Adds getters and setters to every non-public field.
	     */
	    public Class markAsBean() {
	        for (Field f:fields)
	            f.markAsBean();
	        return this;
	    }

        public String getName() {
            return getType().getSimpleName();
        }
        
        public String getPackageName() {
            return getType().getPackageName();
        }
        
        public Field addField(String name, String type) {
            return addField(name, getOrCreateImport(type));
        }

        public Field addField(String f, ClassName type) {
	        if (!isValidToken(f)) {
	            throw new IllegalArgumentException(
	                _loc.get("src-invalid-field",f).toString());
	        }
	        Field field = new Field(this, f, type);
	        
	        if (!fields.add(field))
	            throw new IllegalArgumentException(_loc.get(
	                "src-duplicate-field", field, this).toString());
	        return field;
	    }

        public Method addMethod(String m, String retType) {
            return addMethod(m, getOrCreateImport(retType));
        }
        
	    protected Method addMethod(String m, ClassName retType) {
	        if (isEmpty(m) || !isValidToken(m)) {
	            throw new IllegalArgumentException(_loc.get(
	                "src-invalid-method",m).toString());
	        }
	        Method method = new Method(m, retType);
	        if (!methods.add(method)) 
	            throw new IllegalArgumentException(_loc.get(
	                "src-duplicate-method", method, this).toString());
	        return method;
	    }

	    public Constructor addConstructor(){
	        Constructor c = new Constructor(type.simpleName);
	           if (!constructors.add(c)) 
	                throw new IllegalArgumentException(_loc.get(
	                    "src-duplicate-constructor", c, this).toString());
	            return c;
	    }
	    public void write(PrintWriter out, int tab) {
			super.write(out, tab);
			if (isAbstract) 
			    out.append("abstract ");
			if(isFinal)
			    out.append("final ");
			out.print("class ");
			out.print(type.simpleName);
			writeList(out, BLANK, params, PARAMS_DELIMITER, false);
			if (superCls != null)
				out.print(" extends " + superCls + SPACE);
			writeList(out, "implements ", interfaces);
			out.println(SPACE + BLOCK_DELIMITER.start);
	        for (Field field:fields) 
	            field.write(out, 1);
	        for(Constructor ctor : constructors){
	            ctor.write(out, 1);
	        }
	        for (Method method:methods) 
	            method.write(out, 1);
	        out.println(BLOCK_DELIMITER.end);
		}
	    
	    public String toString() {
	    	return getType().fullName;
	    }
	}

	/**
	 * Represents field declaration.
	 *
	 */
	public class Field extends Element<Field> {
	    private final Class owner;
		protected boolean isTransient;
		protected boolean isVolatile;
		
		Field(Class owner, String name, ClassName type) {
			super(name, type);
			this.owner = owner;
			makePrivate();
		}
		
		/**
		 * Adds bean-style getter setter method.
		 */
		public Field markAsBean() {
			addGetter();
			addSetter();
			return this;
		}
		
		public Field addGetter() {
			owner.addMethod("get"+ capitalize(name), type)
			     .makePublic()
			     .addCodeLine("return "+ name);
			return this;
		}
		
		public Field addSetter() {
			owner.addMethod("set"+ capitalize(name), "void")
			     .makePublic()
                 .addArgument(new Argument<ClassName,String>(type, name,SPACE))
			     .addCodeLine("this."+ name + " = " + name);
			return this;
		}
		
        public void makeVolatile() {
            isVolatile = true; 
        }
        
        public void makeTransient() {
            isTransient = true; 
        }
		
		public String toString() {
			return type + SPACE + name;
		}
		
		public void write(PrintWriter out, int tab) {
			super.write(out, tab);
			if (isVolatile) out.print("volatile ");
			if (isTransient) out.print("transient ");
			out.print(type);
			writeList(out, BLANK, params, PARAMS_DELIMITER, false);
			out.println(SPACE + name + SEMICOLON);
		}
		
		public boolean equals(Object other) {
			if (other instanceof Field) {
				Field that = (Field)other;
				return name.equals(that.name);
			}
			return false;
		}
	}
	
	/**
	 * Represents Method declaration.
	 * 
	 *
	 */
	public class Method extends Element<Method> {
		private boolean isAbstract;
		private List<Argument<ClassName,String>> args = new ArrayList<Argument<ClassName,String>>();
		private List<String> codeLines = new ArrayList<String>();
		int tabCount = 0;
		String tab = "";

        Method(String n, String t) {
            this(n, getOrCreateImport(t));
        }
        
        public Method(String name, ClassName returnType) {
            super(name, returnType);
            makePublic();
        }
		
		public Method addArgument(Argument<ClassName,String> arg) {
			args.add(arg);
			return this;
		}
		
		public Method addArgument(String className, String argName){
		    ClassName cn = getOrCreateImport(className);
		    args.add(new Argument<ClassName, String>(cn, argName," "));
		    return this;
		}
		
        public void setTab(boolean inc) {
            if (inc)
                tabCount++;
            else
                tabCount--;
            tab = "";
            for (int i = 0; i < tabCount * TABSIZE; i++) {
                tab += SPACE;
            }
        }

        public Method addCodeLine(String line) {
            if (isAbstract)
                throw new IllegalStateException("abstract method " + name + " can not have body");
            // This doesn't handle try{ ... catch(){ if{
            if (line.endsWith("{") || line.endsWith("}")) {

            }
            if (!line.endsWith(SEMICOLON)
                && !(line.isEmpty() || line.endsWith("{") || line.endsWith("}") || line.startsWith("if")))
                line = line + SEMICOLON;
            codeLines.add(tab + line);
            return this;
        }

        /**
         * if tabInc = true, the current line, and all following lines will be tabbed.
         *  If false, a tab will be removed.
         */
        public Method addCodeLine(String line, boolean tabInc) {
            setTab(tabInc);
            return addCodeLine(line);
        }
		
		public Method makeAbstract() {
			if (codeLines.isEmpty())
				isAbstract = true;
			else
                throw new IllegalStateException("method " + name + 
				    " can not be abstract. It has a body");
			return this;
		}
		
		
		public String toString() {
			return type + SPACE + name;
		}
		
		public void write(PrintWriter out, int tab) {
			out.println(BLANK);
			super.write(out, tab);
			if (isAbstract) out.append("abstract ");
			out.print(type + SPACE + name);
			writeList(out, BLANK, args, ARGS_DELIMITER, true);
			if (isAbstract) {
				out.println(SEMICOLON);
				return;
			}
			out.println(SPACE + BLOCK_DELIMITER.start);
			for (String line : codeLines) {
				tab(out, tab+1);
				out.println(line);
			}
			tab(out, tab);
			out.println(BLOCK_DELIMITER.end);
		}
		
		public boolean equals(Object other) {
			if (other instanceof Method) {
				Method that = (Method)other;
                return name.equals(that.name) && args.equals(that.args);
			}
			return false;
		}
	}
	
	public class Constructor extends Element<Constructor> {
	    private List<Argument<ClassName,String>> args = new ArrayList<Argument<ClassName,String>>();
        private List<String> codeLines = new ArrayList<String>();
        int tabCount = 0;
        String tab = "";
        
	    public Constructor(String name) {
	        super(name, null);
	        makePublic();
        }
        
        public Constructor addArgument(Argument<ClassName,String> arg) {
            args.add(arg);
            return this;
        }

        public Constructor addArgument(String className, String argName) {
            ClassName cn = getOrCreateImport(className);
            args.add(new Argument<ClassName, String>(cn, argName, " "));
            return this;
        }
        
        public Constructor addCodeLine(String line) {
            // This doesn't handle try{ ... catch(){ if{
            if (line.endsWith("{") || line.endsWith("}")) {

            }
            if (!line.endsWith(SEMICOLON)
                && !(line.isEmpty() || line.endsWith("{") || line.endsWith("}") || line.startsWith("if")))
                line = line + SEMICOLON;
            codeLines.add(tab + line);
            return this;
        }
        /**
         *  if tabInc = true, the current line, and all following lines will be tabbed. If false, a tab will be removed.
         */
        public Constructor addCodeLine(String line, boolean tabInc) {
            setTab(tabInc);
            return addCodeLine(line);
        }
        
        public void setTab(boolean inc) {
            if (inc)
                tabCount++;
            else
                tabCount--;
            tab = "";
            for (int i = 0; i < tabCount * TABSIZE; i++) {
                tab += SPACE;
            }
        }
        
        @Override
        public void write(PrintWriter out, int tab) {
            out.println(BLANK);
            super.write(out, tab);
            out.print(name);
            writeList(out, BLANK, args, ARGS_DELIMITER, true);

            out.println(SPACE + BLOCK_DELIMITER.start);
            for (String line : codeLines) {
                tab(out, tab+1);
                out.println(line);
            }
            tab(out, tab);
            out.println(BLOCK_DELIMITER.end);
        }
	    
	}
	/**
	 * Represents <code>import</code> statement.
	 *
	 */
	class Import implements Comparable<Import> {
		private final ClassName name;
		
		public Import(ClassName name) {
			this.name = name;
		}
		
		public int compareTo(Import other) {
			return name.compareTo(other.name);
		}
		
		public void write(PrintWriter out, int tab) {
		    if (name.usingFullName())
		        return;
		    String pkg = name.getPackageName();
		    if (pkg.length() == 0 || pkg.equals(getPackage().name))
		        return;
		    out.println("import "+ name.fullName + SEMICOLON);
		}
		
		public boolean equals(Object other) {
			if (other instanceof Import) {
				Import that = (Import)other;
				return name.equals(that.name);
			}
			return false;
		}
		
		ClassName getClassName() {
		    return name;
		}
	}
	
	/**
	 * Represents method argument.
	 *
	 */
	public class Argument<K,V> {
		final private K key;
		final private V value;
		final private String connector;
		
		Argument(K key, V value, String connector) {
			this.key = key;
			this.value = value;
			this.connector = connector;
		}
		
        public String toString() {
			return key + connector + value;
		}
	}
	
	/**
	 * Represents annotation.
	 *
	 */
	public class Annotation {
		private String name;
        private List<Argument<?,?>> args = new ArrayList<Argument<?,?>>();
		
		Annotation(String n) {
			name = n;
		}
		
        public Annotation addArgument(String key, String v, boolean quote) {
            return addArgument(new Argument<String,String>(key, 
                quote ? quote(v) : v, EQUAL));
        }
        
        public Annotation addArgument(String key, String v) {
            return addArgument(key, v, true);
        }
        
        public Annotation addArgument(String key, String[] vs) {
            StringBuilder tmp = new StringBuilder(BLOCK_DELIMITER.start);
            for (int i=0; i < vs.length; i++) {
                tmp.append(quote(vs[i]));
                tmp.append(i != vs.length-1 ? COMMA : BLANK);
            }
            tmp.append(BLOCK_DELIMITER.end);
            return addArgument(key, tmp.toString(), false);
        }
        
        public <K,V> Annotation addArgument(Argument<K,V> arg) {
            args.add(arg);
            return this;
        }
		
		public void write(PrintWriter out, int tab) {
			tab(out, tab);
			out.println("@"+name);
			writeList(out, BLANK, args, ARGS_DELIMITER, false);
			out.println();
		}
		
		String quote(String s) {
		    return QUOTE + s + QUOTE;
		}
	}
	
	static class Package {
		private String name;
		
		Package(String p) {
			name = p;
		}
		
        public void write(PrintWriter out, int tab) {
            if (name != null && !name.isEmpty())
                out.println("package " + name + SEMICOLON);
        }
	}
	
	class Comment {
		List<String> lines = new ArrayList<String>();
		private boolean inline = false;
		
		public void append(String line) {
			lines.add(line);
		}
		
		boolean isEmpty() {
			return lines.isEmpty();
		}
		
		void makeInline(boolean flag) {
			inline = flag;
		}
		public void write(PrintWriter out, int tab) {
			if (inline) {
				for (String l:lines) {
					tab(out, tab);
					out.println("// " + l);
				}
			} else {
				int i = 0;
				for (String l:lines) {
					tab(out, tab);
					if (i == 0) {
						out.println("/** ");
						tab(out, tab);
					}
                    out.println(" *  " + l);
					i++;
				}
				tab(out, tab);
				out.println("**/");
			}
		}
	}
	
	/**
	 * Represents fully-qualified name of a Java type.
	 * 
	 * NOTE: Do not construct directly unless necessary.
	 * @see SourceCode#getOrCreateImport(String)
	 */
	private class ClassName implements Comparable<ClassName> {
        public final String fullName;
        public final String simpleName;
        public final String pkgName;
        private String  arrayMarker = BLANK;
        private boolean useFullName = false;
        
	    ClassName(String name) {
	    	while (isArray(name)) {
	    		arrayMarker = arrayMarker + "[]"; 
	    		name = getComponentName(name);
	    	}
            int start = name.indexOf("<");
            int stop = name.lastIndexOf(">");
            if (start != -1 && stop != -1) {
                name = name.substring(0, start) + name.substring(stop + 1); 
            }
	        this.fullName = name;
	        int dot = fullName.lastIndexOf(DOT);
	        simpleName = (dot == -1) ? fullName : fullName.substring(dot+1);
	        pkgName = (dot == -1) ? BLANK : fullName.substring(0,dot);
            if (!isValidTypeName(name)) {
                throw new IllegalArgumentException(_loc.get("src-invalid-type", 
                    name).toString());
            }
	    }
	    
	    /**
	     * Gets fully qualified name of this receiver.
	     */
	    public String getFullName() {
	        return fullName + arrayMarker;
	    }
	    
        /**
         * Gets simple name of this receiver.
         */
	    public String getSimpleName() {
	        return simpleName + arrayMarker;
	    }
	    
	    /**
	     * Gets the package name of this receiver. Default package name is 
	     * represented as empty string.
	     */
	    public String getPackageName() {
	        return pkgName;
	    }
	    
	    /**
	     * Gets the full or simple name of this receiver based on useFullName flag.
	     */
	    public String toString() {
	        return (useFullName ? fullName : simpleName) + arrayMarker;
	    }
	    
	    /**
	     * Compares by fully-qualified name.
	     */
	    public int compareTo(ClassName other) {
	        return getFullName().compareTo(other.getFullName());
	    }
	    
	    public boolean isValidTypeName(String s) {
	        return isValidPackageName(pkgName) 
	            && (isKnownType(s) || isValidToken(simpleName));
	    }
	    
	    boolean isValidPackageName(String s) {
	        if (isEmpty(s)) return true;
	        LinkedList<String> tokens = tokenize(s, DOT);
	        for (String token : tokens) {
	            if (!isValidToken(token))
	                return false;
	        }
	        return !s.endsWith(DOT);
	    }
	    
	    boolean isArray(String name) {
	    	return name.endsWith("[]");
	    }
	    
	    String getComponentName(String name) {
	    	return (!isArray(name)) ? name : 
	    		name.substring(0, name.length()-"[]".length());
	    }
	    
	    boolean hides(ClassName other) {
	        return this.getSimpleName().equals(other.getSimpleName())
	            && !this.fullName.equals(other.fullName);
	    }
	    
	    void useFullName() {
	        useFullName = true;
	    }
	    
	    boolean usingFullName() {
	        return useFullName;
	    }
	    
	}
	
	static class Delimiter {
	    final char start;
	    final char end;
	    
        public Delimiter() {
            this((char)' ', (char)' ');
        }

	    public Delimiter(String pair) {
	        this(pair.charAt(0), pair.charAt(1));
	    }
	    
        public Delimiter(char start, char end) {
            super();
            this.start = start;
            this.end = end;
        }
	}
	
	static {
		reserved.add("abstract");
		reserved.add("continue");
		reserved.add("for");
		reserved.add("new");
		reserved.add("switch");
		reserved.add("assert");
		reserved.add("default"); 	
		reserved.add("goto");
		reserved.add("package");
		reserved.add("synchronized");
		reserved.add("boolean");
		reserved.add("do");
		reserved.add("if");
		reserved.add("private");
		reserved.add("this");
		reserved.add("break");
		reserved.add("double");
		reserved.add("implements");
		reserved.add("protected");
		reserved.add("throw");
		reserved.add("byte");
		reserved.add("else");
		reserved.add("import");
		reserved.add("public");
		reserved.add("throws");
		reserved.add("case");
		reserved.add("enum");
		reserved.add("instanceof");
		reserved.add("return");
		reserved.add("transient");
		reserved.add("catch");
		reserved.add("extends");
		reserved.add("int");
		reserved.add("short");
		reserved.add("try");
		reserved.add("char");
		reserved.add("final");
		reserved.add("interface");
		reserved.add("static");
		reserved.add("void");
		reserved.add("class");
		reserved.add("finally");
		reserved.add("long");
		reserved.add("strictfp");
		reserved.add("volatile");
		reserved.add("const");
		reserved.add("float");
		reserved.add("native");
		reserved.add("super");
		reserved.add("while");
		
		knownTypes.add("boolean");
		knownTypes.add("byte");
		knownTypes.add("char");
		knownTypes.add("double");
		knownTypes.add("float");
		knownTypes.add("int");
		knownTypes.add("long");
		knownTypes.add("short");
		knownTypes.add("void");
		knownTypes.add("String");
	}
}
