import com.github.jh3nd3rs0n.argmatey.ArgMatey;
import com.github.jh3nd3rs0n.argmatey.ArgMatey.Annotations.Option;
import com.github.jh3nd3rs0n.argmatey.ArgMatey.Annotations.OptionArgSpec;
import com.github.jh3nd3rs0n.argmatey.ArgMatey.CLI;
import com.github.jh3nd3rs0n.argmatey.ArgMatey.OptionType;
import com.github.jh3nd3rs0n.argmatey.ArgMatey.TerminationRequestedException;

/*
 * Extends CLI to parse and handle command line options and 
 * arguments for this Java implementation of GNU's utility 
 * base64.
 */
public class Base64CLI extends CLI {

	private int columnLimit;
	private boolean decodingMode;
	private String file;
	private boolean garbageIgnored;

	public Base64CLI(String[] args) {
		super(args, false);
		// for the program help and version information
		this.setProgramDoc(new StringBuilder()
			.append("Base64 encode or decode FILE, ")
			.append("or standard input, to standard output.")
			.append(String.format("%n%n"))
			.append("With no FILE, or when FILE is -, ")
			.append("read standard input.")
			.toString());
		this.setProgramName("base64");
		this.setProgramOperandsUsage("[FILE]");
		this.setProgramVersion("base64 1.0");
	}
	
	/*
	 * Invoked after parsing and handling the command line 
	 * arguments.
	 */
	@Override
	protected void afterHandleArgs() 
		throws TerminationRequestedException {
		// post parsing can happen here
		System.out.printf("columnLimit: %s%n", this.columnLimit);
		System.out.printf("decodingMode: %s%n", this.decodingMode);
		System.out.printf("file: %s%n", this.file);
		System.out.printf("garbageIgnored: %s%n", this.garbageIgnored);
		throw new TerminationRequestedException(0);
	}
	
	/*
	 * Invoked after parsing and handling the next part of the 
	 * current command line argument or the next command line 
	 * argument.
	 */
	@Override
	protected void afterHandleNext() 
		throws TerminationRequestedException {
	}
	
	/*
	 * Invoked before parsing and handling the command line 
	 * arguments.
	 */
	@Override
	protected void beforeHandleArgs() 
		throws TerminationRequestedException {
		// initialization
		this.columnLimit = 76; // default            
		this.decodingMode = false;
		this.file = null;            
		this.garbageIgnored = false;
	}
	
	/*
	 * Invoked before parsing and handling the next part of the 
	 * current command line argument or the next command line 
	 * argument.
	 */
	@Override
	protected void beforeHandleNext() 
		throws TerminationRequestedException {
	}
			
	/*
	 * Invoked when a non-parsed command line argument is 
	 * encountered. In this implementation, the non-parsed 
	 * command line argument is the command line argument for 
	 * FILE. The non-parsed command line argument is provided 
	 * as an argument to the method parameter below. 
	 */
	@Override
	protected void handleNonparsedArg(String nonparsedArg) 
		throws TerminationRequestedException {
		if (this.file != null) {
			/*
			 * IllegalArgumentExceptions for invalid non-parsed
			 * command line arguments can be thrown.
			 */
			throw new IllegalArgumentException(String.format(
				"extra operand: `%s'", nonparsedArg));
		}
		this.file = nonparsedArg;
	}
	
	/*
	 * Invoked when a Throwable is thrown when parsing and 
	 * handling the next part of the command line argument or 
	 * the next command line argument.
	 */
	@Override
	protected void handleThrowable(Throwable t) 
		throws TerminationRequestedException {
		System.err.printf("%s: %s%n", this.getProgramName(), throwable);
		throw new TerminationRequestedException(-1);
	}
			
