/**
* Application to figure out install order of pkgs.
*/
public class Depend {
	/**
	* Main Program.
	*/
	public static void main(String[] args) {
		// Read system vars that are needed.
		//String varDir = System.getenv("TT_VAR_DIR");
		String varDir = System.getProperty("TT_VAR_DIR");
		//String etcDir = System.getenv("TT_ETC_DIR");
		String etcDir = System.getProperty("TT_ETC_DIR");
		if ( (varDir == null) || (etcDir == null) ) {
			System.out.println("Unable to read atleast one of the env vars TT_VAR_DIR/TT_ETC_DIR");
			System.exit(1);
		}
		//System.out.println("TT_ETC_DIR = " + etcDir);
		//System.out.println("TT_VAR_DIR = " + varDir);
		//System.out.println("");
		// Directory where all pkg dependencies are kept
		java.io.File file = new java.io.File(varDir + "/deps");
		if (!file.isDirectory()) {
			System.out.println("Invalid directory");
			System.exit(1);
		}
		// get contents of the directory.
		java.io.File[] files = file.listFiles();
		// num of pkgs
		int numOfPkgs = files.length;
		// all packages
		Pkgs pkgs = new Pkgs();
		// Create each pkg object and add it to the list.
		for (int i=0; i<numOfPkgs; ++i) {
			try {
				pkgs.addPkg(new Pkg(files[i]));
			}
			// exit for all IO exceptions
			catch (java.io.IOException ioe) {
				System.out.println("IOException:\n" + ioe);
				System.exit(1);
			}
		}
		// dereferencing is a good practice:)
		files = null;
		// Pass Number
		int passNum = 0;
		// First remove the pkgs that are defined in the core-pkgs file
		file = new java.io.File(etcDir + "/corePkgs");
		if (file.isFile()) {
			try {
				java.io.FileInputStream fis = new java.io.FileInputStream(file);
				java.io.BufferedReader br = new java.io.BufferedReader(new java.io.InputStreamReader(fis));
				System.out.println("\n--> Pass " + passNum);
				// read each dependency
				String x = br.readLine();
				// x is null when the file is empty
				while (x != null) {
					Pkg p = pkgs.getPkg(x);
					pkgs.removePkg(p);
					System.out.println(p.getFullString());
					x = br.readLine();
				}
			}
			// ignore ioe exceptions
			catch (java.io.IOException ioe) {
			}
		}
		// Remove each pkg whose dependencies are satisfied.
		++passNum;
		Pkgs resolvedPkgs = pkgs.getResolvedPkgs();
		while (resolvedPkgs.getSize() != 0) {
			System.out.println("\n--> Pass " + passNum + " (" + resolvedPkgs.getSize() + " Pkgs)");
			java.util.Iterator elements = resolvedPkgs.iterator();
			while (elements.hasNext()) {
				Pkg p = (Pkg) elements.next();
				pkgs.removePkg(p);
				System.out.println(p.getFullString());
			}
			++passNum;
			resolvedPkgs = pkgs.getResolvedPkgs();
		}
		// The list left is the one with circular dependencies that will need to be resolved manually.
		System.out.println("\n*** Unresolved (" + pkgs.getSize() + " Pkgs) ***");
		java.util.Iterator elements = pkgs.iterator();
		while (elements.hasNext()) {
			Pkg p = (Pkg) elements.next();
			System.out.println(p.toString());
		}
	}
}

/**
* Collection of pkgs.
*/
class Pkgs {
	// collection of pkgs
	private java.util.TreeSet pkgs = new java.util.TreeSet();
	/**
	* Constructor.
	*/
	public Pkgs() {
	}
	/**
	* Add a pkg.
	*/
	public boolean addPkg(Pkg pkg) {
		return pkgs.add(pkg);
	}
	/**
	* Return the pkg with the given name.
	*/
	public Pkg getPkg(String pkgName) {
		java.util.Iterator elements = pkgs.iterator();
		while (elements.hasNext()) {
			Pkg p = (Pkg) elements.next();
			if (p.getName().equals(pkgName))
				return p;
		}
		return null;
	}
	/**
	* Remove the pkg from the list.
	*/
	public boolean removePkg(Pkg pkg) {
		java.util.Iterator elements = pkgs.iterator();
		while (elements.hasNext()) {
			Pkg p = (Pkg) elements.next();
			p.remove(pkg.getName());
		}
		return pkgs.remove(pkg);
	}
	/**
	* Return pkgs for which all dependencies are resolved.
	*/
	public Pkgs getResolvedPkgs() {
		Pkgs resolvedPkgs = new Pkgs();
		java.util.Iterator elements = pkgs.iterator();
		while (elements.hasNext()) {
			Pkg p = (Pkg) elements.next();
			if (p.dependSize() == 0)
				resolvedPkgs.addPkg(p);
		}
		return resolvedPkgs;
	}
	/**
	* Size of pkgs.
	*/
	public int getSize() {
		return pkgs.size();
	}
	/**
	* Iterator.
	*/
	public java.util.Iterator iterator() {
		return pkgs.iterator();
	}
}

/**
* Pkg class that reads dependency information for each pkg.
*/
class Pkg implements Comparable {
	// name of the pkg.
	private String name;
	// dependency list.
	private java.util.TreeSet depends = new java.util.TreeSet();
	// full display string before dependencies are removed.
	private String fullString;
	/**
	* Constructor.
	*/
	public Pkg(java.io.File f) throws java.io.IOException {
		name = f.getName();
		// create reader
		java.io.FileInputStream fis = new java.io.FileInputStream(f);
		java.io.BufferedReader br = new java.io.BufferedReader(new java.io.InputStreamReader(fis));
		try {
			// read each dependency
			String x = br.readLine();
			// x is null when the dependency list is empty.
			while (x != null) {
				//System.out.println("  " + x);
				depends.add(x);
				x = br.readLine();
			}
		}
		// done when we have an EOF Exception.
		catch (java.io.EOFException eofe) {
		}
		//System.out.println("");
		// store the complete list before we mutilate the dependency list.
		fullString = toString();
	}
	/**
	* Emtpy constructor.
	*/
	public Pkg(String pkgName) {
		name = pkgName;
	}
	/**
	* Get the name of the pkg.
	*/
	public String getName() {
		return name;
	}
	/**
	* Get the complete list of dependencies.
	*/
	public String getFullString() {
		return fullString;
	}
	/**
	* Get the number of pkgs left in the dependency list.
	*/
	public int dependSize() {
		return depends.size();
	}
	/**
	* Remove a pkg from the dependency list.
	*/
	public void remove(String p) {
		depends.remove(p);
	}
	/**
	* compare with given object.
	*/
	public int compareTo(Object o) {
		Pkg p = (Pkg) o;
		return name.compareTo(p.getName());
	}
	/**
	* Whether the given pkg is equal
	*/
	public boolean equals(Object o) {
		Pkg p = (Pkg) o;
		return name.equals(p.getName());
	}
	/**
	* Return the current dependency list.
	*/
	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append("* ");
		sb.append(getName());
		sb.append(":\n  ");
		java.util.Iterator elements = depends.iterator();
		while (elements.hasNext()) {
			sb.append(" " + elements.next());
		}
		return sb.toString();
	}
}