// Mega Sena Generator - Java based Mega Sena Number Generator
// Version 
// Copyright (C) 2007 Marcos Peron
// http://www.marcosperon.com/download/
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of either one of the following licences:
//
// 1. The Eclipse Public License (EPL) version 1.0,
// included in this distribution in the file licence-epl-1.0.html
// or available at http://www.eclipse.org/legal/epl-v10.html
//
// 2. The GNU Lesser General Public License (LGPL) version 2.1 or later,
// included in this distribution in the file licence-lgpl-2.1.txt
// or available at http://www.gnu.org/licenses/lgpl.txt
//
// This library is distributed on an "AS IS" basis,
// WITHOUT WARRANTY OF ANY KIND, either express or implied.
// See the individual licence texts for more details.
package com.marcosperon.util;

import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

// TODO: Auto-generated Javadoc
/**
 * The Class MapUtils.
 * 
 * @author Marcos Peron
 */
public class MapUtils {

	/**
	 * Reverse.
	 * 
	 * @param map
	 *            the map
	 * 
	 * @return the map< k, v>
	 */
	public static <K extends Comparable<K>, V> Map<K, V> reverse(Map<K, V> map) {
		List<Map.Entry<K, V>> mapEntry = new LinkedList<Map.Entry<K, V>>(map
				.entrySet());
		Collections.reverse(mapEntry);
		LinkedHashMap<K, V> reversedMap = new LinkedHashMap<K, V>();
		for (Iterator<Map.Entry<K, V>> it = mapEntry.iterator(); it.hasNext();) {
			Map.Entry<K, V> entry = it.next();
			reversedMap.put(entry.getKey(), entry.getValue());
		}
		return (reversedMap);
	}

	/**
	 * Sort map by key.
	 * 
	 * @param map
	 *            the map
	 * 
	 * @return the map< k, v>
	 */
	public static <K extends Comparable<K>, V> Map<K, V> sortMapByKey(
			Map<K, V> map) {
		return (MapUtils.sortMapByKey(map, true));
	}

	/**
	 * Sort map by key.
	 * 
	 * @param map
	 *            the map
	 * @param ascending
	 *            if will be ascending or descending
	 * 
	 * @return the map< k, v>
	 */
	public static <K extends Comparable<K>, V> Map<K, V> sortMapByKey(
			Map<K, V> map, boolean ascending) {
		Comparator<K> c = new Comparator<K>() {
			@Override
			public int compare(K o1, K o2) {
				return o1.compareTo(o2);
			}
		};
		return (MapUtils.sortMapByKey(map, c, ascending));
	}

	/**
	 * Sort map by key.
	 * 
	 * @param map
	 *            the map
	 * @param c
	 *            the comparator
	 * 
	 * @return the map< k, v>
	 */
	public static <K extends Comparable<K>, V> Map<K, V> sortMapByKey(
			Map<K, V> map, final Comparator<K> c) {
		return (MapUtils.sortMapByKey(map, c, true));
	}

	/**
	 * Sort map by key.
	 * 
	 * @param map
	 *            the map
	 * @param c
	 *            the comparator
	 * @param ascending
	 *            if will be ascending or descending
	 * 
	 * @return the map< k, v>
	 */
	public static <K extends Comparable<K>, V> Map<K, V> sortMapByKey(
			Map<K, V> map, final Comparator<K> c, boolean ascending) {
		List<Map.Entry<K, V>> mapEntry = new LinkedList<Map.Entry<K, V>>(map
				.entrySet());

		Collections.sort(mapEntry, new Comparator<Map.Entry<K, V>>() {
			@Override
			public int compare(Entry<K, V> o1, Entry<K, V> o2) {
				return (c.compare(o1.getKey(), o2.getKey()));
			}
		});

		if (!ascending) {
			Collections.reverse(mapEntry);
		}

		LinkedHashMap<K, V> orderMap = new LinkedHashMap<K, V>();
		for (Iterator<Map.Entry<K, V>> it = mapEntry.iterator(); it.hasNext();) {
			Map.Entry<K, V> entry = it.next();
			orderMap.put(entry.getKey(), entry.getValue());
		}
		return (orderMap);
	}

	/**
	 * Sort map by value.
	 * 
	 * @param map
	 *            the map
	 * 
	 * @return the map< k, v>
	 */
	public static <K, V extends Comparable<V>> Map<K, V> sortMapByValue(
			Map<K, V> map) {
		return (MapUtils.sortMapByValue(map, true));
	}

	/**
	 * Sort map by value.
	 * 
	 * @param map
	 *            the map
	 * @param ascending
	 *            if will be ascending or descending
	 * 
	 * @return the map< k, v>
	 */
	public static <K, V extends Comparable<V>> Map<K, V> sortMapByValue(
			Map<K, V> map, boolean ascending) {
		Comparator<V> c = new Comparator<V>() {
			@Override
			public int compare(V o1, V o2) {
				return o1.compareTo(o2);
			}
		};
		return (MapUtils.sortMapByValue(map, c, ascending));
	}

	/**
	 * Sort map by value.
	 * 
	 * @param map
	 *            the map
	 * @param c
	 *            the comparator
	 * 
	 * @return the map< k, v>
	 */
	public static <K, V extends Comparable<V>> Map<K, V> sortMapByValue(
			Map<K, V> map, final Comparator<V> c) {
		return (MapUtils.sortMapByValue(map, c, true));
	}

	/**
	 * Sort map by value.
	 * 
	 * @param map
	 *            the map
	 * @param c
	 *            the comparator
	 * @param ascending
	 *            if will be ascending or descending
	 * 
	 * @return the map< k, v>
	 */
	public static <K, V extends Comparable<V>> Map<K, V> sortMapByValue(
			Map<K, V> map, final Comparator<V> c, boolean ascending) {
		List<Map.Entry<K, V>> mapEntry = new LinkedList<Map.Entry<K, V>>(map
				.entrySet());
		Collections.sort(mapEntry, new Comparator<Map.Entry<K, V>>() {
			@Override
			public int compare(Entry<K, V> o1, Entry<K, V> o2) {
				return (c.compare(o1.getValue(), o2.getValue()));
			}
		});

		if (!ascending) {
			Collections.reverse(mapEntry);
		}
		LinkedHashMap<K, V> orderMap = new LinkedHashMap<K, V>();
		for (Iterator<Map.Entry<K, V>> it = mapEntry.iterator(); it.hasNext();) {
			Map.Entry<K, V> entry = it.next();
			orderMap.put(entry.getKey(), entry.getValue());
		}
		return (orderMap);
	}
	
}