package main
import (
  "github.com/muesli/cache2go"
  "log"
  "time"
)
type Item struct {
  Name   string `json:"name"`
  Prices int64  `json:"prices"`
  Stocks int64  `json:"stocks"`
}
func basicOpTest() {
  // 初始化itemCache本地緩存
  itemCache := cache2go.Cache("itemCache")
  item := &Item{
     Name:   "MacBookPro",
     Prices: 10000,
     Stocks: 1,
  }
  // 添加item1緩存，過期時間為5秒鐘
  itemCache.Add("item1", 5*time.Second, item)
  // 讀取item1緩存
  if v, err := itemCache.Value("item1"); err != nil {
     log.Printf("item1 err = %v", err)
  } else {
     log.Printf("讀取item1緩存：%#v", v.Data())
  }
  // 睡眠6s后讀取
  time.Sleep(6 * time.Second)
  if v, err := itemCache.Value("item1"); err != nil {
     log.Printf("item1 err = %v", err)
  } else {
     log.Printf("6s后讀取item1緩存：%#v", v.Data())
  }
  // 添加item2，不設置過期時間
  itemCache.Add("item2", 0, item)
  // 讀取item2緩存
  if v, err := itemCache.Value("item2"); err != nil {
     log.Printf("item2 err = %v", err)
  } else {
     log.Printf("讀取item2緩存：%#v", v.Data())
  }
  // 刪除掉item2緩存
  itemCache.Delete("item2")
  // 再讀取item2緩存
  if v, err := itemCache.Value("item2"); err != nil {
     log.Printf("item2 err = %v", err)
  } else {
     log.Printf("讀取item2緩存：%#v", v.Data())
  }
  // 添加item3緩存，并刪除所有緩存
  itemCache.Add("item3", 0, item)
  itemCache.Flush()
  // 讀取item3緩存
  if v, err := itemCache.Value("item3"); err != nil {
     log.Printf("item3 err = %v", err)
  } else {
     log.Printf("讀取item3緩存：%#v", v.Data())
  }
}

func callBackTest() {
   // 初始化itemCache本地緩存
   itemCache := cache2go.Cache("itemCache")
   // 設置各操作回調函數(shù)
   itemCache.AddAddedItemCallback(func(item *cache2go.CacheItem) {
      log.Printf("added callback, item = %#v", item)
   })
   itemCache.AddAboutToDeleteItemCallback(func(item *cache2go.CacheItem) {
      log.Printf("deleted callback, item = %#v", item)
   })
   item := itemCache.Add("expire_item", 1*time.Second, Item{
      Name:   "expire_item",
      Prices: 1,
      Stocks: 1,
   })
   item.AddAboutToExpireCallback(func(item interface{}) {
      log.Printf("expired callback, item = %#v", item)
   })
   // 執(zhí)行基本操作
   basicOpTest()
}

func dataLoaderTest() {
   // 初始化itemCache本地緩存
   redisItemCache := cache2go.Cache("redisItemCache")
   // 設置自定義的cache加載邏輯
   redisItemCache.SetDataLoader(func(key interface{}, args ...interface{}) *cache2go.CacheItem {
      // 如果是redis開頭的key，先從redis中獲取
      if strings.HasPrefix(key.(string), "redis") {
         return cache2go.NewCacheItem(key, 0, Item{
            Name: "redis_item",
         })
      }
      return nil
   })
   // 寫入一條數(shù)據(jù)
   redisItemCache.Add("item1", 0, Item{
      Name: "item1",
   })
   item1, _ := redisItemCache.Value("item1")
   log.Printf("item1 = %#v", item1)
   redisItem, _ := redisItemCache.Value("redis_item")
   log.Printf("redisItem = %#v", redisItem)
}

type CacheTable struct {
   sync.RWMutex
   // The table's name.
   name string
   // All cached items.
   items map[interface{}]*CacheItem
   // Timer responsible for triggering cleanup.
   cleanupTimer *time.Timer
   // Current timer duration.
   cleanupInterval time.Duration
   // The logger used for this table.
   logger *log.Logger
   // Callback method triggered when trying to load a non-existing key.
   loadData func(key interface{}, args ...interface{}) *CacheItem
   // Callback method triggered when adding a new item to the cache.
   addedItem []func(item *CacheItem)
   // Callback method triggered before deleting an item from the cache.
   aboutToDeleteItem []func(item *CacheItem)
}

type CacheItem struct {
   sync.RWMutex
   // The item's key.
   key interface{}
   // The item's data.
   data interface{}
   // How long will the item live in the cache when not being accessed/kept alive.
   lifeSpan time.Duration
   // Creation timestamp.
   createdOn time.Time
   // Last access timestamp.
   accessedOn time.Time
   // How often the item was accessed.
   accessCount int64
   // Callback method triggered right before removing the item from the cache
   aboutToExpire []func(key interface{})
}

