/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2000 Michael Powers

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see http://www.gnu.org
*/

package net.wotonomy.control;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import net.wotonomy.foundation.NSArray;
import net.wotonomy.foundation.NSMutableArray;
import net.wotonomy.foundation.NSMutableDictionary;
import net.wotonomy.foundation.NSSelector;
import net.wotonomy.foundation.NSSet;
import net.wotonomy.foundation.internal.ValueConverter;
import net.wotonomy.foundation.internal.WotonomyException;

/**
 * EOQualifiers are used to perform property-based qualifications on objects:
 * for a set of criteria, a qualifier either qualifies or disqualifies an given
 * object. EOKeyValueQualifiers can be joined by EOAndQualifier and
 * EOOrQualifier, and so can form a tree of qualifications. <br>
 * <br>
 *
 * Certain qualifiers can accept a variable in place of a value; variable names
 * are marked by a "$", as in "$name". Variables are resolved with the
 * qualifierWithBindings() method.
 *
 * @author michael@mpowers.net
 * @author yjcheung@intersectsoft.com
 * @author $Author: cgruber $
 * @version $Revision: 894 $
 */
public abstract class EOQualifier {
	public static final NSSelector QualifierOperatorCaseInsensitiveLike = new OperatorCaseInsensitiveLike();
	public static final NSSelector QualifierOperatorContains = new OperatorContains();
	public static final NSSelector QualifierOperatorEqual = new OperatorEqual();
	public static final NSSelector QualifierOperatorGreaterThan = new OperatorGreaterThan();
	public static final NSSelector QualifierOperatorGreaterThanOrEqualTo = new OperatorGreaterThanOrEqualTo();
	public static final NSSelector QualifierOperatorLessThan = new OperatorLessThan();
	public static final NSSelector QualifierOperatorLessThanOrEqualTo = new OperatorLessThanOrEqualTo();
	public static final NSSelector QualifierOperatorLike = new OperatorLike();
	public static final NSSelector QualifierOperatorNotEqual = new OperatorNotEqual();

	/**
	 * Default constructor.
	 */
	public EOQualifier() {
	}

	/**
	 * Adds all qualifier keys in this qualifier to the specified Set, which is
	 * expected to be mutable. The tree of qualifiers is traversed and the
	 * left-hand-side of each expression is added to the set.
	 */
	public void addQualifierKeysToSet(Set aSet) {
		throw new RuntimeException("Not implemented yet.");
	}

	/**
	 * Returns a Set of all property names used for comparisons by this qualifier.
	 * The tree of qualifiers is traversed and the left-hand-side of each expression
	 * is added to the set.
	 */
	public NSSet allQualifierKeys() {
		throw new RuntimeException("Not implemented yet.");
	}

	/**
	 * Returns a List containing the variables used at compare-time by this
	 * qualifier. Each variable will appear only once in the list.
	 */
	public NSArray bindingKeys() {
		throw new RuntimeException("Not implemented yet.");
	}

	/**
	 * Returns whether the specified object meets the criteria defined by this
	 * qualifier.
	 */
	public boolean evaluateWithObject(Object anObject) {
		return true;
	}

	/**
	 * Returns the key (which can be a key path) that is tested against the
	 * specified binding variable. The tree is traversed looking for the first
	 * instance of the specified variable, and the corresponding left-hand-side of
	 * the expression is returned.
	 */
	public String keyPathForBindingKey(String aVariable) {
		throw new RuntimeException("Not implemented yet.");
	}

	/**
	 * Returns a qualifier that is like this qualifier, except all variables will be
	 * replaced with values from the specified Map whose keys match the variable
	 * names. If requireAll is true, an exception will be thrown if there is no key
	 * that matches on of the variables in the tree; otherwise, the qualifier
	 * containing the unmatched variable is removed.
	 */
	public EOQualifier qualifierWithBindings(Map aMap, boolean requireAll) {
		throw new WotonomyException("Not implemented yet.");
	}

	/**
	 * Tests whether all the keys in this qualifier can be applied to an object of
	 * the specified class.
	 * 
	 * @return A Throwable if the validation fails, otherwise returns null if the
	 *         class can be used with this qualifier.
	 */
	public Throwable validateKeysWithRootClassDescription(Class aClass) {
		throw new WotonomyException("Not implemented yet.");
	}

