package dbx

import (
	"bytes"
	"encoding/json"
	"io"
	"testing"

	"github.com/go-jet/jet/v2/mysql"
	"github.com/segmentio/ksuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestStringKSUID_ScanValue(t *testing.T) {
	id := NewStringKSUID()
	require.False(t, id.IsNil())

	val, err := id.Value()
	require.NoError(t, err)
	assert.Equal(t, id.String(), val)

	var scanned StringKSUID
	require.NoError(t, scanned.Scan(id.String()))
	assert.Equal(t, id, scanned)

	require.NoError(t, scanned.Scan([]byte(id.String())))
	assert.Equal(t, id, scanned)

	var nilKSUID StringKSUID
	val, err = nilKSUID.Value()
	require.NoError(t, err)
	assert.Nil(t, val)

	require.NoError(t, scanned.Scan(nil))
	assert.True(t, scanned.IsNil())
}

func TestStringKSUID_ScanRejectsBinary(t *testing.T) {
	var s StringKSUID
	err := s.Scan(idBytes(t))
	assert.ErrorContains(t, err, "BinaryKSUID")
}

func TestStringKSUID_Conversion(t *testing.T) {
	s := NewStringKSUID()
	b := s.AsBinaryKSUID()
	assert.Equal(t, s.String(), b.String())
	assert.Equal(t, s.Bytes(), b.Bytes())
	assert.Equal(t, s, b.AsStringKSUID())
}

func TestStringKSUID_GQL(t *testing.T) {
	id := NewStringKSUID()
	wire := assertKSUIDGQLMarshal(t, id)

	var parsed StringKSUID
	require.NoError(t, parsed.UnmarshalGQL(wire))
	assert.Equal(t, id, parsed)
}

func TestBinaryKSUID_GQL(t *testing.T) {
	id := NewBinaryKSUID()
	wire := assertKSUIDGQLMarshal(t, id)

	var parsed BinaryKSUID
	require.NoError(t, parsed.UnmarshalGQL(wire))
	assert.Equal(t, id, parsed)
}

func assertKSUIDGQLMarshal(t *testing.T, id interface{ String() string; MarshalGQL(w io.Writer) }) string {
	t.Helper()

	var buf bytes.Buffer
	id.MarshalGQL(&buf)

	var wire string
	require.NoError(t, json.Unmarshal(buf.Bytes(), &wire))
	assert.Equal(t, id.String(), wire)
	return wire
}

func TestBinaryKSUID_ScanValue(t *testing.T) {
	id := NewBinaryKSUID()
	require.False(t, id.IsNil())

	val, err := id.Value()
	require.NoError(t, err)
	assert.Equal(t, id.Bytes(), val)

	var scanned BinaryKSUID
	require.NoError(t, scanned.Scan(id.Bytes()))
	assert.Equal(t, id, scanned)

	var nilKSUID BinaryKSUID
	val, err = nilKSUID.Value()
	require.NoError(t, err)
	assert.Nil(t, val)

	require.NoError(t, scanned.Scan(nil))
	assert.True(t, scanned.IsNil())
}

func TestBinaryKSUID_ScanRejectsStringEncoding(t *testing.T) {
	s := NewStringKSUID()
	var b BinaryKSUID
	err := b.Scan([]byte(s.String()))
	assert.ErrorContains(t, err, "StringKSUID")

	err = b.Scan(s.String())
	assert.ErrorContains(t, err, "StringKSUID")
}

func TestBinaryKSUID_Conversion(t *testing.T) {
	b := NewBinaryKSUID()
	s := b.AsStringKSUID()
	assert.Equal(t, b.String(), s.String())
	assert.Equal(t, b, s.AsBinaryKSUID())
}


func TestStringKSUID_EqualIsZero(t *testing.T) {
	id := NewStringKSUID()
	assert.True(t, NilStringKSUID.Equal(NilStringKSUID))
	assert.True(t, id.Equal(id))
	assert.False(t, id.Equal(NilStringKSUID))
	assert.True(t, NilStringKSUID.IsZero())
	assert.False(t, id.IsZero())
}

func TestBinaryKSUID_EqualIsZero(t *testing.T) {
	id := NewBinaryKSUID()
	assert.True(t, NilBinaryKSUID.Equal(NilBinaryKSUID))
	assert.True(t, id.Equal(id))
	assert.False(t, id.Equal(NilBinaryKSUID))
	assert.True(t, NilBinaryKSUID.IsZero())
	assert.False(t, id.IsZero())
}

func TestStringKSUID_ApplyInterfacePtr(t *testing.T) {
	targetCol := mysql.StringColumn("id")
	modified := make(ColumnList, 0)
	current := Ptr(NewStringKSUID())
	updated := ApplyInterfacePtr(current, Ptr(NewStringKSUID()), &modified, targetCol)
	require.NotNil(t, updated)
	assert.Len(t, modified, 1)
	assert.False(t, current.Equal(*updated))
}

func TestParseStringKSUID(t *testing.T) {
	id := ksuid.New()
	parsed, err := ParseStringKSUID(id.String())
	require.NoError(t, err)
	assert.Equal(t, id.String(), parsed.String())
}

func TestParseBinaryKSUID(t *testing.T) {
	id := ksuid.New()
	parsed, err := ParseBinaryKSUID(id.Bytes())
	require.NoError(t, err)
	assert.Equal(t, id.Bytes(), parsed.Bytes())
}

func idBytes(t *testing.T) []byte {
	t.Helper()
	return ksuid.New().Bytes()
}