/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.util.regex.*;

/**
 * This class provides the base implementation of an Expression. All
 * types of Expression must inherit from this class.
 *
 * An objective is always specified in terms of an expression. The
 * only recognized expressions are those known by this class. An
 * expression is create using the valueOf() factory method, which is
 * why Expressions must be known to this class.
 */
abstract class Expression
{
	/**
	 * Expression importance
	 */
	private long imp = -1;

	/**
	 * Expression name
	 */
	private String name;

	/**
	 * Sole constructor.  (For invocation by subclass constructors)
	 */
	protected Expression(long imp, String name)
	{
		this.imp = imp;
		this.name = name;
	}

	/**
	 * Return the name of the expression.
	 */
	String getName()
	{
		return (this.name);
	}

	/**
	 * Return the importance of the expression.
	 */
	long getImportance()
	{
		return (imp);
	}

	/**
	 * Returns the supplied string as an expression.
	 *
	 * This utility function attempts to identify the supplied
	 * string as an expression. It tries in turn each of the known
	 * sub-classes until finally, if none can be recognized, an
	 * exception is thrown. This function is not immune to
	 * mistakenly mis-classifying an expression. It is the
	 * responsibility of the concrete Exrpession classes to ensure
	 * that syntactic integrity is maintained with respect to
	 * potential cases of mistaken identity.
	 *
	 * @param raw The candidate expression
	 * @throws IllegalArgumentException If no valid expression can
	 * be found
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		Expression exp = null;
		/*
		 * TODO It would be better if subclasses registered,
		 * but this hard coded list will do until such a time
		 */
		if ((exp = KVOpExpression.valueOf(raw)) == null)
			if ((exp = KVExpression.valueOf(raw)) == null)
				exp = KExpression.valueOf(raw);
		if (exp == null)
			throw new IllegalArgumentException(
			    "unrecognized expression: " + raw);
		return (exp);
	}

	/**
	 * Ensure that the supplied importance is a valid value.
	 *
	 * @param imps String representation of the importance.
	 *
	 * @throws IllegalArgumentException if the importance is not
	 * valid.
	 */
	protected static long validateImportance(String imps)
	    throws IllegalArgumentException
	{
		long imp;

		try {
			imp = Long.parseLong(imps);
		} catch (NumberFormatException nfe) {
			throw new IllegalArgumentException("importance value " +
			    imps + " is not legal");
		}
		
		if (imp < 0)
			throw new IllegalArgumentException("importance value " +
			    imps + " is not legal (must be positive)");
		return (imp);
	}

	/**
	 * Ensure that the supplied keyword is a member of the
	 * supplied keys.
	 *
	 * @param keys Array of valid key strings.
	 * @param key Key sought.
	 *
	 * @throws IllegalArgumentException if the sought key is not
	 * a member of the keys array.
	 */
	protected static void validateKeyword(String keys[], String key)
	    throws IllegalArgumentException
	{
		for (int i = 0; i < keys.length; i++) {
			if (keys[i].compareTo(key) == 0)
				return;
		}
		throw new IllegalArgumentException("keyword " + key +
		    " is not recognized");
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. The definition of contradiction is left down to
	 * each implementing sub-class.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public abstract boolean contradicts(Expression o);
}

/**
 * This class implements the functionality for a key-value-operator
 * expression.
 *
 * The general form of this expression is defined in the pattern
 * member. A simplified rendition of which is:
 *
 * [[imp]:] <key> <op> <value>
 *
 * key is a string which identifies the expression
 * op is the operator for the expression ( < | > | ~)
 * value is the value of the expression
 *
 * For example:
 *
 * 10: utilization < 80
 */
final class KVOpExpression extends Expression
{
	/**
	 * The operator for this expression.
	 */
	private char op;

	/**
	 * The value of this expression.
	 */
	private int val;

	/**
	 * The pattern used to recognize this type of expression.
	 */
	private static final Pattern pattern = Pattern.compile(
	    "\\s*((\\d+)\\s*:)?\\s*(\\w+)\\s*([~<>])\\s*(\\d+)\\s*");

	/**
	 * The array of valid keys for this type of expression.
	 */
	private static final String keys[] = { "utilization" };

	/**
	 * A greater than operator.
	 */
	static final char GT = '>';

	/**
	 * A less than operator.
	 */
	static final char LT = '<';

	/**
	 * A near to operator.
	 */
	static final char NT = '~';