	// statics

	/**
	 * Convenience to retain only those objects from the specified List that meet
	 * the specified qualifier's requirements.
	 */
	public static void filterArrayWithQualifier(List anObjectList, EOQualifier aQualifier) {
		ListIterator iterator = anObjectList.listIterator();
		while (iterator.hasNext()) {
			if (!aQualifier.evaluateWithObject(iterator.next())) {
				iterator.remove();
			}
		}
	}

	/**
	 * Convenience to return a List consisting only of those objects in the
	 * specified List that meet the specified qualifier's requirements.
	 */
	public static NSArray filteredArrayWithQualifier(List anObjectList, EOQualifier aQualifier) {
		Object o;
		List result = new LinkedList();
		Iterator iterator = anObjectList.iterator();
		while (iterator.hasNext()) {
			o = iterator.next();
			if (aQualifier.evaluateWithObject(o)) {
				result.add(o);
			}
		}
		return new NSArray((Collection) result);
	}

	/**
	 * Convenience to create a set of EOKeyValueQualifiers joined by an
	 * EOAndQualifier. Each pair of keys and values are used to create
	 * EOKeyValueQualifiers.
	 */
	public static EOQualifier qualifierToMatchAllValues(Map aMap) {
		Object key, value;
		List qualifierList = new LinkedList();
		Iterator iterator = aMap.keySet().iterator();
		while (iterator.hasNext()) {
			key = iterator.next();
			value = aMap.get(key);
			qualifierList.add(new EOKeyValueQualifier(key.toString(), QualifierOperatorEqual, value));
		}
		return new EOAndQualifier(qualifierList);
	}

	/**
	 * Convenience to create a set of EOKeyValueQualifiers joined by an
	 * EOOrQualifier. Each pair of keys and values are used to create
	 * EOKeyValueQualifiers.
	 */
	public static EOQualifier qualifierToMatchAnyValue(Map aMap) {
		Object key, value;
		List qualifierList = new LinkedList();
		Iterator iterator = aMap.keySet().iterator();
		while (iterator.hasNext()) {
			key = iterator.next();
			value = aMap.get(key);
			qualifierList.add(new EOKeyValueQualifier(key.toString(), QualifierOperatorEqual, value));
		}
		return new EOOrQualifier(qualifierList);
	}

	/**
	 * Returns an EOQualifier that meets the criteria represented by the specified
	 * string and variable length argument list. This method parses the string and
	 * returns a tree of qualifiers. Each token beginning with "%" is replaced with
	 * the corresponding object from the argument list. The parser recognizes the
	 * operation tokens returned from the allQualifierOperators() method.
	 */
	public static EOQualifier qualifierWithQualifierFormat(String aString, List anArgumentList) {
		throw new RuntimeException("Not implemented yet.");
	}

	/**
	 * Returns a List of operators that are supported for relational operations.
	 * This excludes string comparison operators.
	 */
	public static NSArray relationalQualifierOperators() {
		NSMutableArray result = new NSMutableArray();
		BaseSelector selector;
		Iterator iterator = allQualifierOperators().iterator();
		while (iterator.hasNext()) {
			selector = (BaseSelector) iterator.next();
			if (selector.isRelationalOperator()) {
				result.addObject(selector);
			}
		}
		return result;
	}

	/**
	 * Returns a List of valid operators.
	 */
	public static NSArray allQualifierOperators() {
		return operators.allKeys();
	}

	/**
	 * Returns a selector the corresponds to the operation represented by the
	 * specified string. For example, ">" represents QualifierOperatorGreaterThan.
	 */
	public static NSSelector operatorSelectorForString(String anOperatorString) {
		return (NSSelector) operators.objectForKey(anOperatorString);
	}

	/**
	 * Returns a string the corresponds to the operation represented by the
	 * specified selector. For example, QualifierOperatorGreaterThan is represented
	 * with ">".
	 */
	public static String stringForOperatorSelector(NSSelector aSelector) {
		return (String) operators.allKeysForObject(aSelector).lastObject();
	}

	/**
	 * Returns a string representation of this qualifier.
	 */
	public String toString() {
		// TODO: implement this
		return super.toString();
	}

