package com.study;

import java.util.HashMap;

/***
 * 底層HashMap + 各個node用指標連線起來，將最新加入或者最新訪問的node放在佇列的右端，這樣佇列左端將是最“老”的node，記憶體不夠時，從最左端淘汰元素。
 * @author: 碼出地球
 */
public class LRUCache<K, V> {

    private HashMap<K,Node> cache = new HashMap<>();

    Node left = new Node();
    Node right 
 
= new Node();

    public LRUCache(){
        this.left.next = right;
        this.right.pre = left;
    }

    class Node{
        V value;
        Node pre;
        Node next;

        public Node(){}

        public Node(V value){
            this.value = value;
        }
    }

    /***
     * 新新增的node放在佇列的最右邊
     * 左 <=> node1 <=> node2 <=> node3 <=> 右
     *
     * 左 <=> node1 <=> node2 <=> newNode <=> 右
     * 
 
@param key
     * @param value
     * @description:
     * 這裡只簡單的處理了put新元素，當key存在時覆蓋，且移到最右端的沒有實現 ||_||
     */
    public void put(K key, V value){
        Node node = new Node(value);

        Node temp = right.pre;

        temp.next = node;
        node.next = right;
        node.pre = temp;
        right.pre 
 
= node;

        cache.put(key, node);
    }

    /***
     * 例如node1被訪問，移到佇列的最右邊
     * 左 <=> node1 <=> node2 <=> node3 <=> 右
     *
     * 左 <=> node2 <=> node3 <=> node1 <=> 右
     * @param key
     */
    public Node get(K key){
        Node node = cache.get(key);

        node.pre.next = node.next;
        node.next.pre = node.pre;


        Node temp = right.pre;

        temp.next = node;
        node.next = right;
        node.pre = temp;
        right.pre = node;


        return node;
    }

    public String toString(){
        String result = "";

        Node flag = left.next;
        while (flag != null && flag != right){
            result += flag.value.toString() + " ";
            flag = flag.next;
        }

        return result;
    }
}