package cursortoken

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

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

func TestDecodeAtStart(t *testing.T) {
	tok, err := Decode("@start")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsStart())
	tst.AssertFalse(t, tok.IsEnd())
}

func TestDecodeAtStartUppercase(t *testing.T) {
	tok, err := Decode("@START")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsStart())
}

func TestDecodeAtStartMixedCase(t *testing.T) {
	tok, err := Decode("@StArT")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsStart())
}

func TestDecodeAtEnd(t *testing.T) {
	tok, err := Decode("@end")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsEnd())
	tst.AssertFalse(t, tok.IsStart())
}

func TestDecodeAtEndUppercase(t *testing.T) {
	tok, err := Decode("@END")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsEnd())
}

func TestDecodeDollarEnd(t *testing.T) {
	tok, err := Decode("$end")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsEnd())
	_, ok := tok.(CTPaginated)
	tst.AssertTrue(t, ok)
}

func TestDecodeDollarEndUppercase(t *testing.T) {
	tok, err := Decode("$END")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsEnd())
}

func TestDecodeDollarPage(t *testing.T) {
	tok, err := Decode("$5")
	tst.AssertNoErr(t, err)
	pg, ok := tok.(CTPaginated)
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, pg.Page, 5)
	tst.AssertEqual(t, pg.Mode, CTMNormal)
}

func TestDecodeDollarPageOne(t *testing.T) {
	tok, err := Decode("$1")
	tst.AssertNoErr(t, err)
	tst.AssertTrue(t, tok.IsStart())
	pg, ok := tok.(CTPaginated)
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, pg.Page, 1)
}

func TestDecodeDollarPageInvalid(t *testing.T) {
	_, err := Decode("$abc")
	if err == nil {
		t.Fatalf("expected error for invalid page")
	}
}

func TestDecodeUnknownPrefix(t *testing.T) {
	_, err := Decode("foobar")
	if err == nil {
		t.Fatalf("expected error for unknown prefix")
	}
}

func TestDecodeInvalidBase32(t *testing.T) {
	_, err := Decode("tok_!!!")
	if err == nil {
		t.Fatalf("expected error for invalid base32 body")
	}
}

func TestDecodeInvalidJSON(t *testing.T) {
	// "tok_" prefix with valid base32 but invalid JSON content
	_, err := Decode("tok_NBSWY3DP")
	if err == nil {
		t.Fatalf("expected error for invalid json body")
	}
}

func TestDecodeJustDollar(t *testing.T) {
	// "$" alone (length == 1) should fall through to the unknown-prefix branch
	_, err := Decode("$")
	if err == nil {
		t.Fatalf("expected error for bare $")
	}
}

func TestDecodeKnownTokenContent(t *testing.T) {
	tok := NewKeySortToken("k1", "k2", SortASC, SortDESC, 33, Extra{})
	encoded := tok.Token()

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

	tst.AssertEqual(t, decoded.Token(), encoded)
}