	/**
	 * Private constructor used in the valueOf() factory method.
	 *
	 * @param imp The importance of this expression.
	 * @param name The name of this expression.
	 * @param op The operator of this expression.
	 * @param val The value of this expression.
	 */
	private KVOpExpression(long imp, String name, String op, int val)
	{
		super(imp, name);
		this.op = op.charAt(0);
		this.val = val;
	}

	/**
	 * Create and return an expression from the input string.
	 *
	 * Determine if the input string matches the syntax defined by
	 * this expression. If the expression cannot be matched, an
	 * exception will be thrown.
	 *
	 * @param raw Candidate expression string.
	 *
	 * @throws IllegalArgumentExpression if the string is not a
	 * valid expression of this type.
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		KVOpExpression exp = null;
		Matcher m = pattern.matcher(raw);

		if (m.matches()) {
			long imp = 1;
			int val = Integer.parseInt(m.group(5));

			if (m.group(2) != null)
				imp = validateImportance(m.group(2));

			validateKeyword(keys, m.group(3));
			if (val > 100 || val < 0)
				throw new IllegalArgumentException(
				    "expression value " + val +
				    " is outside the legal range (0-100)");
			exp = new KVOpExpression(imp, m.group(3),
			    m.group(4), val);
		}
		return (exp);
	}

	/**
	 * Return the operator for this expression.
	 */
	char getOp()
	{
		return (op);
	}

	/**
	 * Return the value of this expression.
	 */
	int getValue()
	{
		return (val);
	}

	/**
	 * Return a string representation of this expresssion.
	 */
	public String toString()
	{
		return ("(" + getImportance() + ", " + getName() + ", '" + op +
		    "', " + val + ")");
	}

	/**
	 * Indicates whether some other KVOpExpression is "equal to
	 * this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof KVOpExpression))
			return (false);
		KVOpExpression other = (KVOpExpression) o;
		if (getName().compareTo(other.getName()) != 0 ||
		    op != other.getOp() || val != other.getValue())
			return (false);		
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (getName().hashCode() + (int) op + val);
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. If the supplied expression is not of the same
	 * type, then it cannot contradict it. If the names are
	 * different then there can be no contradiction.
	 *
	 * Contradiction occurs if the operator is the same or if they
	 * aren't the same and the operator is < or > and the values
	 * aren't simultanteously achievable.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public boolean contradicts(Expression o)
	{
		if (!(o instanceof KVOpExpression))
			return (false);
		KVOpExpression other = (KVOpExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);
		if (getOp() != other.getOp()) {
			if (getOp() != NT && other.getOp() != NT) {
				if (getOp() == GT) {
					if (getValue() < other.getValue())
						return (false);
				} else {
					if (getValue() > other.getValue())
						return (false);
				}
			} else
				return (false);
		}
		return (true);
	}	
}

/**
 * This class implements the functionality for a key-value expression.
 *
 * The general form of this expression is defined in the pattern
 * member. A simplified rendition of which is:
 *
 * [[imp]:] <key> <value>
 *
 * key is a string which identifies the expression
 * value is the value of the expression
 *
 * For example:
 *
 * 10: locality tight
 */
final class KVExpression extends Expression
{
	/**
	 * The value of this expression.
	 */
	private String val;

	/**
	 * The pattern used to recognize this type of expression.
	 */
	private static final Pattern pattern = Pattern.compile(
	    "\\s*((\\d+)\\s*:)?\\s*(\\w+)\\s+(tight|loose|none)\\s*");

	/**
	 * The array of valid keys for this type of expression.
	 */
	private static final String keys[] = { "locality" };

	/**
	 * Private constructor used in the valueOf() factory method.
	 *
	 * @param imp The importance of this expression.
	 * @param name The name of this expression.
	 * @param val The value of this expression.
	 */
	private KVExpression(long imp, String name, String val)
	{
		super(imp, name);
		this.val = val;
	}

	/**
	 * Create and return an expression from the input string.
	 *
	 * Determine if the input string matches the syntax defined by
	 * this expression. If the expression cannot be matched, an
	 * exception will be thrown.
	 *
	 * @param raw Candidate expression string.
	 *
	 * @throws IllegalArgumentExpression if the string is not a
	 * valid expression of this type.
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		KVExpression exp = null;
		Matcher m = pattern.matcher(raw);

		if (m.matches()) {
			long imp = 1;

			if (m.group(2) != null)
				imp = validateImportance(m.group(2));

			validateKeyword(keys, m.group(3));
			exp = new KVExpression(imp, m.group(3), m.group(4));
		}
		return (exp);
	}

	/**
	 * Return the value of this expression.
	 */
	String getValue()
	{
		return (val);
	}

