package simple_bitcask_kv

import (
	"github.com/stretchr/testify/assert"
	"os"
	"simple_bitcask_kv/utils"
	"testing"
)

func destroyDB(db *DB) {
	if db != nil {
		if db.activeFile != nil {
			db.Close()
		}
		err := os.RemoveAll(db.options.DirPath)
		if err != nil {
			panic(err)
		}
	}
}

func TestDB_PutGetDelete(t *testing.T) {
	opts := DefaultOptions
	db, err := Open(opts)
	if err != nil {
		panic(err)
	}
	defer destroyDB(db)

	// 1.正常Put数据并读取
	db.RawPut([]byte("name"), []byte("Jack"))
	db.RawPut([]byte("age"), []byte("18"))
	db.RawPut([]byte("home"), []byte("ZJU China"))

	val, err := db.RawGet([]byte("name"))
	assert.Nil(t, err)
	assert.Equal(t, []byte("Jack"), val)

	val, err = db.RawGet([]byte("home"))
	assert.Nil(t, err)
	assert.Equal(t, []byte("ZJU China"), val)

	// 2.读取unknown key
	_, err = db.RawGet([]byte("unknown"))
	assert.NotNil(t, err)
	assert.Equal(t, ErrKeyNotFound, err)

	// 3.delete再读取
	err = db.RawDelete([]byte("name"))
	assert.Nil(t, err)
	val, err = db.RawGet([]byte("name"))
	assert.NotNil(t, err)
	assert.Equal(t, ErrKeyNotFound, err)

	// 4.update更新key
	val, err = db.RawGet([]byte("age"))
	assert.Nil(t, err)
	assert.Equal(t, []byte("18"), val)

	db.RawPut([]byte("age"), []byte("19"))
	val, err = db.RawGet([]byte("age"))
	assert.Nil(t, err)
	assert.Equal(t, []byte("19"), val)

	// 5.放入empty key
	err = db.RawPut(nil, []byte("hello"))
	assert.NotNil(t, err)
	assert.Equal(t, ErrKeyIsEmpty, err)

	err = db.RawPut([]byte(""), []byte("hello"))
	assert.NotNil(t, err)
	assert.Equal(t, ErrKeyIsEmpty, err)

	// 6.多个数据文件

	//db.Close()
}

func TestDB_Restart(t *testing.T) {
	opts := DefaultOptions
	opts.DataFileMaxSize = 64 * 1024 * 1024
	db, err := Open(opts)
	if err != nil {
		panic(err)
	}
	defer destroyDB(db)

	var val11, val22 []byte
	for i := 0; i < 1000000; i++ {
		key := utils.GetTestKey(i)
		val := utils.RandomValue(128)
		err := db.RawPut(key, val)
		if i == 11 {
			val11 = val
		} else if i == 22 {
			val22 = val
		}
		assert.Nil(t, err)
	}
	assert.Equal(t, 2, len(db.olderFiles))
	// close db
	db.Close()

	// restart db
	db, err = Open(opts)
	val, err := db.RawGet(utils.GetTestKey(11))
	assert.Nil(t, err)
	assert.Equal(t, val11, val)
	val, err = db.RawGet(utils.GetTestKey(22))
	assert.Nil(t, err)
	assert.Equal(t, val22, val)
}

func TestDB_ListKeys(t *testing.T) {
	opts := DefaultOptions
	db, err := Open(opts)
	if err != nil {
		panic(err)
	}
	defer destroyDB(db)

	for i := 0; i < 10; i++ {
		db.RawPut(utils.GetTestKey(i), utils.RandomValue(i))
	}
	keys := db.RawListKeys()
	for i := 0; i < 10; i++ {
		assert.Equal(t, keys[i], utils.GetTestKey(i))
		t.Log(string(keys[i]))
	}
}

func TestDB_Fold(t *testing.T) {
	opts := DefaultOptions
	db, err := Open(opts)
	if err != nil {
		panic(err)
	}
	defer destroyDB(db)

	for i := 0; i < 10; i++ {
		db.RawPut(utils.GetTestKey(i), utils.RandomValue(i))
	}

	var results [][]byte
	fn := func(key []byte, value []byte) bool {
		kv := append(key, []byte(": ")...)
		kv = append(kv, value...)
		results = append(results, kv)
		return true
	}
	db.RawFold(fn)

	for i := 0; i < len(results); i++ {
		t.Log(string(results[i]))
	}
}

func TestDB_Size(t *testing.T) {
	opts := DefaultOptions
	db, err := Open(opts)
	if err != nil {
		panic(err)
	}
	defer destroyDB(db)

	for i := 0; i < 10; i++ {
		assert.Equal(t, i, db.RawSize())
		db.RawPut(utils.GetTestKey(i), utils.RandomValue(i))
	}

	db.RawDelete(utils.GetTestKey(5))
	assert.Equal(t, 9, db.RawSize())
	db.RawDelete(utils.GetTestKey(5))
	assert.Equal(t, 9, db.RawSize())
	db.RawDelete(utils.GetTestKey(3))
	assert.Equal(t, 8, db.RawSize())
}

func TestDB_EncDec(t *testing.T) {
	for i := 0; i < 1000; i++ {
		for seqNo := 0; seqNo < 100; seqNo++ {
			enc := encodeKey(utils.GetTestKey(i), uint64(seqNo))
			rKey, n := decodeKey(enc)
			assert.Equal(t, utils.GetTestKey(i), rKey)
			assert.Equal(t, uint64(seqNo), n)
		}
	}
}