import java.io.*;
import java.lang.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.jar.*;
import java.util.zip.ZipEntry;
import java.text.Collator;

/**
* Builds Api file for use with SciTe.<br>
* Note: Classes to be processed must be in your CLASSPATH<br>
*
* @author <a href="mailto:nazimok@yahoo.com">Alex Nazimok</a>
* @version 1.1
*/
public class ApiBuilder
{
    private static ArrayList fileList = new ArrayList();
    private static boolean appendToFile = false;
    private static boolean isJar = false;
    private static final int MAX_OPTIONS = 2;

	/**
	* main method
	*/
    public static void main(String args[])
        throws Exception
    {
        ApiBuilder apiB = new ApiBuilder();

        if (args.length < 2)
           printUsage();

        int argNum = 0;
        for(int i = 0; i < MAX_OPTIONS; i++)
        {
            if(args[i].equals("-a"))
            {
                appendToFile = true;
                argNum++;
            }

            if(args[i].equals("-j"))
            {
                isJar = true;
                argNum++;
            }

            if(args[i].equals("-s"))
            {
                apiB.sortApiFile(args[1]);
                return;
            }
        }

        System.out.println("\n-----------------------------------------------");
        System.out.println("Starting processing...");
        if(!isJar)
            apiB.buildFileList(new File(args[argNum]));
        else
            apiB.processJar(args[argNum]);

        apiB.writeToFile(args[argNum], args[++argNum]);
        System.out.println("Done...");
        System.out.println("-----------------------------------------------\n");
    }

    /**
	* Creates a list of all of the methods for basedir .class files.
    * TODO: I am not sure at this point what the best way to handle inner
    * classes is so I am just replacing '$' with '.'
	*/
	private List buildMethodList(String baseDir)
        throws Exception
    {
        List methodList = new ArrayList();

        for (int i = 0; i < fileList.size(); i++)
        {
            String className = formatClassName(fileList.get(i).toString(), baseDir);

            Class clazz = getClass().getClassLoader().loadClass(className);

            if (clazz != null)
            {
                Method methods[] = clazz.getMethods();

                for (int j = 0; j < methods.length; j++)
                {
                    String sig = (methods[j].getName()).replace('$', '.') + "(";
                    Class[] params = methods[j].getParameterTypes();

                    for (int k = 0; k < params.length; k++)
                        sig += formatParams(params[k].getName());

                    if (sig.lastIndexOf(",") == sig.length() - 1)
                        sig = sig.substring(0, sig.length() - 1);

                    sig += ")";
                    if (!methodList.contains(sig))
                        methodList.add(sig);
                }
            }
        }
        return methodList;
    }

    /**
	* Creates a list of all of the constructors for basedir .class files.
	*/
    private List buildConstructorList(String baseDir)
        throws Exception
    {
        List methodList = new ArrayList();

        for (int i = 0; i < fileList.size(); i++)
        {
            String className = formatClassName(fileList.get(i).toString(), baseDir);

            Class clazz = getClass().getClassLoader().loadClass(className);

            if (clazz != null)
            {
                String packName = null;
                try{packName = clazz.getPackage().getName();}
                catch(Exception e){}

                Constructor methods[] = clazz.getConstructors();

                for (int j = 0; j < methods.length; j++)
                {
                    String constName = (methods[j].getName()).replace('$', '.');

                    if (packName != null && packName.length() > 0)
                        constName = constName.substring(constName.indexOf(packName) + packName.length() + 1);

                    String sig = constName + "(";
                    Class[] params = methods[j].getParameterTypes();

                    for (int k = 0; k < params.length; k++)
                        sig += formatParams(params[k].getName());

                    if (sig.lastIndexOf(",") == sig.length() - 1)
                        sig = sig.substring(0, sig.length() - 1);

                    sig += ")";
                    if (!methodList.contains(sig))
                        methodList.add(sig);
                }
            }
        }
        return methodList;
    }

	/**
	* Replaces arrays classloader representation with real values
	*/
    private String formatParams(String paramName)
    {
        String name = "";

        if (paramName.startsWith("[B"))
            name = "byte[],";
        else if (paramName.startsWith("[C"))
            name = "char[],";
        else if (paramName.startsWith("[D"))
            name = "double[],";
        else if (paramName.startsWith("[F"))
            name = "float[],";
        else if (paramName.startsWith("[I"))
            name = "int[],";
        else if (paramName.startsWith("[J"))
            name = "long[],";
        else if (paramName.startsWith("[S"))
            name = "short[],";
        else if (paramName.startsWith("[Z"))
            name = "boolean[],";
        else if (paramName.startsWith("[L"))
            name = paramName.substring(2, paramName.indexOf(";")) + "[],";
        else
            name = paramName + ",";

        return name.replace('$', '.');
    }

