package lru

import (
	"container/list"
)

type Cache struct {
	maxBytes  int64
	nBytes    int64
	ll        *list.List
	cache     map[string]*list.Element
	onEvicted func(key string, value Value)
}

type entry struct {
	key   string
	value Value
}

type Value interface {
	Len() int
}

func New(maxBytes int64, onEvicted func(key string, value Value)) *Cache {
	cache := &Cache{
		maxBytes:  maxBytes,
		nBytes:    0,
		ll:        list.New(),
		cache:     make(map[string]*list.Element),
		onEvicted: onEvicted,
	}
	return cache
}

func (this *Cache) put(key string, value Value) {
	ele, ok := this.cache[key]
	if ok {
		this.ll.MoveToFront(ele)
		element := ele.Value.(*entry)
		this.nBytes += int64(value.Len()) - int64(element.value.Len())
		element.value = value
	} else {
		element := this.ll.PushFront(&entry{key, value})
		this.cache[key] = element
		this.nBytes += int64(len(key)) + int64(value.Len())
	}
	if this.maxBytes != 0 && this.maxBytes < this.nBytes {
		this.removeOldest()
	}
}

func (this *Cache) removeOldest() {
	ele := this.ll.Back()
	if ele != nil {
		this.ll.Remove(ele)
		element := ele.Value.(*entry)
		delete(this.cache, element.key)
		this.nBytes -= int64(len(element.key)) + int64(element.value.Len())
		if this.onEvicted != nil {
			this.onEvicted(element.key, element.value)
		}
	}
}

func (this *Cache) Get(key string) (value Value, ok bool) {
	element := this.cache[key]
	if element != nil {
		this.ll.MoveToFront(element)
		kv := element.Value.(*entry)
		return kv.value, true
	} else {
		return nil, false
	}
}