package codec

import (
	"testing"

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

func TestJSONCodec(t *testing.T) {
	codec := NewJSONCodec()

	// 测试名称
	assert.Equal(t, "json", codec.Name(), "Expected name to be 'json'")

	// 测试编码
	type TestStruct struct {
		Name  string `json:"name"`
		Value int    `json:"value"`
	}

	data := TestStruct{
		Name:  "test",
		Value: 42,
	}

	encoded, err := codec.Encode(data)
	require.NoError(t, err, "Expected no error when encoding")
	assert.NotEmpty(t, encoded, "Expected encoded data to be non-empty")

	// 测试解码
	var decoded TestStruct
	err = codec.Decode(encoded, &decoded)
	require.NoError(t, err, "Expected no error when decoding")
	assert.Equal(t, data.Name, decoded.Name, "Expected name to match")
	assert.Equal(t, data.Value, decoded.Value, "Expected value to match")
}

func TestJSONCodecEncodePrimitives(t *testing.T) {
	codec := NewJSONCodec()

	// 测试编码字符串
	encoded, err := codec.Encode("hello")
	require.NoError(t, err)
	assert.Equal(t, `"hello"`, string(encoded))

	// 测试编码数字
	encoded, err = codec.Encode(42)
	require.NoError(t, err)
	assert.Equal(t, "42", string(encoded))

	// 测试编码布尔值
	encoded, err = codec.Encode(true)
	require.NoError(t, err)
	assert.Equal(t, "true", string(encoded))
}

func TestJSONCodecDecodePrimitives(t *testing.T) {
	codec := NewJSONCodec()

	// 测试解码字符串
	var str string
	err := codec.Decode([]byte(`"hello"`), &str)
	require.NoError(t, err)
	assert.Equal(t, "hello", str)

	// 测试解码数字
	var num int
	err = codec.Decode([]byte("42"), &num)
	require.NoError(t, err)
	assert.Equal(t, 42, num)

	// 测试解码布尔值
	var b bool
	err = codec.Decode([]byte("true"), &b)
	require.NoError(t, err)
	assert.True(t, b)
}

func TestJSONCodecInvalidJSON(t *testing.T) {
	codec := NewJSONCodec()

	// 测试无效的JSON
	var result interface{}
	err := codec.Decode([]byte("invalid json"), &result)
	assert.Error(t, err, "Expected error for invalid JSON")
}

func TestJSONCodecEncodeNil(t *testing.T) {
	codec := NewJSONCodec()

	// 测试编码nil
	encoded, err := codec.Encode(nil)
	require.NoError(t, err)
	assert.Equal(t, "null", string(encoded))
}

func TestJSONCodecComplexStruct(t *testing.T) {
	codec := NewJSONCodec()

	type ComplexStruct struct {
		Name     string            `json:"name"`
		Age      int               `json:"age"`
		Tags     []string          `json:"tags"`
		Metadata map[string]string `json:"metadata"`
	}

	data := ComplexStruct{
		Name: "John",
		Age:  30,
		Tags: []string{"tag1", "tag2"},
		Metadata: map[string]string{
			"key1": "value1",
			"key2": "value2",
		},
	}

	encoded, err := codec.Encode(data)
	require.NoError(t, err)

	var decoded ComplexStruct
	err = codec.Decode(encoded, &decoded)
	require.NoError(t, err)
	assert.Equal(t, data.Name, decoded.Name)
	assert.Equal(t, data.Age, decoded.Age)
	assert.Equal(t, data.Tags, decoded.Tags)
	assert.Equal(t, data.Metadata, decoded.Metadata)
}