package cursortoken

import (
	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
	"strings"
	"testing"
	"time"
)

func TestStartToken(t *testing.T) {
	tok := Start()
	tst.AssertEqual(t, tok.Token(), "@start")
	tst.AssertTrue(t, tok.IsStart())
	tst.AssertFalse(t, tok.IsEnd())
}

func TestEndToken(t *testing.T) {
	tok := End()
	tst.AssertEqual(t, tok.Token(), "@end")
	tst.AssertTrue(t, tok.IsEnd())
	tst.AssertFalse(t, tok.IsStart())
}

func TestNewKeySortTokenBasic(t *testing.T) {
	tok := NewKeySortToken("alpha", "beta", SortASC, SortDESC, 50, Extra{})
	tst.AssertFalse(t, tok.IsEnd())
	tst.AssertFalse(t, tok.IsStart())
	str := tok.Token()
	tst.AssertTrue(t, strings.HasPrefix(str, "tok_"))
}

func TestNewKeySortTokenRoundTrip(t *testing.T) {
	original := NewKeySortToken("primary-val", "secondary-val", SortASC, SortDESC, 25, Extra{})
	encoded := original.Token()

	decoded, err := Decode(encoded)
	tst.AssertNoErr(t, err)

	ks, ok := decoded.(CTKeySort)
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, ks.ValuePrimary, "primary-val")
	tst.AssertEqual(t, ks.ValueSecondary, "secondary-val")
	tst.AssertEqual(t, ks.Direction, SortASC)
	tst.AssertEqual(t, ks.DirectionSecondary, SortDESC)
	tst.AssertEqual(t, ks.PageSize, 25)
	tst.AssertEqual(t, ks.Mode, CTMNormal)
}

func TestKeySortTokenWithExtra(t *testing.T) {
	ts := time.Date(2024, 6, 15, 10, 30, 0, 0, time.UTC)
	id := "object-id-123"
	page := 7
	pageSize := 42

	original := NewKeySortToken("p", "s", SortDESC, SortASC, 10, Extra{
		Timestamp: &ts,
		Id:        &id,
		Page:      &page,
		PageSize:  &pageSize,
	})
	encoded := original.Token()

	decoded, err := Decode(encoded)
	tst.AssertNoErr(t, err)

	ks, ok := decoded.(CTKeySort)
	tst.AssertTrue(t, ok)
	tst.AssertTrue(t, ks.Extra.Timestamp != nil)
	tst.AssertTrue(t, ks.Extra.Timestamp.Equal(ts))
	tst.AssertDeRefEqual(t, ks.Extra.Id, "object-id-123")
	tst.AssertDeRefEqual(t, ks.Extra.Page, 7)
	tst.AssertDeRefEqual(t, ks.Extra.PageSize, 42)
}

func TestKeySortTokenStartRoundTrip(t *testing.T) {
	original := Start()
	decoded, err := Decode(original.Token())
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, decoded.IsStart())
	tst.AssertFalse(t, decoded.IsEnd())
}

func TestKeySortTokenEndRoundTrip(t *testing.T) {
	original := End()
	decoded, err := Decode(original.Token())
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, decoded.IsEnd())
	tst.AssertFalse(t, decoded.IsStart())
}

func TestKeySortTokenEmptyValues(t *testing.T) {
	tok := CTKeySort{Mode: CTMNormal}
	encoded := tok.Token()
	tst.AssertTrue(t, strings.HasPrefix(encoded, "tok_"))

	decoded, err := Decode(encoded)
	tst.AssertNoErr(t, err)

	ks, ok := decoded.(CTKeySort)
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, ks.ValuePrimary, "")
	tst.AssertEqual(t, ks.ValueSecondary, "")
	tst.AssertEqual(t, ks.Direction, SortDirection(""))
	tst.AssertEqual(t, ks.DirectionSecondary, SortDirection(""))
	tst.AssertEqual(t, ks.PageSize, 0)
}

func TestKeySortTokenOnlyTimestamp(t *testing.T) {
	ts := time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC)
	tok := CTKeySort{
		Mode:  CTMNormal,
		Extra: Extra{Timestamp: &ts},
	}

	decoded, err := Decode(tok.Token())
	tst.AssertNoErr(t, err)

	ks, ok := decoded.(CTKeySort)
	tst.AssertTrue(t, ok)
	tst.AssertTrue(t, ks.Extra.Timestamp != nil)
	tst.AssertTrue(t, ks.Extra.Timestamp.Equal(ts))
	tst.AssertTrue(t, ks.Extra.Id == nil)
	tst.AssertTrue(t, ks.Extra.Page == nil)
	tst.AssertTrue(t, ks.Extra.PageSize == nil)
}

func TestKeySortTokenSpecialChars(t *testing.T) {
	original := NewKeySortToken("hello world / @!#$%", "äöü€", SortASC, SortASC, 1, Extra{})
	decoded, err := Decode(original.Token())
	tst.AssertNoErr(t, err)

	ks, ok := decoded.(CTKeySort)
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, ks.ValuePrimary, "hello world / @!#$%")
	tst.AssertEqual(t, ks.ValueSecondary, "äöü€")
}