package main

import (
  "log"
  "time"
)

type LRUCache struct {
  NodeMap map[int]Node
  Cap     int
}

func NewLRUCache(c int) *LRUCache {
  return &LRUCache{
    Cap:     c,
    NodeMap: make(map[int]Node, c),
  }
}

type Node struct {
  value    int
  lastUsed time.Time
}

// Put ...
func (lru *LRUCache) Put(key, value int) {
  mSize := len(lru.NodeMap)
  var leastRecentUsedKey int
  leastRecentUsedValue := time.Now()

  // remove if the max size reached
  if mSize >= lru.Cap {
    // remove most recent one
    for key, v := range lru.NodeMap {
      if v.lastUsed.Before(leastRecentUsedValue) {
        leastRecentUsedKey = key
        leastRecentUsedValue = v.lastUsed
      }
    }

    delete(lru.NodeMap, leastRecentUsedKey)
  }

  lru.NodeMap[key] = Node{
    value:    value,
    lastUsed: time.Now(),
  }
}

// Get ...
func (lru *LRUCache) Get(key int) int {
  val, prs := lru.NodeMap[key]

  if prs {
    return val.value
  }
  return -1
}

func main() {
  // create lru with size specified
  lru := NewLRUCache(5)

  // check no value case -> return -1
  log.Println(lru.Get(1))

  // use of put
  lru.Put(1, 1)
  lru.Put(2, 2)

  // use of get
  log.Println(lru.Get(1))
  log.Println(lru.Get(2))
}



/*

Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.

Implement the LRUCache class:

* LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
* int get(int key) Return the value of the key if the key exists, otherwise return -1.
* void put(int key, int value) Update the value of the key if the key exists. 
  Otherwise, add the key-value pair to the cache. 
  If the number of keys exceeds the capacity from this operation, evict the least recently used key.

*/