package helpers;

import java.awt.Color;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class CountMap {
	private final Map<Integer, Integer> Counts = new HashMap<>();

	private int avgR = 128;
	private int avgG = 128;
	private int avgB = 128;
	private int avgA = 128;
	
	public void add(Integer key) {
		if (Counts.containsKey(key)) {
			Counts.put(key, Counts.get(key) + 1);
		} else {
			Counts.put(key, 1);
		}
		updateAvgColor(key);
	}

	public Map<Integer, Integer> getCounts() {
		return this.Counts;
	}

	public static <K extends Comparable, V extends Comparable> Map<K, V> sortByValues(Map<K, V> map) {
		List<Map.Entry<K, V>> entries = new LinkedList<Map.Entry<K, V>>(map.entrySet());

		Collections.sort(entries, new Comparator<Map.Entry<K, V>>() {

			@Override
			public int compare(Entry<K, V> o1, Entry<K, V> o2) {
				return o2.getValue().compareTo(o1.getValue());
			}
		});

		Map<K, V> sortedMap = new LinkedHashMap<K, V>();

		for (Map.Entry<K, V> entry : entries) {
			sortedMap.put(entry.getKey(), entry.getValue());
		}

		return sortedMap;
	}

	public String toString() {
		StringBuilder sb = new StringBuilder();
		Map<Integer, Integer> sorted = sortByValues(Counts);
		for (Integer color : sorted.keySet()) {
			sb.append(color).append(" ").append(sorted.get(color)).append("\n");
		}
		return sb.toString();
	}

	public int getAvgR() {
		return avgR;
	}

	public int getAvgG() {
		return avgG;
	}

	public int getAvgB() {
		return avgB;
	}

	public int getAvgA() {
		return avgA;
	}
	
	public int getSize() {
		return this.Counts.size();
	}
	
	private void updateAvgColor(Integer key) {
		Color rgbColor = new Color(key, true);
		avgR = (avgR+rgbColor.getRed())/2;
		avgG = (avgG+rgbColor.getGreen())/2;
		avgB = (avgB+rgbColor.getBlue())/2;
		avgA = (avgB+rgbColor.getAlpha())/2;
	}
}