package helpers_test

import (
	"testing"

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

	"go.yandata.net/wangsiyuan/go-trustlog/internal/helpers"
)

func TestMarshalCanonical(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name    string
		input   interface{}
		wantErr bool
	}{
		{
			name:    "string",
			input:   "test",
			wantErr: false,
		},
		{
			name:    "int",
			input:   42,
			wantErr: false,
		},
		{
			name:    "map",
			input:   map[string]interface{}{"key": "value"},
			wantErr: false,
		},
		{
			name:    "slice",
			input:   []string{"a", "b", "c"},
			wantErr: false,
		},
		{
			name:    "struct",
			input:   struct{ Name string }{"test"},
			wantErr: false,
		},
		{
			name:    "nil",
			input:   nil,
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			result, err := helpers.MarshalCanonical(tt.input)
			if tt.wantErr {
				require.Error(t, err)
				assert.Nil(t, result)
			} else {
				require.NoError(t, err)
				assert.NotNil(t, result)
			}
		})
	}
}

func TestMarshalCanonical_Deterministic(t *testing.T) {
	t.Parallel()

	input := map[string]interface{}{
		"key1": "value1",
		"key2": "value2",
		"key3": 123,
	}

	result1, err1 := helpers.MarshalCanonical(input)
	require.NoError(t, err1)

	result2, err2 := helpers.MarshalCanonical(input)
	require.NoError(t, err2)

	// Canonical encoding should produce identical results
	assert.Equal(t, result1, result2)
}

func TestUnmarshal(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name    string
		data    []byte
		target  interface{}
		wantErr bool
	}{
		{
			name:    "string",
			data:    []byte{0x64, 0x74, 0x65, 0x73, 0x74}, // "test" in CBOR
			target:  new(string),
			wantErr: false,
		},
		{
			name:    "int",
			data:    []byte{0x18, 0x2a}, // 42 in CBOR
			target:  new(int),
			wantErr: false,
		},
		{
			name:    "invalid CBOR",
			data:    []byte{0xff, 0xff, 0xff},
			target:  new(string),
			wantErr: true,
		},
		{
			name:    "empty data",
			data:    []byte{},
			target:  new(string),
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			err := helpers.Unmarshal(tt.data, tt.target)
			if tt.wantErr {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}
		})
	}
}

func TestMarshalUnmarshal_RoundTrip(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		input interface{}
	}{
		{
			name:  "string",
			input: "test string",
		},
		{
			name:  "int",
			input: 42,
		},
		{
			name:  "map",
			input: map[string]interface{}{"key": "value"},
		},
		{
			name:  "slice",
			input: []string{"a", "b", "c"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			// Marshal
			data, err := helpers.MarshalCanonical(tt.input)
			require.NoError(t, err)
			require.NotNil(t, data)

			// Unmarshal
			var result interface{}
			err = helpers.Unmarshal(data, &result)
			require.NoError(t, err)

			// Verify
			assert.NotNil(t, result)
		})
	}
}