	/**
	 * Return a string representation of this expresssion.
	 */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append("(");
		buf.append(getImportance());
		buf.append(", ");
		buf.append(getName());
		buf.append(", ");
		buf.append(val);
		buf.append(")");

		return (buf.toString());
	}

	/**
	 * Indicates whether some other KVExpression is "equal to
	 * this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof KVExpression))
			return (false);
		KVExpression other = (KVExpression) o;
		if (getName().compareTo(other.getName()) != 0 ||
		    val.compareTo(other.getValue()) != 0)
			return (false);		
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (getName().hashCode() + val.hashCode());
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. If the supplied expression is not of the same
	 * type, then it cannot contradict it. If the names are
	 * different then there can be no contradiction.
	 *
	 * Contradiction occurs if the value is different.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public boolean contradicts(Expression o)
	{
		if (!(o instanceof KVExpression))
			return (false);
		KVExpression other = (KVExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);
		if (val.compareTo(other.getValue()) == 0)
			return (false);
		return (true);
	}	
}

/**
 * This class implements the functionality for a key expression.
 *
 * The general form of this expression is defined in the pattern
 * member. A simplified rendition of which is:
 *
 * [[imp]:] <key>
 *
 * key is a string which identifies the expression
 *
 * For example:
 *
 * 10: wt-load
 */
final class KExpression extends Expression
{
	/**
	 * The pattern used to recognize this type of expression.
	 */
	private static final Pattern pattern = Pattern.compile(
	    "\\s*((\\d+)\\s*:)?\\s*([\\w-]+)\\s*");

	/**
	 * The array of valid keys for this type of expression.
	 */
	private static final String keys[] = { "wt-load" };

	/**
	 * Private constructor used in the valueOf() factory method.
	 *
	 * @param imp The importance of this expression.
	 * @param name The name of this expression.
	 */
	private KExpression(long imp, String name)
	{
		super(imp, name);
	}

	/**
	 * Create and return an expression from the input string.
	 *
	 * Determine if the input string matches the syntax defined by
	 * this expression. If the expression cannot be matched, an
	 * exception will be thrown.
	 *
	 * @param raw Candidate expression string.
	 *
	 * @throws IllegalArgumentExpression if the string is not a
	 * valid expression of this type.
	 */
	static Expression valueOf(String raw) throws IllegalArgumentException
	{
		KExpression exp = null;
		Matcher m = pattern.matcher(raw);

		if (m.matches()) {
			long imp = 1;

			if (m.group(2) != null)
				imp = validateImportance(m.group(2));

			validateKeyword(keys, m.group(3));
			exp = new KExpression(imp, m.group(3));
		}
		return (exp);
	}

	/**
	 * Return a string representation of this expresssion.
	 */
	public String toString()
	{
		return ("(" + getImportance() + ", " + getName() + ")");
	}

	/**
	 * Indicates whether some other KExpression is "equal to
	 * this one.
	 * @param o the reference object with which to compare.
	 * @return <code>true</code> if this object is the same as the
	 * o argument; <code>false</code> otherwise.
	 * @see	#hashCode()
	 */
	public boolean equals(Object o)
	{
		if (o == this)
			return (true);
		if (!(o instanceof KExpression))
			return (false);
		KExpression other = (KExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);		
		return (true);
	}

	/**
	 * Returns a hash code value for the object. This method is
	 * supported for the benefit of hashtables such as those provided by
	 * <code>java.util.Hashtable</code>.
	 *
	 * @return a hash code value for this object.
	 * @see	#equals(java.lang.Object)
	 * @see	java.util.Hashtable
	 */
	public int hashCode()
	{
		return (getName().hashCode());
	}

	/**
	 * Return true if the supplied expression "contradicts" this
	 * expression. If the supplied expression is not of the same
	 * type, then it cannot contradict it. If the names are
	 * different then there can be no contradiction.
	 *
	 * @param o Expression to examine for contradiction.
	 */
	public boolean contradicts(Expression o)
	{
		if (!(o instanceof KExpression))
			return (false);
		KExpression other = (KExpression) o;
		if (getName().compareTo(other.getName()) != 0)
			return (false);
		return (true);
	}	
}