package org.webslinger.collections;

 import java.util.Arrays;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.ListIterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.NoSuchElementException;

 import java.util.StringTokenizer;

 import java.util.concurrent.atomic.AtomicReference;

 import org.apache.commons.lang.StringUtils;

 import org.apache.commons.collections.Transformer;

 import org.apache.commons.collections.iterators.EnumerationIterator;

 /**

  * This class contains various utility methods for manipulating various

  * collection type objects.

  * @author Adam Heath <a href="mailto:doogie@brainfood.com">doogie@brainfood.com</a>

  */

 public final class CollectionUtil {

     public static final String NESTED_CONTAINER_SEPARATORS = "./";

     /**

      * Splits <code>key</code> into parts specified by

      * {@link #NESTED_CONTAINER_SEPARATORS}, creates intervening HashMap

      * containers, then adds <code>item</code> * into the array at the

      * final leaf.  This method just calls {@link

      * #push(Map, String, String, Object) push(container, key,

      * NESTED_CONTAINER_SEPARATORS, item)}.

      * @param container Where to start the push.

      * @param key The location to place the new item.

      * @param item The item to push.

      */

     public static void push(Map<String, Object> container, String key, Object item) {

         push(container, key, NESTED_CONTAINER_SEPARATORS, item);

     }

     /**

      * Splits <code>key</code> into parts specified by

      * <code>separators</code>, creates intervening HashMap containers,

      * then adds <code>item</code> into the array at the final leaf.

      * @param container Where to start the push.

      * @param key The location to place the new item.

      * @param separators The characters used to split the <code>key

      * </code> with.

      * @param item The item to push.

      */

     public static void push(Map<String, Object> container, String key, String separators, Object item) {

         push(container, new StringTokenizer(key, separators), item);

     }

     public static void push(Map<String, Object> container, StringTokenizer st, Object item) {

         String key = st.nextToken();

         if (st.hasMoreTokens()) {

             Map<String, Object> nextContainer;

             synchronized (container) {

                 nextContainer = (Map<String, Object>) container.get(key);

                 if (nextContainer == null) {

                     nextContainer = new HashMap<String, Object>();

                     container.put(key, nextContainer);

                 }

             }

             push(nextContainer, st, item);

             return;

         }

         Collection<Object> col;

         synchronized (container) {

             col = (Collection<Object>) container.get(key);

             if (col == null) {

                 col = new ArrayList<Object>();

                 container.put(key, col);

             }

         }

         synchronized (col) {

             col.add(item);

         }

     }

     public static Object pop(Map<String, Object> container, String key) {

         return pop(container, key, NESTED_CONTAINER_SEPARATORS);

     }

     public static Object pop(Map<String, Object> container, String key, String separators) {

         return pop(container, new StringTokenizer(key, separators));

     }

     public static Object pop(Map<String, Object> container, StringTokenizer st) {

         String key = st.nextToken();

         if (st.hasMoreTokens()) {

             Map<String, Object> nextContainer = (Map<String, Object>) container.get(key);

             synchronized (container) {

                 nextContainer = (Map<String, Object>) container.get(key);

                 if (nextContainer == null) {

                     nextContainer = new HashMap<String, Object>();

                     container.put(key, nextContainer);

                 }

             }

             return pop(nextContainer, st);

         }

         Collection<Object> col;

         synchronized (container) {

             col = (Collection<Object>) container.get(key);

             if (col == null) return null;

             synchronized (col) {

                 Iterator<Object> it = col.iterator();

                 try {

                     if (it.hasNext()) return it.next();

                     return null;

                 } finally {

                     if (!it.hasNext()) container.remove(key);

                 }

             }

         }

     }

     public static void set(Map<String, Object> container, String key, Object item) {

         set(container, key, NESTED_CONTAINER_SEPARATORS, item);

     }

     public static void set(Map<String, Object> container, String key, String separators, Object item) {

         set(container, new StringTokenizer(key, separators), item);

     }

     public static void set(Map<String, Object> container, StringTokenizer st, Object item) {

         String key = st.nextToken();

         if (st.hasMoreTokens()) {

             Map<String, Object> nextContainer;

             synchronized (container) {

                 nextContainer = (Map<String, Object>) container.get(key);

                 if (nextContainer == null) {

                     nextContainer = new HashMap<String, Object>();

                     container.put(key, nextContainer);

                 }

             }

             set(nextContainer, st, item);

             return;

         }

         synchronized (container) {

             container.put(key, item);

         }

     }

     public static void remove(Map<String, Object> container, String key) {

         remove(container, key, NESTED_CONTAINER_SEPARATORS);

     }

     public static void remove(Map<String, Object> container, String key, String separators) {

         remove(container, new StringTokenizer(key, separators));

     }

     public static void remove(Map<String, Object> container, StringTokenizer st) {

         String key = st.nextToken();

         if (st.hasMoreTokens()) {

             Map<String, Object> nextContainer;

             synchronized (container) {

                 nextContainer = (Map<String, Object>) container.get(key);

                 if (nextContainer == null) {

                     nextContainer = new HashMap<String, Object>();

                     container.put(key, nextContainer);

                 }

             }

             remove(nextContainer, st);

             return;

         }

         synchronized (container) {

             container.remove(key);

         }

     }

     public static Object get(Map<String, Object> container, String key) {

         return get(container, key, NESTED_CONTAINER_SEPARATORS);

     }

     public static Object get(Map<String, Object> container, String key, String separators) {

         return get(container, new StringTokenizer(key, separators));

     }

     public static Object get(Map<String, Object> container, StringTokenizer st) {

         String key = st.nextToken();

         if (st.hasMoreTokens()) {

             Map<String, Object> nextContainer;

             synchronized (container) {

                 nextContainer = (Map<String, Object>) container.get(key);

                 if (nextContainer == null) {

                     nextContainer = new HashMap<String, Object>();

                     container.put(key, nextContainer);

                 }

             }

             return get(nextContainer, st);

         }

         synchronized (container) {

             return container.get(key);

         }

     }

     public static ListIterator<String> parse(String name, String separator) {

         StringTokenizer st = new StringTokenizer(name, separator);

         List<String> parts = new ArrayList<String>();

         try {

             while (true) {

                 parts.add(st.nextToken());

             }

         } catch (NoSuchElementException e) {

             // ignore

         }

         return parts.listIterator();

     }

     public static <T> Collection<T> addAll(Collection<T> col, T[] array) {

         org.apache.commons.collections.CollectionUtils.addAll(col, array);

         return col;

     }

     public static <T> Collection<T> addAll(Collection<T> col, Enumeration<T> en) {

         org.apache.commons.collections.CollectionUtils.addAll(col, en);

         return col;

     }

     public static <T> Collection<T> addAll(Collection<T> col, Iterator<T> it) {

         org.apache.commons.collections.CollectionUtils.addAll(col, it);

         return col;

     }

     public static String join(String[] items, String sep) {

         return StringUtils.join(items, sep);

     }

     public static String join(Collection<? extends Object> items, String sep) {

         return StringUtils.join(items, sep);

     }

     public static String join(Iterator<? extends Object> it, String sep) {

         return StringUtils.join(it, sep);

     }

     public static String join(Enumeration<? extends Object> en, String sep) {

         return StringUtils.join(new EnumerationIterator(en), sep);

     }

     public static List<String> split(String str, String regex) {

         String[] parts = str.split(regex);

         return Arrays.asList(parts);

     }

     public static List<String> split(String str, String regex, int limit) {

         String[] parts = str.split(regex, limit);

         return Arrays.asList(parts);

     }

     public static final <R, T> Collection<R> convert(Collection<T> names, Convertor<R, T> convertor) {

         return convert(names.iterator(), convertor);

     }

     public static final <R, T> Collection<R> convert(Iterator<T> it, Convertor<R, T> convertor) {

         List<R> converted = new ArrayList<R>();

         while (it.hasNext()) {

             converted.add(convertor.convert(it.next()));

         }

         return converted;

     }

     public interface Convertor<R, T> {

         R convert(T value);

     }

     public static abstract class StringConvertor implements Convertor<String, Object>, Transformer {

         public Object transform(Object value) {

             return convertString((String) value);

         }

         public String convert(Object value) {

             return convertString((String) value);

         }

         public abstract String convertString(String value);

     }

     public static Map<String, Object> expandMap(Map<String, Object> inMap) {

         return expandMap(inMap, new HashMap<String, Object>());

     }

     public static Map<String, Object> expandMap(Map<String, Object> inMap, Map<String, Object> returnMap) {

         for (Map.Entry<String, Object> entry: inMap.entrySet()) {

             String key = entry.getKey();

             Object value = entry.getValue();

             set(returnMap, key, ".", value instanceof String[] ? ((String[]) value)[0] : value);

         }

         return returnMap;

     }

     public static Map<String, Object> flattenMap(Map<String, Object> inMap) {

         return flattenMap("", inMap);

     }

     public static Map<String, Object> flattenMap(String prefix, Map<String, Object> inMap) {

         HashMap<String, Object> returnMap = new HashMap<String, Object>();

         StringBuilder sb = new StringBuilder();

         sb.append(prefix);

         flattenMap(returnMap, inMap, sb);

         return returnMap;

     }

     private static void flattenMap(Map<String, Object> returnMap, Map<String, Object> inMap, StringBuilder sb) {

         int length = sb.length();

         synchronized (inMap) {

             for (Map.Entry<String, Object> entry: inMap.entrySet()) {

                 sb.append(entry.getKey()).append('.');

                 Object value = entry.getValue();

                 if (value instanceof Map) {

                     flattenMap(returnMap, (Map<String, Object>) value, sb);

                 } else {

                     if (sb.charAt(sb.length() - 1) == '.') sb.setLength(sb.length() - 1);

                     returnMap.put(sb.toString(), value);

                 }

                 sb.setLength(length);

             }

         }

     }

     public static Map toMap(Object... args) {

         HashMap map = new HashMap(args.length / 2);

         for (int i = 0; i < args.length - 1; ) {

             Object key = args[i++];

             Object value = args[i++];

             map.put(key, value);

         }

         return map;

     }

     public static <K, V> Map<? extends K, ? extends V> toMap(K k1, V v1) {

         HashMap<K, V> map = new HashMap<K, V>(1);

         map.put(k1, v1);

         return map;

     }

     public static <K, V> Map<? extends K, ? extends V> toMap(K k1, V v1, K k2, V v2) {

         HashMap<K, V> map = new HashMap<K, V>(2);

         map.put(k1, v1);

         map.put(k2, v2);

         return map;

     }

     public static <K, V> Map<? extends K, ? extends V> toMap(K k1, V v1, K k2, V v2, K k3, V v3) {

         HashMap<K, V> map = new HashMap<K, V>(3);

         map.put(k1, v1);

         map.put(k2, v2);

         map.put(k3, v3);

         return map;

     }

 }