	/*
	 * Invoked when either of the command line options "-w" and 
	 * "--wrap" is encountered. Command line option argument 
	 * for either of the command line options "-w" and "--wrap" 
	 * is provided as an argument to the method parameter below.
	 *
	 * Methods that are annotated with @Option that allow for a 
	 * command line option argument must have only one method
	 * parameter. The method parameter's type must be a type or 
	 * a java.util.List of a type that has either a static 
	 * String conversion method or a constructor that has only 
	 * one constructor parameter of type String.
	 *
	 * Alternatively, for any method parameter type, a class 
	 * that extends StringConverter can be used to convert the 
	 * command line option argument to that type. It can be 
	 * supplied to @OptionArgSpec.stringConverter.
	 */
	@Option(
		doc = "Wrap encoded lines after COLS character (default is 76)",
		name = "w",
		optionArgSpec = @OptionArgSpec(name = "COLS"),
		type = OptionType.POSIX
	)
	@Option(
		name = "wrap",
		// optionArgSpec is provided from the above @Option.                    
		type = OptionType.GNU_LONG
	)
	private void setColumnLimit(Integer i) { 
		int intValue = i.intValue();
		if (intValue < 0) {
			/*
			 * IllegalArgumentExceptions for invalid command 
			 * line option arguments can be thrown.
			 */
			throw new IllegalArgumentException(
				"must be a non-negative integer");
		}
		this.columnLimit = intValue;
	}
			
	/*
	 * Invoked when either of the command line options "-d" and 
	 * "--decode" is encountered.
	 *
	 * Methods that are annotated with @Option that does not 
	 * allow for a command line option argument can have no 
	 * method parameters or only one method parameter of type 
	 * boolean.
	 */        
	@Option(
		doc = "Decode data",
		name = "d",
		type = OptionType.POSIX
	)
	@Option(
		name = "decode", 
		type = OptionType.GNU_LONG
	)
	private void setDecodingMode(boolean b) {
		this.decodingMode = b; // always received as true
	}
	
	/*
	 * Invoked when either of the command line options "-i" and 
	 * "--ignore-garbage" is encountered.
	 *
	 * Methods that are annotated with @Option that does not 
	 * allow for a command line option argument can have no 
	 * method parameters or only one method parameter of type 
	 * boolean.
	 */
	@Option(
		doc = "When decoding, ignore non-alphabet characters",
		name = "i",
		type = OptionType.POSIX
	)
	@Option(
		name = "ignore-garbage", 
		type = OptionType.GNU_LONG
	)
	private void setGarbageIgnored(boolean b) {
		this.garbageIgnored = b; // always received as true
	}
		
	public static void main(String[] args) {
		// how to use a CLI such as Base64CLI
		CLI cli = new Base64CLI(args);
		try {
			cli.handleArgs();
		} catch (TerminationRequestedException e) {
			System.exit(e.getExitStatusCode());
		}
	}
	
	/*
	 * Output when using the command line option "--help" :
	 *
	 * Usage: base64 [OPTION]... [FILE]
	 * Base64 encode or decode FILE, or standard input, to standard output.
	 *
	 * With no FILE, or when FILE is -, read standard input.
	 *
	 * OPTIONS:
	 *   -d, --decode
	 *       Decode data
	 *   --help
	 *       Display this help and exit
	 *   -i, --ignore-garbage
	 *       When decoding, ignore non-alphabet characters
	 *   --version
	 *       Display version information and exit
	 *   -w COLS, --wrap=COLS
	 *       Wrap encoded lines after COLS character (default is 76)
	 *
	 */
	 
	/*
	 * Output when using the command line option "--version" :
	 *
	 * base64 1.0
	 *
	 */
	 
	/*
	 * Output when using the following command line arguments:
	 *
	 * -w 100 input.txt
	 *
	 * columnLimit: 100
	 * decodingMode: false
	 * file: input.txt
	 * garbageIgnored: false
	 *
	 */
	 
	/*
	 * Output when using the following command line arguments:
	 *
	 * -di text.txt
	 *
	 * columnLimit: 76
	 * decodingMode: true
	 * file: text.txt
	 * garbageIgnored: true
	 *
	 */
	 
	/*
	 * Output when using the following command line arguments:
	 *
	 * --wrap=10 -
	 *
	 * columnLimit: 10
	 * decodingMode: false
	 * file: -
	 * garbageIgnored: false
	 *
	 */
	 
