import java.util.HashMap;

public class Cache<K, V>
{
	private final int size;
	private int len;

	private CacheNode head;
	private CacheNode tail;

	private class CacheNode
	{
		public CacheNode prev;
		public CacheNode next;
		public K key;
		public V value;

		public CacheNode(K key, V value)
		{
			this.key = key;
			this.value = value;
			prev = null;
			next = null;
		}

		public void unlink()
		{
			if(prev == null) {
				head = next;
			} else {
				prev.next = next;
			}

			if(next == null) {
				tail = prev;
			} else {
				next.prev = prev;
			}

			prev = null;
			next = null;

			len --;
		}

		public void append()
		{
			if(tail == null) {
				head = this;
				tail = this;
			} else {
				tail.next = this;
				prev = tail;
				tail = this;
			}

			len ++;
		}
	}

	private HashMap<K, CacheNode> map;

	public Cache(int size)
	{
		this.size = size;
		len = 0;

		head = null;
		tail = null;

		map = new HashMap<K, CacheNode>();
	}

	/* returns value for key, if key exists in the cache
	 * otherwise null */
	public V get(K key)
	{
		CacheNode n = map.get(key);
		if(n == null)
			return null;
		return n.value;
	}

	/* puts a new key-value pair in the cache
	 * if the key existed already, the value is updated, and the old value is returned
	 * if the key didn't exist, it is added; the oldest value (now pushed out of the
	 * cache) may be returned, or null if the cache isn't yet full */
	public V put(K key, V value)
	{
		CacheNode n = map.get(key);
		if(n == null) {
			V ret = null;

			if(len >= size) {
				CacheNode first = head;
				first.unlink();
				map.remove(first.key);
				ret = first.value;
			}

			CacheNode add = new CacheNode(key, value);
			add.append();
			map.put(key, add);

			return ret;
		} else {
			n.unlink();
			V old = n.value;
			n.value = value;
			n.append();
			return old;
		}
	}
}