var (
   // 全局cache map
   cache = make(map[string]*CacheTable)
   // cache map 讀寫鎖
   mutex sync.RWMutex
)
// 從cache map中獲取對應的CacheTable，不存在則創(chuàng)建新的
func Cache(table string) *CacheTable {
   // 先上讀鎖，獲取cacheTable
   mutex.RLock()
   t, ok := cache[table]
   mutex.RUnlock()
   // 不存在，則新建
   if !ok {
      // 寫操作需要上寫鎖
      mutex.Lock()
      t, ok = cache[table]
      // 雙重校驗是否存在
      if !ok {
         // 不存在則新建cacheTable
         t = &CacheTable{
            name:  table,
            items: make(map[interface{}]*CacheItem),
         }
         cache[table] = t
      }
      mutex.Unlock()
   }
   return t
}

func (table *CacheTable) Add(key interface{}, lifeSpan time.Duration, data interface{}) *CacheItem {
   // 封裝一個item
   item := NewCacheItem(key, lifeSpan, data)
   // 鎖表，將item添加進去
   table.Lock()
   table.addInternal(item)
   return item
}
func (table *CacheTable) addInternal(item *CacheItem) {
   // 添加kv值到map中
   table.items[item.key] = item
   expDur := table.cleanupInterval
   addedItem := table.addedItem
   // 添加完成解除寫鎖
   table.Unlock()
   // 觸發(fā)Add回調函數(shù)
   if addedItem != nil {
      for _, callback := range addedItem {
         callback(item)
      }
   }
   // 如果一個item有設置過期時間，且比檢查失效間隔小，則進行過期key清理（懶加載思想，只有存在這類Key才會啟動清理，而不是定時任務）
   if item.lifeSpan > 0 && (expDur == 0 || item.lifeSpan < expDur) {
      table.expirationCheck()
   }
}
func (table *CacheTable) expirationCheck() {
   table.Lock()
   if table.cleanupTimer != nil {
      table.cleanupTimer.Stop()
   }
   if table.cleanupInterval > 0 {
      table.log("Expiration check triggered after", table.cleanupInterval, "for table", table.name)
   } else {
      table.log("Expiration check installed for table", table.name)
   }
   now := time.Now()
   smallestDuration := 0 * time.Second
   for key, item := range table.items {
      // 遍歷該table下的所有items
      item.RLock()
      lifeSpan := item.lifeSpan
      accessedOn := item.accessedOn
      item.RUnlock()
      if lifeSpan == 0 {
         continue
      }
      if now.Sub(accessedOn) >= lifeSpan {
         // 該item已超出存活時間，刪除key
         table.deleteInternal(key)
      } else {
         // 找到最小的需要過期的item，計算最優(yōu)時間間隔
         if smallestDuration == 0 || lifeSpan-now.Sub(accessedOn) < smallestDuration {
            smallestDuration = lifeSpan - now.Sub(accessedOn)
         }
      }
   }
   // 在最優(yōu)時間間隔后啟動定時任務檢查table的過期key
   table.cleanupInterval = smallestDuration
   if smallestDuration > 0 {
      table.cleanupTimer = time.AfterFunc(smallestDuration, func() {
         go table.expirationCheck()
      })
   }
   table.Unlock()
}

func (table *CacheTable) Value(key interface{}, args ...interface{}) (*CacheItem, error) {
   table.RLock()
   // 先嘗試從items中獲取該item
   r, ok := table.items[key]
   loadData := table.loadData
   table.RUnlock()
   if ok {
      // 如果存在，則更新該item的accessOn時間和accessCount計數(shù)
      r.KeepAlive()
      return r, nil
   }
   // 如果不存在，則從loadData自定義加載函數(shù)中嘗試獲取
   if loadData != nil {
      item := loadData(key, args...)
      if item != nil {
         // 如果自定義加載函數(shù)中存在該item，則添加到table中并返回
         table.Add(key, item.lifeSpan, item.data)
         return item, nil
      }
      return nil, ErrKeyNotFoundOrLoadable
   }
   return nil, ErrKeyNotFound
}

func (table *CacheTable) Delete(key interface{}) (*CacheItem, error) {
   table.Lock()
   defer table.Unlock()
   return table.deleteInternal(key)
}
func (table *CacheTable) deleteInternal(key interface{}) (*CacheItem, error) {
   // 判斷key是否存在
   r, ok := table.items[key]
   if !ok {
      return nil, ErrKeyNotFound
   }
   aboutToDeleteItem := table.aboutToDeleteItem
   table.Unlock()
   // 先觸發(fā)刪除回調函數(shù)
   if aboutToDeleteItem != nil {
      for _, callback := range aboutToDeleteItem {
         callback(r)
      }
   }
   r.RLock()
   defer r.RUnlock()
   // 觸發(fā)item的過期回調函數(shù)
   if r.aboutToExpire != nil {
      for _, callback := range r.aboutToExpire {
         callback(key)
      }
   }
   table.Lock()
   table.log("Deleting item with key", key, "created on", r.createdOn, "and hit", r.accessCount, "times from table", table.name)
   // 將item從table中刪除
   delete(table.items, key)
   return r, nil
}

func (table *CacheTable) Flush() {
   table.Lock()
   defer table.Unlock()
   table.log("Flushing table", table.name)
   // 直接將items重新初始化
   table.items = make(map[interface{}]*CacheItem)
   table.cleanupInterval = 0
   if table.cleanupTimer != nil {
      // 如果此時還有清理過期定時器，則終止其運行
      table.cleanupTimer.Stop()
   }
}