/***
    * 
    */
   package de.cohesion.bssh;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.PrintStream;
   import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.TimeUnit;
  
  import ch.ethz.ssh2.Connection;
  import de.cohesion.bssh.impl.CommandProcessor;
  import de.cohesion.bssh.impl.ExecuteSSHCommand;
  import de.cohesion.bssh.impl.FileMemberSource;
  import de.cohesion.bssh.impl.PBEPasswordStore;
  import de.cohesion.bssh.impl.SSHCommand;
  import de.cohesion.bssh.impl.SSHConnectionFactory;
  import de.cohesion.bssh.impl.io.PasswordHelper;
  import de.cohesion.bssh.impl.util.Cache;
  import de.cohesion.bssh.impl.util.Cache.ReplacementStrategy;
  
  /***
   * @author schulzs
   */
  public class BatchSSH {
  
  	private enum ReturnCodes {
  		OK("Success"), INVALID_OPTION("Invalid option"), UNRECOGNIZED_OPTION(
  				"Unrecognized option"), GROUP_FILE_ERROR(
  				"Error opening the group file"), PASSPHRASE_ERROR(
  				"Error reading passphrase"), PASSWORD_STORE_ERROR(
  				"Failed to open password store");
  
  		private String message;
  
  		ReturnCodes(final String message) {
  			this.message = message;
  		}
  
  		public String getMessage() {
  			return message;
  		}
  
  		public void exit() {
  			exit(null, null);
  		}
  
  		public void exit(final String msg) {
  			exit(msg, null);
  		}
  
  		public void exit(final Throwable t) {
  			exit(null, t);
  		}
  
  		public void exit(final String msg, final Throwable t) {
  			PrintStream ps = null;
  			if (this == OK) {
  				ps = System.out;
  			} else {
  				ps = System.err;
  			}
  			ps.print(getMessage() + " (code: " + ordinal());
  			if (msg != null) {
  				ps.print(", message: " + msg);
  			}
  			if (t != null) {
  				ps.print(", cause: " + t.getMessage());
  			}
  			ps.println(").");
  			System.exit(ordinal());
  		}
  
  	}
  
  	private static Cache<Member, Connection> ccache;
  
  	private static final Map<String, Option> OPTIONS = new HashMap<String, Option>();
  	static {
  		for (Option o : new Option[] { new Concurrency(), new Help(),
  				new Timeout(), new Password() }) {
  			OPTIONS.put(o.getKey(), o);
  		}
  	}
  
  	private static char[] getPassphrase() {
  		Password p = (Password) OPTIONS.get(Password.KEY);
  		if (p.isActive()) {
  			return p.getPassword();
  		} else {
  			try {
  				return PasswordHelper.getPassword(System.in, "Password: ");
  			} catch (IOException ioe) {
 				ReturnCodes.PASSPHRASE_ERROR.exit(ioe);
 			}
 		}
 		return null;
 	}
 
 	public static void main(final String[] args) {
 
 		if (args.length == 0) {
 			showHelp();
 		}
 
 		int offset = parseOptions(args);
 
 		/* Read in the members file. */
 		MemberSource source = null;
 		try {
 			source = new FileMemberSource(new File(args[offset]));
 		} catch (IOException ioe) {
 			ReturnCodes.GROUP_FILE_ERROR.exit(ioe);
 		}
 		Set<Member> members = source.getMembers();
 
 		/* Build the command string. */
 		StringBuilder b = new StringBuilder();
 		for (int i = 1; i < args.length - offset; i++) {
 			b.append(args[offset + i]);
 			b.append(" ");
 		}
 
 		/* Get the passphrase (from option or console) */
 		char[] passphrase = getPassphrase();
 
 		PasswordStore store = null;
 		try {
 			store = new PBEPasswordStore(new File(System
 					.getProperty("user.home")
 					+ "/.bssh"), passphrase);
 		} catch (IOException ioe) {
 			ReturnCodes.PASSWORD_STORE_ERROR.exit(ioe);
 		}
 
 		/* Construct the connection cache. */
 		ccache = new Cache<Member, Connection>(1024, new SSHConnectionFactory(
 				3, store), ReplacementStrategy.LRU);
 
 		SSHCommand command = new ExecuteSSHCommand(b.toString(), ccache);
 
 		CommandProcessor processor = new CommandProcessor(Collections
 				.singleton(command), members, Timeout.class.cast(
 				OPTIONS.get(Timeout.KEY)).getTimeout());
 		processor.setConcurrency(Concurrency.class.cast(
 				OPTIONS.get(Concurrency.KEY)).getLevel());
 
 		/* Collect results before printing. */
 		long start = System.nanoTime();
 		List<Result> results = new LinkedList<Result>();
 		showProgress(System.out, members.size(), 0);
 		for (Result r : processor.getResults()) {
 			results.add(r);
 			showProgress(System.out, members.size(), results.size()
 					/ (float) members.size());
 		}
 		long end = System.nanoTime();
 		System.out.println("\n");
 
 		/* Print the results as soon as they are available. */
 		ResultFormat rf = ResultFormat.SIMPLE;
 		for (Result r : results) {
 			System.out.println(rf.format(r) + "\n");
 		}
 
 		long diff = end - start;
 		System.out.println("Total execution time: "
 				+ TimeUnit.SECONDS.convert(diff, TimeUnit.NANOSECONDS) + "s "
 				+ TimeUnit.MILLISECONDS.convert(diff, TimeUnit.NANOSECONDS)
 				% 1000 + "ms");
 
 		ccache.invalidate();
 
 		System.exit(0);
 
 	}
 
 	private static int parseOptions(final String[] args) {
 
 		int offset = 0;
 		for (int i = 0; i < args.length;) {
 			String arg = args[i];
 
 			/* Determine option class. */
 			Option o = null;
 			if (arg.startsWith("--")) {
 				o = OPTIONS.get(arg.substring(2));
 			} else if (arg.startsWith("-")) {
 				for (String key : OPTIONS.keySet()) {
 					if (key.startsWith(arg.substring(1, 2))) {
 						o = OPTIONS.get(key);
 						break;
 					}
 				}
 			} else {
 				break;
 			}
 
 			if (o == null) {
 				ReturnCodes.UNRECOGNIZED_OPTION.exit(arg);
 			}
 
 			assert o != null;
 
 			/* Build raw option string (e.g. --concurrent 5). */
 			StringBuilder b = new StringBuilder();
 			int j = 0;
 			while (j <= o.getArity()) {
 				if (j > 0 && args[i + j].startsWith("-")) {
 					break;
 				}
 				b.append(args[i + j]);
 				b.append(' ');
 				j++;
 			}
 			i += j;
 
 			/* Parse option. */
 			try {
 				o.parse(b.toString());
 			} catch (ParseException pe) {
 				ReturnCodes.INVALID_OPTION.exit(o.getKey(), pe);
 			}
 
 			offset = i;
 		}
 
 		/* Process active options. */
 		for (Option o : OPTIONS.values()) {
 			if (o.isActive()) {
 				if (o instanceof Help) {
 					showHelp();
 				}
 			}
 		}
 
 		return offset;
 	}
 
 	private static void showHelp() {
 		StringBuilder b = new StringBuilder();
 		b.append("usage: bssh [-options] <group-file> <command>\n\n");
 		b.append("where options include:\n");
 		for (Option o : OPTIONS.values()) {
 			b.append(" -" + o.getKey().charAt(0) + ", --" + o.getKey() + " ");
 			b.append(o.getHelpText() + "\n");
 		}
 		System.out.println(b.toString());
 		ReturnCodes.OK.exit();
 	}
 
 	private static void showProgress(final PrintStream p, int width, float ratio) {
 		p.print("\015" + "[");
 		for (int i = 0; i < (int) Math.floor(width * ratio); i++) {
 			p.print("#");
 		}
 		for (int i = (int) Math.floor(width * ratio); i < width; i++) {
 			p.print("-");
 		}
 		p.print("]");
 	}
 
 }