package dbx

import (
	"encoding/hex"
	"testing"

	"github.com/segmentio/ksuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestParseStringKSUIDAny(t *testing.T) {
	id := ksuid.New()
	stringForm := id.String()
	byteForm := id.Bytes()
	hexForm := hex.EncodeToString(byteForm)

	cases := []struct {
		name string
		src  any
	}{
		{"string", stringForm},
		{"bytes string form", []byte(stringForm)},
		{"bytes binary form", byteForm},
		{"hex", []byte(hexForm)},
		{"ksuid", id},
		{"StringKSUID", StringKSUID{KSUID: id}},
		{"nil", nil},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got, err := ParseStringKSUIDAny(tc.src)
			require.NoError(t, err)
			if tc.src == nil {
				assert.True(t, got.IsZero())
				return
			}
			assert.Equal(t, id.String(), got.String())
		})
	}
}

func TestParseBinaryKSUIDAny(t *testing.T) {
	id := ksuid.New()
	got, err := ParseBinaryKSUIDAny(id.Bytes())
	require.NoError(t, err)
	assert.Equal(t, id.Bytes(), got.Bytes())
}

func TestParseStringKSUIDAny_InvalidType(t *testing.T) {
	_, err := ParseStringKSUIDAny(123)
	assert.Error(t, err)
}

func TestBinaryKSUID_BinExpr(t *testing.T) {
	id := NewBinaryKSUID()
	expr := id.BinExpr()
	require.NotNil(t, expr)

	nilExpr := NilBinaryKSUID.BinExpr()
	require.NotNil(t, nilExpr)
}

func TestExprStringKSUIDs(t *testing.T) {
	a := NewStringKSUID()
	b := NewStringKSUID()
	exprs := ExprStringKSUIDs([]*StringKSUID{&a, &b})
	require.Len(t, exprs, 2)
}