package storage

import (
	"errors"
	"os"
	"path/filepath"
	"reflect"
	"testing"
)

func TestKV(t *testing.T) {
	kv, err := OpenKV(filepath.Join("testdata", "kv"), ':')
	if err != nil {
		t.Skip(err)
		return
	}

	tests := []struct {
		Key   string
		Value any
		OK    bool
	}{
		{"test", "data", true},
		{"empty", "", true},
		{"", "emptykey", true},
		{"nonexistant", nil, false},
		{"ignored line because not relevant", nil, false},
	}
	for _, test := range tests {
		t.Run(test.Key, func(it *testing.T) {
			value, ok := kv.Get(test.Key)
			if ok != test.OK {
				t.Errorf("expected ok %t, got %t", test.OK, ok)
			}
			if ok && !reflect.DeepEqual(value, test.Value) {
				t.Errorf("expected value %v, got %v", test.Value, value)
			}
		})
	}
}

func TestWritableKV(t *testing.T) {
	orgfile := filepath.Join("testdata", "kv")
	b, err := os.ReadFile(orgfile)
	if err != nil {
		t.Skip(err)
	}

	w, err := os.CreateTemp(os.TempDir(), "kv.*")
	if err != nil {
		t.Skip(err)
		return
	}
	testfile := w.Name()
	t.Logf("using a copy of %s as %s", orgfile, testfile)
	defer os.Remove(testfile)

	if _, err = w.Write(b); err != nil {
		return
	}
	if err = w.Close(); err != nil {
		return
	}

	kv, err := OpenWritableKV(testfile, ':', 0640)
	if err != nil {
		t.Skip(err)
		return
	}
	defer kv.Close()

	t.Run("write", func(t *testing.T) {
		writeTests := []struct {
			Key   string
			Value any
			Error error
		}{
			{"test", "newdata", nil},
			{"strings", []string{"test", "data"}, nil},
			{"int", 42, ValueError{Value: 42}},
		}
		for _, test := range writeTests {
			t.Run(test.Key, func(it *testing.T) {
				err := kv.Set(test.Key, test.Value)
				if err != nil {
					if test.Error == nil {
						it.Errorf("unepxected error %q (%T)", err, err)
					} else if !errors.Is(err, test.Error) {
						it.Errorf("expected error %q, but got %q (%T)", test.Error, err, err)
					}
					return
				} else if err == nil && test.Error != nil {
					it.Errorf("expected error %q, but got nil", err)
				}
			})
		}
	})

	t.Run("read", func(t *testing.T) {
		readTests := []struct {
			Key   string
			Value any
			OK    bool
		}{
			{"test", "newdata", true},
			{"empty", "", true},
			{"", "emptykey", true},
			{"strings", []string{"test", "data"}, true},
			{"nonexistant", nil, false},
			{"ignored line because not relevant", nil, false},
		}
		for _, test := range readTests {
			t.Run(test.Key, func(it *testing.T) {
				value, ok := kv.Get(test.Key)
				if ok != test.OK {
					t.Errorf("expected ok %t, got %t", test.OK, ok)
				}
				if ok && !reflect.DeepEqual(value, test.Value) {
					t.Errorf("expected value %v, got %v", test.Value, value)
				}
			})
		}
	})
}