package net.sourceforge.jparam.paramset;
   
   import java.io.ByteArrayInputStream;
   import java.io.ByteArrayOutputStream;
   import java.io.InputStream;
   import java.io.PrintStream;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import net.sourceforge.jparam.JParam;
  import net.sourceforge.jparam.JParamException;
  import net.sourceforge.jparam.parser.AssignmentListener;
  import net.sourceforge.jparam.parser.TreeNode;
  import net.sourceforge.jparam.util.Utils;
  
  /***
   * This class helps in parsing and handling user input from the command line,
   * you can define sets of parameters, give them types and binding information
   * and use this to read the entire input as a whole
   *  
   * @author ron_sidi
   * 
   */
  public class ParamSet implements AssignmentListener {
  	private PrintStream outStream = System.out;
  	private PrintStream feedbackStream = System.err;
  
  	private int m_max_feedback_length = 100;
  
  	// the map should be ordered...
  	private Map param_map = new HashMap();
  
  	private List param_names = new LinkedList();
  
  	private String description = "";
  
  	private boolean m_warning_is_error = true;
  
  	private boolean m_ignore_unexpected_param = false;
  
  	private boolean m_feedback_enabled = false;
  
  	/***
  	 * Create an empty ParamSet object.
  	 */
  	public ParamSet() {
  	}
  
  	/***
  	 * Create a ParamSet object with the given general description, and no
  	 * parameters.
  	 */
  	public ParamSet(String description) {
  		setDescription(description);
  	}
  
  	public void clearValues() {
  		for (Iterator iter = param_map.values().iterator(); iter.hasNext();) {
  			Param param = (Param) iter.next();
  			param.clearValue();
  		}
  	}
  
  	/***
  	 * Sets the ParamSet's general description
  	 */
  	public void setDescription(String description) {
  		this.description = description;
  	}
  
  	/***
  	 * Returns the ParamSet's general description
  	 */
  	public String getDescription() {
  		return description;
  	}
  
  	/***
  	 * Adds the given parameter to the set. Throws an exception if a parameter
  	 * by the same name already exists in the set.
  	 */
  	public void addParam(Param param) throws JParamException {
  		String name = param.getName();
  		if (param_map.get(name) != null) {
  			throw new JParamException("Duplicate definition of parameter \'"
  					+ name + "\'.");
  		}
  		param_map.put(name, param);
  		param_names.add(name);
  	}
  
  	/***
  	 * Returns the parameter with the given name, or null if no such parameter
  	 * exists.
  	 */
 	public Param getParam(String name) throws MatchException {
 		Object param = param_map.get(name);
 		if (param == null) {
 			// check prefixes
 			List possibleNames = new LinkedList();
 			for (Iterator iter = param_names.iterator(); iter.hasNext();) {
 				String paramName = (String) iter.next();
 				if (paramName.startsWith(name)) {
 					possibleNames.add(paramName);
 					param = param_map.get(paramName);
 				}
 			}
 
 			if (param == null) {
 				throw new MatchException(false, "No match for parameter '"
 						+ name + "'.");
 			}
 			if (possibleNames.size() > 1) {
 				throw new MatchException(true,
 						"Reference to parameter aval is ambiguous. Candidates are: "
 								+ arraytoString(possibleNames) + ".");
 			}
 		}
 		return (Param) param;
 	}
 
 	private String arraytoString(List objects) {
 		StringBuffer buf = new StringBuffer();
 		for (Iterator iter = objects.iterator(); iter.hasNext();) {
 			buf.append(iter.next());
 			if (iter.hasNext()) {
 				buf.append(", ");
 			}
 		}
 		return buf.toString();
 	}
 
 	/***
 	 * Returns all parameters
 	 */
 	public Collection getParams() {
 		List params = new LinkedList();
 		for (Iterator iter = param_names.iterator(); iter.hasNext();) {
 			String paramName = (String) iter.next();
 			params.add(param_map.get(paramName));
 		}
 		return params;
 	}
 
 	/***
 	 * Returns a human readable description of the ParamSet, including all
 	 * parameters
 	 */
 	public String info() {
 		StringBuffer str = new StringBuffer(description);
 		str.append('\n');
 		if (param_map.isEmpty())
 			return str.toString(); // don't print table when no parameters are
 		// defined
 
 		str
 				.append("Usage: progname <param1>=<val1> <param2>=<val2> -<flag1> -no_<flag2>...\n");
 		str.append("Use exact parameter names.\n");
 		str
 				.append("Multiple assignment to the same parameter is not allowed.\n");
 		str.append("\n");
 
 		String table = formatTable(getParamsTable());
 		str.append(table);
 
 		return str.toString();
 	}
 
 	private String[][] getParamsTable() {
 
 		List rows = new LinkedList();
 		List row;
 
 		// headers
 		row = new LinkedList();
 		row.add("Name");
 		row.add("Type");
 		row.add("I/O");
 		row.add("Default Value");
 		row.add("Description");
 		rows.add(row);
 
 		// underline row
 		row = new LinkedList();
 		row.add("====");
 		row.add("====");
 		row.add("===");
 		row.add("=============");
 		row.add("===========");
 		rows.add(row);
 
 		Iterator i = getParams().iterator();
 		while (i.hasNext()) {
 			Param param = (Param) i.next();
 
 			row = new LinkedList();
 			row.add(param.getName());
 			row.add(param.getTypeBound().getName());
 
 			if (param.isInput() && !param.isOutput())
 				row.add(" I ");
 			if (!param.isInput() && param.isOutput())
 				row.add(" O ");
 			if (param.isInput() && param.isOutput())
 				row.add("I/O");
 
 			if (param.isInput()) {
 				Object defaultValue = param.getDefaultValue();
 				if (defaultValue != null) {
 					String defaultString;
 					try {
 						defaultString = JParam.toString(defaultValue);
 					} catch (JParamException ex) {
 						defaultString = "Output Error";
 					}
 					row.add(defaultString);
 				} else {
 					row.add("[ required ]");
 				}
 			} else {
 				row.add("");
 			}
 
 			row.add(param.getDescription());
 
 			rows.add(row);
 		}
 
 		// convert to String[][]
 		int nRows = rows.size();
 		int nCols = ((List) rows.get(0)).size();
 		String[][] table = new String[nRows][nCols];
 		int iRow = 0;
 		for (Iterator curRow = rows.iterator(); curRow.hasNext();) {
 			List curCol = (List) curRow.next();
 			Utils.assert(row.size() == nCols, "row.size() == nCols");
 			int iCol = 0;
 			for (Iterator curCell = curCol.iterator(); curCell.hasNext();) {
 				table[iRow][iCol] = (String) curCell.next();
 				iCol++;
 			}
 			iRow++;
 		}
 		return table;
 	}
 
 	private static String formatTable(String[][] table) {
 		int iCol, nCols;
 		int iRow, nRows;
 
 		nRows = table.length;
 		Utils.assert(nRows != 0, "Table is empty");
 		nCols = table[0].length;
 
 		for (iRow = 0; iRow < nRows; ++iRow) {
 			Utils.assert(table[iRow].length == nCols,
 					"Not all rows have same number of columns");
 		}
 
 		// set column widths to maximum width of data in that column plus margin
 		// of 1.
 		int[] columnWidth = new int[nCols];
 		for (iCol = 0; iCol < nCols; ++iCol) {
 			int max = 0;
 			for (iRow = 0; iRow < nRows; ++iRow) {
 				int size = table[iRow][iCol].length();
 				if (size > max)
 					max = size;
 			}
 			columnWidth[iCol] = max + 1;
 		}
 
 		// write table data
 		StringBuffer str = new StringBuffer();
 		for (iRow = 0; iRow < nRows; ++iRow) {
 			for (iCol = 0; iCol < nCols; ++iCol) {
 				String cellData = table[iRow][iCol];
 				str.append(table[iRow][iCol]);
 
 				// pad with spaces
 				int i;
 				for (i = cellData.length(); i < columnWidth[iCol]; ++i) {
 					str.append(' ');
 				}
 			}
 			str.append('\n');
 		}
 
 		return str.toString();
 	}
 
 	/***
 	 * Reads values for all input parameter from given InputStream. Checks that
 	 * all parameters have values.
 	 */
 	public void input(InputStream in) throws JParamException {
 		input(in, true);
 	}
 
 	/***
 	 * Reads values for all input parameter from given InputStream. If check is
 	 * true, checks that all parameters have values.
 	 */
 	public void input(InputStream in, boolean check) throws JParamException {
 		JParam.readValueSet(in, this);
 
 		if (m_feedback_enabled) {
 			write_feedback();
 		}
 		// check all required parameters have values (if requested)
 		if (check)
 			this.check();
 	}
 
 	/***
 	 * Reads values for all input parameter from 'args'. Checks that all
 	 * parameters have values.
 	 */
 	public void input(String[] args) throws JParamException {
 		input(args, true);
 	}
 
 	/***
 	 * Reads values for all input parameter from 'args'. If check is true,
 	 * checks that all parameters have values.
 	 */
 	public void input(String[] args, boolean check) throws JParamException {
 		if (args.length == 1 || args.length == 2) { // might be help request
 			if (args[0].equals("!") || args[0].equals("/?")
 					|| args[0].equals("-?") || args[0].equals("--help")
 					|| args[0].equals("/h") || args[0].equals("/H")
 					|| args[0].equals("/help")) {
 				if (args.length == 1) { // program help
 					outStream.println(info());
 				} else { // help for a type
 					String topic = args[1];
 					outStream.println(JParam.help(topic));
 				}
 				System.exit(0);
 			}
 		}
 
 		StringBuffer strbuf = new StringBuffer();
 		for (int i = 0; i < args.length; ++i) {
 			strbuf.append('\1');
 			strbuf.append(args[i]);
 		}
 
 		InputStream in = new ByteArrayInputStream(strbuf.toString().getBytes());
 		input(in, check);
 	}
 
 	/***
 	 * Checks that all parameters have values. Throws an exception if check
 	 * fails.
 	 */
 	public void check() throws JParamException {
 
 		Iterator i = getParams().iterator();
 		while (i.hasNext()) {
 			Param param = (Param) i.next();
 			if (param.isInput() && (param.getDefaultValue() == null)
 					&& !param.wasAssignedTo()) {
 				throw new JParamException(
 						"No value given for required parameter "
 								+ param.getName() + ".");
 			}
 		}
 	}
 
 	/***
 	 * Writes all output parameters to outStream
 	 */
 	public void output() throws JParamException {
 		output(outStream);
 	}
 
 	/***
 	 * Writes all output parameters to given PrintStream.
 	 */
 	public void output(PrintStream out) throws JParamException {
 		Iterator i = getParams().iterator();
 		while (i.hasNext()) {
 			Param param = (Param) i.next();
 			if (param.isOutput()) {
 				Object val = param.getValue();
 				out.print(param.getName());
 				out.print(" = ");
 				JParam.writeObject(val, out);
 				out.print('\n');
 			}
 		}
 		out.println(";"); // mark end of ParamSet
 	}
 
 	public void write_feedback() {
 		feedbackStream
 				.println("--------------------------------------------------");
 		feedbackStream.println("Values of input parameters:");
 
 		Iterator i = getParams().iterator();
 		while (i.hasNext()) {
 			Param param = (Param) i.next();
 			if (param.isInput()) {
 				Object val = param.getValue();
 				feedbackStream.print(param.getName());
 				if (param.hasGivenValue()) {
 					if (!param.wasAssignedTo()) {
 						feedbackStream.print(" [default]");
 					}
 					feedbackStream.print(" = ");
 					ByteArrayOutputStream argBytesStream = new ByteArrayOutputStream();
 					PrintStream argsStream = new PrintStream(argBytesStream);
 
 					try {
 						JParam.writeObject(val, argsStream);
 					} catch (JParamException e) {
 						e.printStackTrace();
 					}
 					String argValue = argBytesStream.toString();
 
 					if (m_max_feedback_length > 0) {
 						if (argValue.length() > m_max_feedback_length) {
 							argValue = argValue.substring(0,
 									m_max_feedback_length)
 									+ " ...";
 						}
 					}
 
 					feedbackStream.println(argValue);
 				} else {
 					feedbackStream.println(" [unassigned]");
 				}
 			}
 		}
 		feedbackStream
 				.println("--------------------------------------------------");
 		feedbackStream.println();
 	}
 
 	/***
 	 * Called by parser for each assignemnt to value set.
 	 */
 	public void notifyAssignment(String name, TreeNode value)
 			throws JParamException {
 		Param p;
 		try {
 			p = getParam(name);
 		} catch (MatchException e) {
 			if (!e.isAmbigous() && m_ignore_unexpected_param) {
 				return;
 			}
 
 			if (m_warning_is_error) {
 				throw e;
 			}
 
 			outStream.println("WARNING: Assignment to parameter " + name
 					+ " was ignored. " + e.getMessage());
 			return;
 		}
 
 		if (p == null)
 			throw new JParamException("No match for parameter \'" + name
 					+ "\'.");
 
 		if (!p.isInput())
 			throw new JParamException("Parameter " + name
 					+ " isn't an input parameter.");
 
 		if (p.wasAssignedTo())
 			throw new JParamException("Multiple assignment to parameter "
 					+ name + ".");
 
 		Object constructedValue = value.getConstructedValue(p.getTypeBound());
 		p.setValue(constructedValue);
 	}
 
 	public void setOutput(PrintStream outStream) {
 		this.outStream = outStream;
 	}
 
 	public void warning_is_error(boolean b) {
 		m_warning_is_error = b;
 	}
 
 	public void ignore_unexpected(boolean b) {
 		m_ignore_unexpected_param = b;
 	}
 
 	public void feedback_enabled(boolean b) {
 		m_feedback_enabled = b;
 	}
 
 	public void max_feedback_length(int i) {
 		m_max_feedback_length = i;
 	}
 
 	public void set_feedback_stream(PrintStream ps) {
 		feedbackStream = ps;
 	}
 
 }