package cache

import (
	"bytes"
	"encoding/gob"
	"errors"
	"os"
	"reflect"
	"sync"
)

// SetPersist 设置持久化储蓄
// path: 文件路径
// 警告: 请在创建缓存同时设置,否则会出现原有数据丢失
// *如果需要储蓄自定义结构体,请在init包使用gob.Register()注册
func (c *Cache[K, V]) SetPersist(path string) error {
	if c.persist != nil {
		return errors.New("persist already set up")
	}
	c.persist = c.setPersist(path)
	return nil
}

// PersistSave 手动保存持久化数据
// 会覆盖指定路径的文件 也可以用作创建快照
func (c *Cache[K, V]) PersistSave(path string) {
	datas := make(map[K]*Data[V])
	c.data.Range(func(key, value any) bool {
		datas[key.(K)] = value.(*Data[V])
		return true
	})
	err := c.saveCache(path, datas)
	if err != nil {
		c.fatal(err)
	}
}

func (c *Cache[K, V]) setPersist(path string) func() {
	gob.Register(map[K]*Data[V]{})
	stopChan := make(chan struct{})
	var wg sync.WaitGroup

	data, err := c.loadCache(path)
	if err != nil {
		c.fatal(err)
	}
	if data != nil {
		for k, v := range data {
			c.data.Store(k, v)
		}
	}
	go func() {
		wg.Add(1)
		var newData map[K]*Data[V] // 提取缓存降低锁的时间
		var oldData map[K]*Data[V]
		// 关闭时保存一次数据
		//defer c.PersistSave(path)
		for {
			select {
			case <-stopChan:
				wg.Done()
				return
			default:
				newData = make(map[K]*Data[V])
				c.data.Range(func(key, value any) bool {
					newData[key.(K)] = value.(*Data[V])
					return true
				})
				if compareMaps(newData, oldData) {
					continue
				}
				err := c.saveCache(path, newData)
				if err != nil {
					c.fatal(err)
					continue
				} else {
					oldData = newData
				}
			}
		}
	}()

	return func() {
		close(stopChan)
		wg.Wait()
	}
}

// loadCache 加载持久化数据(会覆盖原有数据)
func (c *Cache[K, V]) loadCache(path string) (map[K]*Data[V], error) {
	// 判断文件是否存在
	if info, err := os.Stat(path); errors.Is(err, os.ErrNotExist) || info.Size() == 0 {
		return nil, nil
	}
	// 读取文件
	file, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	// 解析文件
	var data map[K]*Data[V]
	err = gob.NewDecoder(bytes.NewReader(file)).Decode(&data)
	if err != nil {
		return nil, err
	}

	return data, nil
}

// saveCache 保存持久化数据(会覆盖原有文件)
func (c *Cache[K, V]) saveCache(path string, data map[K]*Data[V]) error {
	// 编码数据
	var buf bytes.Buffer
	err := gob.NewEncoder(&buf).Encode(data)
	if err != nil {
		return err
	}
	// 写入/覆盖文件
	err = os.WriteFile(path, buf.Bytes(), 0644)
	if err != nil {
		return err
	}

	return nil
}

// compareMaps 比较两个 map 是否相等
func compareMaps[K comparable, V any](map1, map2 map[K]V) bool {
	if len(map1) != len(map2) {
		return false
	}
	for k, v1 := range map1 {
		v2, ok := map2[k]
		if !ok || !reflect.DeepEqual(v1, v2) {
			return false
		}
	}
	return true
}