/*
    * The contents of this file are subject to the terms 
    * of the Common Development and Distribution License 
    * (the "License").  You may not use this file except 
    * in compliance with the License.
    * 
    * You can obtain a copy of the license at 
    * http://www.sun.com/cddl/cddl.html. 
    * 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 
   * license.txt.  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]
   * 
   * Portions Copyright 2004 eBay, Inc.
   */
  package com.ebay.carad.os.vitalsigns.util;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Comparator;
  import java.util.Collections;
  import java.util.Set;
  import java.util.HashSet;
  import java.util.Collection;
  import java.util.Arrays;
  
  import org.apache.commons.collections.Transformer;
  import org.apache.commons.collections.MultiHashMap;
  import org.apache.commons.collections.MultiMap;
  import org.apache.commons.collections.comparators.ComparableComparator;
  
  /***
   * Utility class for manipulating collections.
   * 
   * @author Jeremy Kraybill
   * @author Jeremy Thomerson
   * @version $Id$
   */
  public final class CollectionUtil {
  
  	private CollectionUtil() {
  		// This block intentionally left blank.  Thank you PMD.
  	}
  
  	/***
  	 * Transformer to convert objects' string representations to integers.
  	 */
  	public static final Transformer TO_INTEGER_TRANSFORM = new Transformer() {
  		public Object transform(Object obj) {
  			return Integer.valueOf(obj.toString());
  		}
  	};
  
  	/***
  	 * Returns a list contain N lists.
  	 * 
  	 * @param containedLists number of lists to contain.
  	 * @return The list that contains <tt>containedLists</tt> lists.
  	 */
  	public static List listOfLists(int containedLists) {
  		List retList = new ArrayList();
  		for (int i = 0; i < containedLists; i++) {
  			List set = new ArrayList();
  			retList.add(set);
  		}
  		return retList;
  	}
  
  	/***
  	 * Converts the keys of a map to integers and creates a <b>new</b> map with
  	 * these new keys and the original values.
  	 * @param inMap
  	 * @return <b>Non-null</b>
  	 */
  	public static Map convertKeysToIntegers(Map inMap) {
  		Map outMap = new HashMap(inMap.size());
  		Iterator iterator = inMap.entrySet().iterator();
  		while (iterator.hasNext()) {
  			Map.Entry entry = (Map.Entry) iterator.next();
  			outMap.put(TO_INTEGER_TRANSFORM.transform(entry.getKey().toString()), entry.getValue());
  		}
  		return outMap;
  	}
  
  	public static void sortMultiMapLists(MultiHashMap map, Comparator comparator) {
  		Iterator iterator = map.entrySet().iterator();
  		while (iterator.hasNext()) {
  			Map.Entry entry = (Map.Entry) iterator.next();
  			Collections.sort((List) entry.getValue(), comparator);
  		}
  	}
 
 	public static MultiMap unmodifiableMultiMap(MultiMap map) {
 		return new UnmodifiableMultiMap(map);
 	}
 
 	/***
 	 * Concatinates the elements of the collection into a single string.  Uses each element's "toString" method, and adds a ", " between
 	 * elements.  This method is mostly intended for use in debug or error messaging where a the collection of items is relevent
 	 * information.
 	 * @param coll <b>Non-null</b> collection of <b>Non-null</b> elements
 	 */
 	public static String toString(Collection coll) {
 		StringBuffer buf = new StringBuffer();
 		Iterator iterator = coll.iterator();
 		while (iterator.hasNext()) {
 			buf.append(iterator.next().toString());
 			if (iterator.hasNext()) {
 				buf.append(", ");
 			}
 		}
 		return buf.toString();
 	}
 
 	public static class SetComparator implements Comparator {
 
 		private final Comparator comparator;
 
 		public SetComparator(Comparator comparator) {
 			this.comparator = comparator;
 		}
 
 		public int compare(Object o1, Object o2) {
 			if (o1 == o2) {
 				return 0;
 			}
 
 			Collection set1 = (Collection) o1;
 			Collection set2 = (Collection) o2;
 
 			if (set1.size() != set2.size()) {
 				return set1.size() - set2.size();
 			}
 
 			Object[] array1 = set1.toArray();
 			Object[] array2 = set2.toArray();
 
 			Arrays.sort(array1, comparator);
 			Arrays.sort(array2, comparator);
 
 			for (int i = 0; i < array1.length; i++) {
 				int delta = comparator.compare(array1[i], array2[i]);
 				if (delta != 0) {
 					return delta;
 				}
 			}
 
 			return 0;
 		}
 	}
 
 	public static int compareSets(Collection set1, Collection set2) {
 		Comparator setComparator = new SetComparator(new ComparableComparator());
 		return setComparator.compare(set1, set2);
 	}
 
 	public static int compareSets(Collection set1, Collection set2, Comparator comparator) {
 		Comparator setComparator = new SetComparator(comparator);
 		return setComparator.compare(set1, set2);
 	}
 
 	private static class UnmodifiableMultiMap implements MultiMap {
 
 		private final Map mMap;
         private final Set allValues;
 
 		protected UnmodifiableMultiMap(MultiMap source) {
 			Map tempMap = new HashMap();
 			Set tempAllValues = new HashSet();
 
 			Iterator iterator = source.entrySet().iterator();
 			while (iterator.hasNext()) {
 				Entry entry = (Entry) iterator.next();
 				Object key = entry.getKey();
 				Collection values = (Collection) entry.getValue();
 
 				if (values != null) {
 					values = Collections.unmodifiableCollection(values);
 				}
 
 				tempMap.put(key, values);
 				tempAllValues.addAll(values);
 			}
 
 			mMap = Collections.unmodifiableMap(tempMap);
 			allValues = Collections.unmodifiableSet(tempAllValues);
 		}
 
 		public int size() { return mMap.size(); }
 		public boolean isEmpty() { return mMap.isEmpty(); }
 
 		public boolean containsKey(Object key) { return mMap.containsKey(key); }
 		public boolean containsValue(Object value) { return allValues.contains(value); }
 
 		public Set keySet() { return mMap.keySet(); }
 		public Set entrySet() { return mMap.entrySet(); }
 
 		public Object get(Object key) { return (Collection) mMap.get(key); }
 		public Collection values() { return allValues; }
 
 		public Object put(Object key, Object value) { throw new UnsupportedOperationException("UnmodifiableMultiMap can not be modified"); }
 		public void putAll(Map map) { throw new UnsupportedOperationException("UnmodifiableMultiMap can not be modified"); }
 
 		public Object remove(Object key) { throw new UnsupportedOperationException("UnmodifiableMultiMap can not be modified"); }
 		public Object remove(Object key, Object item) { throw new UnsupportedOperationException("UnmodifiableMultiMap can not be modified"); }
 
 		public void clear() { throw new UnsupportedOperationException("UnmodifiableMultiMap can not be modified"); }
 	}
 }