	// built-in qualifiers

	private static NSMutableDictionary operators;
	static {
		operators = new NSMutableDictionary();
		operators.setObjectForKey(QualifierOperatorCaseInsensitiveLike,
				QualifierOperatorCaseInsensitiveLike.toString());
		operators.setObjectForKey(QualifierOperatorContains, QualifierOperatorContains.toString());
		operators.setObjectForKey(QualifierOperatorEqual, QualifierOperatorEqual.toString());
		operators.setObjectForKey(QualifierOperatorGreaterThan, QualifierOperatorGreaterThan.toString());
		operators.setObjectForKey(QualifierOperatorGreaterThanOrEqualTo,
				QualifierOperatorGreaterThanOrEqualTo.toString());
		operators.setObjectForKey(QualifierOperatorLessThan, QualifierOperatorLessThan.toString());
		operators.setObjectForKey(QualifierOperatorLessThanOrEqualTo, QualifierOperatorLessThanOrEqualTo.toString());
		operators.setObjectForKey(QualifierOperatorLike, QualifierOperatorLike.toString());
		operators.setObjectForKey(QualifierOperatorNotEqual, QualifierOperatorNotEqual.toString());
	}

	static private abstract class BaseSelector extends NSSelector {
		public String name() {
			return "BaseSelector";
		}

		public Class[] parameterTypes() {
			return new Class[] { Object.class, Object.class };
		}

		public Method methodOnClass(Class aClass) throws NoSuchMethodException {
			throw new NoSuchMethodException();
		}

		public Method methodOnObject(Object anObject) throws NoSuchMethodException {
			throw new NoSuchMethodException();
		}

		public boolean implementedByClass(Class aClass) {
			return true;
		}

		public boolean implementedByObject(Object anObject) {
			return true;
		}

		public boolean isRelationalOperator() {
			return true;
		}

		public Object invoke(Object anObject, Object[] parameters) throws IllegalAccessException,
				IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
			return qualify(anObject, parameters[0]);
		}

		abstract protected Boolean qualify(Object target, Object parameter);

