package session

import "io"
import "time"
import "reflect"
import "testing"
import "github.com/google/uuid"
import "git.tebibyte.media/sashakoshka/step"
import "git.tebibyte.media/sashakoshka/go-util/sync"

func TestSession (test *testing.T) {
	future := time.Now().Add(5 * time.Minute)
	sessions := make(sessionMap)
	sessionLocker := usync.NewRWLocker(sessions)
	state := state { sessions: &sessionLocker }
	session, err := state.newSession(uuid.New(), future)
	if err != nil { test.Fatal(err) }

	if len(sessions) != 0 { test.Fatal("incorrect len(sessions):", sessions) }
	_, err = session.Set("some key", "some value")
	if err != nil { test.Fatal(err) }
	if len(sessions) != 1 { test.Fatal("incorrect len(sessions):", sessions) }
	value, err := session.Get("some key")
	if err != nil { test.Fatal(err) }
	if value.(string) != "some value" { test.Fatal("not equal") }
	session.Clear()
	if len(sessions) != 0 { test.Fatal("incorrect len(sessions):", sessions) }
}

func TestEnsafenValue (test *testing.T) {
	items := []any {
		"hello",
		123,
		934.3298,
		'o',
		[]any {
			"asljdkasd",
			"90iur3e",
		},
		map[string] any {
			"asdkiasd": 34,
			"jdjjdfj": '-',
		},
		nil,
	}
	for index, item := range items {
		safe, err := ensafenValue(item)
		if err != nil { test.Fatal(index, err) }
		test.Logf("%d: %v --> %v", index, item, safe)
		if !reflect.DeepEqual(item, safe) {
			test.Fatal("not equal")
		}
		switch item := item.(type) {
		case []any, map[string] any:
			if reflect.ValueOf(item).Pointer() == reflect.ValueOf(safe).Pointer() {
				test.Fatal("memory wasn't duplicated")
			}
		}
	}
}

func TestEnsafenValueErrTypeMismatch (test *testing.T) {
	items := []any {
		[]any {
			"asljdkasd",
			&struct { } { },
			"90iur3e",
		},
		io.EOF,
		[]string {
			"hello",
		},
		map[string] any {
			"asdkiasd": 34,
			"jdjjdfj": struct { } { },
		},
	}
	for index, item := range items {
		safe, err := ensafenValue(item)
		if err != step.ErrTypeMismatch {
			test.Fatalf("%d: no error, produced %v", index, safe)
		}
	}
}