    /**
	* Sorts methods and constructors lists and writes them to file.
	*/
	private void writeToFile(String baseDir, String outputFile)
        throws Exception
    {
        RandomAccessFile output = new RandomAccessFile(outputFile, "rw");

        if (appendToFile)
            output.seek(output.length());

        PrintWriter bw = new PrintWriter(new FileWriter(output.getFD()));
        List methodList = buildMethodList(baseDir);
        List constructorList = buildConstructorList(baseDir);
        List all = new ArrayList();

        all.addAll(methodList);
        all.addAll(constructorList);

        Collections.sort(all, new CaseCompareator());

        for (int j = 0; j < all.size(); j++)
        {
            bw.println((String) all.get(j));
            bw.flush();
        }

        bw.close();
    }

    /**
	* Builds list of .class files to be processed (recursively)
	*/
	private void buildFileList(File baseDir)
    {
        String files[] = baseDir.list();

        if(files == null || files.length == 0)
        {
            System.out.println("\nUnable to find .class files in " + baseDir);
            printUsage();
        }

        for (int i = 0; i < files.length; i++)
        {
            File f = new File(baseDir, files[i]);

            if (f.isDirectory())
                buildFileList(f);
            if (f.getName().endsWith(".class"))
                if (!fileList.contains(f))
                    fileList.add(f);
        }
    }

	/**
	* Builds a className from filename passed in.
	* @param f File to be processed
	* @param baseDir based directory for the file being processed.
	* It is stripped out from class name.
	* @return className
	*
	*/
    private String formatClassName(String fileName, String baseDir)
    {
        fileName = fileName.replace('\\', '/');
        if(!isJar)
            fileName = fileName.substring(fileName.indexOf(baseDir) + baseDir.length(), fileName.indexOf(".class"));
        else
            fileName = fileName.substring(0, fileName.indexOf(".class"));

        fileName = fileName.replace('/', '.');
        return (fileName.startsWith(".") ? fileName.substring(1) : fileName);
    }

    /**
    * Builds list of files from Jar File.
    * Jar File must be in your CLASSPATH
    */
    private void processJar(String jarFile)
        throws Exception
    {
        JarFile jar = new JarFile(jarFile);
        for(Enumeration e = jar.entries(); e.hasMoreElements();)
        {
            String fileName = ((ZipEntry)e.nextElement()).getName();
            if(fileName.endsWith(".class"))
                if(!fileList.contains(fileName))
                    fileList.add(fileName);
        }
    }

    private static void printUsage()
    {
        System.out.println("\nUsage: ApiBuilder [option] <baseDir | jarFile> <output file>");
        System.out.println("OR");
        System.out.println("Usage: ApiBuilder -s <api filename>");
        System.out.println("Options:");
        System.out.println("\t-a: Appends to existing file");
        System.out.println("\t-j: Processes jar file");
        System.out.println("\t-s: Sorts api file. Removes duplicate entry");
        System.exit(1);
    }

    private class CaseCompareator implements java.util.Comparator
    {

        /**
         *	Compare two objects and...
         *
         *	  return an integer < 1 if o1 is "less" than o2
         *	  return  0 if o1 and o2 are "equal"
         *	  return an integer > 1 if o1 is "greater" than o2
         *
         */
        public int compare(Object o1, Object o2)
        {
            if (o1 instanceof String && o2 instanceof String)
                return o1.toString().compareToIgnoreCase(o2.toString());
            else
                return Collator.getInstance().compare(o1, o2);
        }
    }

    /**
    * Sorts api file removes duplicate entries.
    */
    private void sortApiFile(String apiFile)
        throws Exception
    {

        File oldFile = new File(apiFile);
        BufferedReader br = new BufferedReader(new FileReader(oldFile));
        String line = new String();
        List lines = new ArrayList();

        while((line = br.readLine()) != null)
            if(!lines.contains(line))
                lines.add(line);

        br.close();
        oldFile.delete();

        Collections.sort(lines, new CaseCompareator());


        File newFile = new File(apiFile);
        PrintWriter out = new PrintWriter(new FileOutputStream(newFile));

        for(int i = 0; i < lines.size(); i++)
            out.println(lines.get(i));

        out.flush();
        out.close();

    }
}