	/*
	 * Output when using the following command line arguments:
	 *
	 * --decode --ignore-garbage text.txt
	 *
	 * columnLimit: 76
	 * decodingMode: true
	 * file: text.txt
	 * garbageIgnored: true
	 *
	 */
	 
	/*
	 * Output when using the bogus command line option "--bogus":
	 *
	 * base64: com.github.jh3nd3rs0n.argmatey.ArgMatey$UnknownOptionException: unknown option `--bogus'
	 *
	 */
	 
	/*
	 * Output when using the following command line arguments:
	 *
	 * --wrap=-42 input.txt
	 *
	 * base64: com.github.jh3nd3rs0n.argmatey.ArgMatey$IllegalOptionArgException: illegal option argument `-42' for option `--wrap': java.lang.IllegalArgumentException: must be a non-negative integer
	 *
	 */
	 
	/*
	 * Output when using the following command line arguments:
	 *
	 * text.txt anothertext.txt
	 *
	 * base64: com.github.jh3nd3rs0n.argmatey.ArgMatey$IllegalArgException: illegal argument `anothertext.txt': java.lang.IllegalArgumentException: extra operand: `anothertext.txt'
	 *
	 */
}

// ...
import com.github.jh3nd3rs0n.argmatey.ArgMatey.Annotations.OptionGroupHelpTextProvider;
import com.github.jh3nd3rs0n.argmatey.ArgMatey.OptionGroupHelpTextParams;
	
public class Base64CLI extends CLI {
	
	/*
	 * Provides the help text for a command line option group 
	 * on a single line instead of multiple lines.
	 */
	private static class SingleLineOptionGroupHelpTextProvider 
		extends ArgMatey.OptionGroupHelpTextProvider {
	
		@Override
		public String getOptionGroupHelpText(OptionGroupHelpTextParams params) {
			String optionGroupHelpText = null;
			StringBuilder sb = null;
			String doc = null;
			for (ArgMatey.Option option : params.getDisplayableOptions()) {
				if (sb == null) {
					sb = new StringBuilder();
					sb.append("  ");
				} else {
					sb.append(", ");
				}
				sb.append(option.getUsage());
				if (doc == null) {
					doc = option.getDoc();
				}
			}
			if (sb != null) {
				if (doc != null) {
					final int docStart = 24;
					int length = sb.length();
					for (int i = 0; i < docStart - length; i++) {
						sb.append(' ');
					}
					sb.append(doc);
				}
				optionGroupHelpText = sb.toString();
			}
			return optionGroupHelpText;
		}
	
	}
	
	// ...
	
	@Option(
		doc = "Wrap encoded lines after COLS character (default is 76)",
		name = "w",
		optionArgSpec = @OptionArgSpec(name = "COLS"),
		type = OptionType.POSIX
	)
	@Option(
		name = "wrap",
		type = OptionType.GNU_LONG
	)
	/*
	 * You can apply the OptionGroupHelpTextProvider to a 
	 * particular command line option group...
	 */ 
	@OptionGroupHelpTextProvider(SingleLineOptionGroupHelpTextProvider.class)
	private void setColumnLimit(Integer i) {
		// ... 
	}
	
	// ...
	
	public static void main(String[] args) {
		/*
		 * ... or you can apply the OptionGroupHelpTextProvider 
		 * to all command line option groups.
		 */
		ArgMatey.OptionGroupHelpTextProvider provider = new SingleLineOptionGroupHelpTextProvider();
		ArgMatey.OptionGroupHelpTextProvider.setDefault(provider);
		// ...        
	}
			
	/*
	 * Output when using the command line option "--help" :
	 *
	 * Usage: base64 [OPTION]... [FILE]
	 * Base64 encode or decode FILE, or standard input, to standard output.
	 *
	 * With no FILE, or when FILE is -, read standard input.
	 *
	 * OPTIONS:
	 *   -d, --decode          Decode data
	 *   --help                Display this help and exit
	 *   -i, --ignore-garbage  When decoding, ignore non-alphabet characters
	 *   --version             Display version information and exit
	 *   -w COLS, --wrap=COLS  Wrap encoded lines after COLS character (default is 76)
	 *
	 */
	 
}