		protected int doCompare(Object o1, Object o2) {
			Class firstClass = o1.getClass();
			Class secondClass = o2.getClass();

			if (!(secondClass.equals(firstClass))) {
				Object converted = null;
				if (o2 instanceof Comparable) {
					converted = ValueConverter.convertObjectToClass(o1, secondClass);
					if (converted != null) {
						o1 = converted;
					}
				}

				if (converted == null && (o1 instanceof Comparable)) {
					converted = ValueConverter.convertObjectToClass(o2, firstClass);
					if (converted != null) {
						o2 = converted;
					}
				}

				if (converted == null) {
					throw new WotonomyException("Qualifier: Not Comparable Objects");
					// no way to compare
				}
			}

			return ((Comparable) o2).compareTo(o1);
		}

	}

	static class OperatorCaseInsensitiveLike extends BaseSelector {

		public boolean isRelationalOperator() {
			return false;
		}

		protected Boolean qualify(Object o1, Object o2) {
			String myString1 = o1.toString();
			String myString2 = o2.toString();
			myString1 = myString1.toLowerCase();
			myString2 = myString2.toLowerCase();
			StringTokenizer st = new StringTokenizer(myString1, "%");

			while (st.hasMoreTokens()) {
				String part = st.nextToken();
				int index = myString2.indexOf(part);
				if (index > -1) {
					myString2 = myString2.substring(index + part.length());
				} else {
					return Boolean.FALSE;
				}
			}
			return Boolean.TRUE;

		}

		public String toString() {
			return "caseInsensitiveLike";
		}
	}

	static class OperatorContains extends BaseSelector {

		public boolean isRelationalOperator() {
			return false;
		}

		protected Boolean qualify(Object o1, Object o2) {
			String myString1 = o1.toString();
			String myString2 = o2.toString();
			return new Boolean(myString2.indexOf(myString1) > -1);
		}

		public String toString() {
			return "contains";
		}
	}

	static class OperatorEqual extends BaseSelector {

		protected Boolean qualify(Object o1, Object o2) {
			return new Boolean(doCompare(o1, o2) == 0);
		}

		public String toString() {
			return "=";
		}
	}

	static class OperatorGreaterThan extends BaseSelector {

		protected Boolean qualify(Object o1, Object o2) {
			return new Boolean(doCompare(o1, o2) > 0);
		}

		public String toString() {
			return ">";
		}
	}

	static class OperatorGreaterThanOrEqualTo extends BaseSelector {

		protected Boolean qualify(Object o1, Object o2) {
			return new Boolean(doCompare(o1, o2) >= 0);
		}

		public String toString() {
			return new String(" >= ");
		}
	}

	static class OperatorLessThan extends BaseSelector {

		protected Boolean qualify(Object o1, Object o2) {
			return new Boolean(doCompare(o1, o2) < 0);
		}

		public String toString() {
			return ">";
		}
	}

	static class OperatorLessThanOrEqualTo extends BaseSelector {

		protected Boolean qualify(Object o1, Object o2) {
			return new Boolean(doCompare(o1, o2) <= 0);
		}

		public String toString() {
			return "<=";
		}
	}

	static class OperatorLike extends BaseSelector {

		public boolean isRelationalOperator() {
			return false;
		}

		protected Boolean qualify(Object o1, Object o2) {
			String myString1 = o1.toString();
			String myString2 = o2.toString();
			StringTokenizer st = new StringTokenizer(myString1, "%");
			while (st.hasMoreTokens()) {
				String part = st.nextToken();
				int index = myString2.indexOf(part);
				if (index > -1) {
					myString2 = myString2.substring(index + part.length());
				} else {
					return Boolean.FALSE;
				}
			}
			return Boolean.TRUE;
		}

		public String toString() {
			return "like";
		}
	}

	static class OperatorNotEqual extends BaseSelector {

		protected Boolean qualify(Object o1, Object o2) {
			return new Boolean(!(o1.equals(o2)));
		}

		public String toString() {
			return "!=";
		}
	}

	public static Object decodeWithKeyValueUnarchiver(EOKeyValueUnarchiver ua) {
		String cname = (String) ua.decodeObjectForKey("class");
		if (cname.equals("EOKeyValueQualifier"))
			return (EOQualifier) EOKeyValueQualifier.decodeWithKeyValueUnarchiver(ua);
		if (cname.equals("EOAndQualifier"))
			return (EOQualifier) EOAndQualifier.decodeWithKeyValueUnarchiver(ua);
		if (cname.equals("EOOrQualifier"))
			return (EOQualifier) EOOrQualifier.decodeWithKeyValueUnarchiver(ua);
		if (cname.equals("EONotQualifier"))
			return (EOQualifier) EONotQualifier.decodeWithKeyValueUnarchiver(ua);
		return null;
	}

}
/*
 * $Log$ Revision 1.2 2006/02/16 16:47:14 cgruber Move some classes in to
 * "internal" packages and re-work imports, etc.
 *
 * Also use UnsupportedOperationExceptions where appropriate, instead of
 * WotonomyExceptions.
 *
 * Revision 1.1 2006/02/16 13:19:57 cgruber Check in all sources in
 * eclipse-friendly maven-enabled packages.
 *
 * Revision 1.10 2003/08/09 01:22:51 chochos qualifiers implement
 * EOKeyValueArchiving
 *
 * Revision 1.9 2001/11/04 18:29:11 mpowers Better handling for non-string types
 * used with non-relational operators.
 *
 * Revision 1.8 2001/10/31 15:25:14 mpowers Cleanup of qualifiers.
 *
 * Revision 1.7 2001/10/30 22:57:28 mpowers EOQualifier framework is now
 * working.
 *
 * Revision 1.6 2001/10/30 22:16:37 mpowers Implemented operators as selectors.
 *
 * Revision 1.5 2001/09/14 14:21:28 mpowers Updated javadoc.
 *
 * Revision 1.3 2001/09/13 15:25:56 mpowers Started implementation of the
 * EOQualifier framework.
 *
 * Revision 1.2 2001/02/27 03:33:04 mpowers Initial draft of the key-value
 * qualifier.
 *
 * Revision 1.1.1.1 2000/12/21 15:46:47 mpowers Contributing wotonomy.
 *
 * Revision 1.2 2000/12/20 16:25:35 michael Added log to all files.
 *
 *
 */